Source Code for Module fabio.fabioutils

  1  import re, os 
  2   
  3 -def construct_filename(*args, **kwds): 
  4      raise Exception("You probably want fabio.jump_filename") 
  5   
  6   
  7   
  8  FILETYPES = { 
  9      # extension NNNimage fabioclass 
 10      # type consistency - always use a list if one case is 
 11      'edf'    : ['edf'], 
 12      'cor'    : ['edf'], 
 13      'pnm'    : ['pnm'], 
 14      'pgm'    : ['pnm'], 
 15      'pbm'    : ['pnm'], 
 16      'tif'    : ['tif'], 
 17      'tiff'   : ['tif'], 
 18      'img'    : ['adsc', 'OXD', 'HiPiC'], 
 19      'mccd'   : ['marccd'], 
 20      'mar2300': ['mar345'], 
 21      'sfrm'   : ['bruker100'], 
 22      'msk'    : ['fit2dmask'], 
 23      'spr'    : ['fit2dspreadsheet'], 
 24      'dm3'    : ['dm3'], 
 25      'kcd'    : ['kcd'], 
 26      'cbf'    : ['cbf'], 
 27      'xml'    : ["xsd"], 
 28      'xsd'    : ["xsd"], 
 29               } 
 30   
 31  # Add bzipped and gzipped 
 32  for key in FILETYPES.keys(): 
 33      FILETYPES[key + ".bz2"] = FILETYPES[key] 
 34      FILETYPES[key + ".gz"] = FILETYPES[key] 
 35   
 36   
 37  # Compressors 
 38   
 39  COMPRESSORS = {} 
 40   
 41  try: 
 42      lines = os.popen("gzip -h 2>&1").read() 
 43      # Looking for "usage" 
 44      if "sage" in lines: 
 45          COMPRESSORS['.gz'] = 'gzip -dc ' 
 46      else: 
 47          COMPRESSORS['.gz'] = None 
 48  except: 
 49      COMPRESSORS['.gz'] = None 
 50   
 51  try: 
 52      lines = os.popen("bzip2 -h 2>&1").read() 
 53      # Looking for "usage"  
 54      if "sage" in lines: 
 55          COMPRESSORS['.bz2'] = 'bzip2 -dc ' 
 56      else: 
 57          COMPRESSORS['.bz2'] = None 
 58  except: 
 59      COMPRESSORS['.bz2'] = None 
 60   
 61  # print COMPRESSORS 
 62   
 63 -def getnum(name): 
 64      """ 
 65      # try to figure out a file number 
 66      # guess it starts at the back 
 67      """ 
 68      stem , num, post_num = numstem(name) 
 69      try: 
 70          return int(num) 
 71      except ValueError: 
 72          return None 
 73   
 74 -class filename_object: 
 75      """ 
 76      The 'meaning' of a filename 
 77      """ 
 78 -    def __init__(self, stem, 
 79              num=None, 
 80              directory=None, 
 81              format=None, 
 82              extension=None, 
 83              postnum=None, 
 84              digits=4): 
 85          self.stem = stem 
 86          self.num = num 
 87          self.format = format 
 88          self.extension = extension 
 89          self.digits = digits 
 90          self.postnum = postnum 
 91          self.directory = directory 
 92          #print self.str() 
 93   
 94 -    def str(self): 
 95          """ Return a string representation """ 
 96          fmt = "stem %s, num %s format %s extension %s " + \ 
 97                  "postnum = %s digits %s dir %s" 
 98          return fmt % tuple([str(x) for x in [ 
 99                      self.stem , 
100                      self.num , 
101                      self.format , 
102                      self.extension , 
103                      self.postnum , 
104                      self.digits , 
105                      self.directory ] ]) 
106   
107   
108 -    def tostring(self): 
109          """ 
110          convert yourself to a string 
111          """ 
112          name = self.stem 
113          if self.digits is not None and self.num is not None: 
114              fmt = "%0" + str(self.digits) + "d" 
115              name += fmt % self.num 
116          if self.postnum is not None: 
117              name += self.postnum 
118          if self.extension is not None: 
119              name += self.extension 
120          if self.directory is not None: 
121              name = os.path.join(self.directory, name) 
122          return name 
123   
124   
125 -def numstem(name): 
126      """ cant see how to do without reversing strings 
127      Match 1 or more digits going backwards from the end of the string 
128      """ 
129      reg = re.compile(r"^(.*?)(-?[0-9]{0,9})(\D*)$") 
130      #reg = re.compile("""(\D*)(\d\d*)(\w*)""") 
131      try: 
132          res = reg.match(name).groups() 
133          #res = reg.match(name[::-1]).groups() 
134          #return [ r[::-1] for r in res[::-1]] 
135          if len(res[0]) == len(res[1]) == 0: # Hack for file without number  
136              return [res[2], '', ''] 
137          return [ r for r in res] 
138      except AttributeError: # no digits found 
139          return [name, "", ""] 
140   
141 -def deconstruct_filename(filename): 
142      """ 
143      Break up a filename to get image type and number 
144      """ 
145      direc , name = os.path.split(filename) 
146      if len(direc) == 0: 
147          direc = None 
148      parts = os.path.split(name)[-1].split(".") 
149      # loop back from end 
150      compressed = False 
151      extn = "" 
152      postnum = "" 
153      ndigit = 4 
154      if parts[-1] in ["gz", "bz2"]: 
155          extn = "." + parts[-1] 
156          parts = parts[:-1] 
157          compressed = True 
158      if parts[-1] in FILETYPES.keys(): 
159          typ = FILETYPES[parts[-1]] 
160          extn = "." + parts[-1] + extn 
161          try: 
162              stem , numstring, postnum = numstem(".".join(parts[:-1])) 
163              num = int(numstring) 
164              ndigit = len(numstring) 
165          except: 
166              # There is no number - hence make num be None, not 0 
167              num = None 
168              stem = "".join(parts[:-1]) 
169      else: 
170          # Probably two type left 
171          if len(parts) == 1: 
172              # Probably GE format stem_numb 
173              parts2 = parts[0].split("_") 
174              try: 
175                  num = int(parts2[-1]) 
176                  ndigit = len(parts2[-1]) 
177                  typ = ['GE'] 
178                  stem = "_".join(parts2[:-1]) + "_" 
179              except: 
180                  pass 
181          else: 
182              try: 
183                  num = int(parts[-1]) 
184                  ndigit = len(parts[-1]) 
185                  typ = ['bruker'] 
186                  stem = ".".join(parts[:-1]) + "." 
187              except: 
188                  typ = None 
189                  extn = "." + parts[-1] + extn 
190                  try: 
191                      stem , numstring, postnum = numstem(".".join(parts[:-1])) 
192                      num = int(numstring) 
193                      ndigit = len(numstring) 
194                  except: 
195                      raise 
196              #            raise Exception("Cannot decode "+filename) 
197      obj = filename_object(stem, 
198              num=num, 
199              directory=direc, 
200              format=typ, 
201              extension=extn, 
202              postnum=postnum, 
203              digits=ndigit) 
204   
205      return obj 
206   
207   
208 -def next_filename(name, padding=True): 
209      """ increment number """ 
210      obj = deconstruct_filename(name) 
211      obj.num += 1 
212      if not padding: 
213          obj.digits = 0 
214      return obj.tostring() 
215   
216 -def previous_filename(name, padding=True): 
217      """ decrement number """ 
218      obj = deconstruct_filename(name) 
219      obj.num -= 1 
220      if not padding: 
221          obj.digits = 0 
222      return obj.tostring() 
223   
224 -def jump_filename(name, num, padding=True): 
225      """ jump to number """ 
226      obj = deconstruct_filename(name) 
227      obj.num = num 
228      if not padding: 
229          obj.digits = 0 
230      return obj.tostring() 
231   
232   
233 -def extract_filenumber(name): 
234      """ extract file number """ 
235      obj = deconstruct_filename(name) 
236      return obj.num 
237