src/model/model.py

   1 import os,re,sys
   2 import config.config
   3 import inout.io
   4 from inout.io import write
   5
   6 from time import *
   7 from observable import *
   8 from log.logging import logger
   9 from config.config import *
  10 from inout.io import *
  11 from inout import io
  12 #logger.log(u'new version')
  13
  14
  15
  16
  17 def invert_dictionary(dictionary):
  18         return dict([[v,k] for k,v in dictionary.items()])
  19
  20 def no_transition_policy(self,owner):
  21         return self
  22
  23
  24
  25 class Status(object):
  26     symbols = {}
  27     names = {}
  28     def __init__(self,name,value=0,symbol=u'',transition_policy=no_transition_policy):
  29         self.name = name
  30         self.value = value
  31         self.symbol = symbol
  32         Status.symbols[symbol] = self
  33         Status.names[name] = self
  34         self.transition_policy = transition_policy
  35
  36     def __eq__(self,other):
  37 #       print "Called eq with %s (%s) and %s (%s)"%(repr(self),type(self),repr(other),type(other))
  38 #       if self == other:
  39 #               return True
  40         if (not self and other) or (not other and self):
  41                 return False
  42         return self.name == other.name #and self.value == other.value and type(self) == type(other)
  43
  44     def __cmp__(self,other):
  45         if not other:
  46             return 1
  47         return other.value - self.value
  48
  49     def __str__(self):
  50         return self.name
  51
  52     def __repr__(self):
  53         return "%s %s %s (%s)"%(type(self),self.value, self.name,id(self))
  54
  55     def symbol(self):
  56         return self.symbol
  57
  58     def get_status(symbol):
  59         return Status.symbols[symbol]
  60     get_status = staticmethod(get_status)
  61
  62     def get_status_for_name(name):
  63         return Status.names[name]
  64     get_status_for_name = staticmethod(get_status_for_name)
  65
  66     def update(self,owner):
  67         return self.transition_policy(self,owner)
  68
  69
  70
  71 class ItemWithStatus(object):
  72         def __init__(self,status):
  73                 self.status = status
  74
  75         def status_symbol(self):
  76                 if self.status.symbol and len(self.status.symbol) > 0:
  77                         return self.status.symbol + u' '
  78                 else:
  79                         return u''
  80
  81 class WriteableItem(ObservableItem):
  82         def __init__(self):
  83                 super(WriteableItem, self).__init__()
  84         def write(self):
  85                 write(self.path(),self.file_string())
  86         def move_to(self,directory,old_dir=None):
  87                 new_file_name = os.path.join(directory,self.file_name())
  88                 if old_dir == None:
  89                         old_dir = self.directory()
  90                 old_file_name = os.path.join(old_dir,self.file_name())
  91                 try:
  92                         os.renames(io.os_encode(old_file_name),io.os_encode(new_file_name))
  93                         ##logger.log(u'Moved %s to %s'%(repr(old_file_name),repr(new_file_name)))
  94                         #print u'Moved %s to %s'%(repr(old_file_name),repr(new_file_name))
  95                         logger.log(u'Moved %s to %s'%(repr(old_file_name),repr(new_file_name)))
  96                         return new_file_name
  97                 except OSError,e:
  98                         logger.log(u'Cannot move %s to %s: %s'%(repr(old_file_name),repr(new_file_name),e.strerror))
  99                         raise e
 100
 101
 102         def directory(self):
 103                 return io.os_decode(os.path.dirname(self.encoded_path()))
 104         def file_name(self):
 105                 return io.os_decode(os.path.basename(self.encoded_path()))
 106         def remove(self,path=None):
 107                 if not path:
 108                         encoded_path = self.encoded_path()
 109                 else:
 110                         encoded_path = io.os_encode(path)
 111                 if os.path.isfile(encoded_path):
 112                         os.remove(encoded_path)
 113         def exists(self):
 114                 return os.path.isfile(self.encoded_path())
 115
 116         def encoded_path(self):
 117                 return io.os_encode(self.path())
 118
 119         def extension(self):
 120                 return os.path.splitext(self.encoded_path())[1]
 121         def rename(self,new_name,old=None):
 122                 if not old:
 123                         old = io.os_decode(os.path.splitext(os.path.basename(self.encoded_path()))[0])
 124                 directory = io.os_encode(self.directory())
 125                 extension = io.os_encode(self.extension())
 126                 old_filename_encoded = io.os_encode(old)
 127                 new_file_name = os.path.join(directory,io.os_encode(new_name)+extension)
 128                 old_file_name = os.path.join(directory,old_filename_encoded+extension)
 129                 #logger.log(u'Renaming %s to %s'%(old_file_name,new_file_name))
 130                 os.renames(old_file_name,new_file_name)
 131
 132         def notify(self,action,attribute,new=None,old=None):
 133                 self.write()
 134
 135 # Public API
 136 __all__= (
 137                 'WriteableItem',
 138                 'ItemWithStatus',
 139                 'ObservableItem',
 140                 'invert_dictionary',
 141                 'Status'
 142
 143                   )