home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / hplip / pcard / photocard.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2007-04-29  |  18.8 KB  |  716 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import struct
  5. import time
  6. import fnmatch
  7. import mimetypes
  8. import array
  9. from base.g import *
  10. from base.codes import *
  11. from base import device, utils, exif
  12. import pcardext
  13. ACK = 256
  14. NAK = 257
  15. READ_CMD = 16
  16. WRITE_CMD = 32
  17. SECTOR_SIZE = 512
  18. MAX_CACHE = 512
  19. INITIAL_PCARDFILE_BUFFER = 20 * SECTOR_SIZE
  20. INCREMENTAL_PCARDFILE_BUFFER = 2 * SECTOR_SIZE
  21.  
  22. class PhotoCardFile:
  23.     
  24.     def __init__(self, pc, name = None):
  25.         self.pos = 0
  26.         self.closed = True
  27.         self.file_size = 0
  28.         self.pc = pc
  29.         self.buffer = array.array('c')
  30.         if name is not None:
  31.             self.open(name)
  32.         
  33.         self.buffer_size = INITIAL_PCARDFILE_BUFFER
  34.         self.buffer.fromstring(pcardext.read(self.name, 0, self.buffer_size))
  35.  
  36.     
  37.     def open(self, name):
  38.         self.closed = False
  39.         self.name = name
  40.  
  41.     
  42.     def seek(self, offset, whence = 0):
  43.         if whence == 0:
  44.             self.pos = offset
  45.         elif whence == 1:
  46.             self.pos += offset
  47.         elif whence == 2:
  48.             self.pos = self.file_size - offset
  49.         else:
  50.             return None
  51.  
  52.     
  53.     def tell(self):
  54.         return self.pos
  55.  
  56.     
  57.     def read(self, size):
  58.         if size > 0:
  59.             if self.pos + size < self.buffer_size:
  60.                 data = self.buffer[self.pos:self.pos + size].tostring()
  61.                 self.pos += size
  62.                 return data
  63.             else:
  64.                 while self.pos + size >= self.buffer_size:
  65.                     self.buffer.fromstring(pcardext.read(self.name, self.buffer_size, INCREMENTAL_PCARDFILE_BUFFER))
  66.                     self.buffer_size += INCREMENTAL_PCARDFILE_BUFFER
  67.                     continue
  68.                     self
  69.                 return self.read(size)
  70.         
  71.  
  72.     
  73.     def close(self):
  74.         self.closed = True
  75.         self.pos = 0
  76.  
  77.  
  78.  
  79. class PhotoCard:
  80.     
  81.     def __init__(self, dev_obj = None, device_uri = None, printer_name = None):
  82.         if dev_obj is None:
  83.             self.device = device.Device(device_uri, printer_name)
  84.             self.device.open()
  85.             self.close_device = True
  86.         else:
  87.             self.device = dev_obj
  88.             self.close_device = False
  89.         self.dir_stack = utils.Stack()
  90.         self.current_dir = []
  91.         self.device_uri = self.device.device_uri
  92.         self.pcard_mounted = False
  93.         self.saved_pwd = []
  94.         self.sector_buffer = { }
  95.         self.sector_buffer_counts = { }
  96.         self.cache_flag = True
  97.         self.write_protect = False
  98.         self.callback = None
  99.         self.channel_opened = False
  100.  
  101.     
  102.     def START_OPERATION(self, name = ''):
  103.         pass
  104.  
  105.     
  106.     def END_OPERATION(self, name = '', flag = True):
  107.         if self.channel_opened and flag:
  108.             self.close_channel()
  109.         
  110.  
  111.     
  112.     def set_callback(self, callback):
  113.         self.callback = callback
  114.  
  115.     
  116.     def _read(self, sector, nsector):
  117.         log.debug('read pcard sector: sector=%d count=%d' % (sector, nsector))
  118.         if self.cache_flag:
  119.             for s in range(sector, sector + nsector):
  120.                 if s not in self.sector_buffer:
  121.                     break
  122.                     continue
  123.             else:
  124.                 buffer = ''
  125.                 for s in range(sector, sector + nsector):
  126.                     buffer = ''.join([
  127.                         buffer,
  128.                         self.sector_buffer[s]])
  129.                     log.debug('Cached sector read sector=%d' % s)
  130.                     count = self.sector_buffer_counts[s]
  131.                     self.sector_buffer_counts[s] = count + 1
  132.                     if self.callback is not None:
  133.                         self.callback()
  134.                         continue
  135.                 
  136.                 return buffer
  137.         
  138.         if self.callback is not None:
  139.             self.callback()
  140.         
  141.         if not self.channel_opened:
  142.             self.open_channel()
  143.         
  144.         log.debug('Normal sector read sector=%d count=%d' % (sector, nsector))
  145.         sectors_to_read = range(sector, sector + nsector)
  146.         request = struct.pack('!HH' + 'I' * nsector, READ_CMD, nsector, *sectors_to_read)
  147.         if self.callback is not None:
  148.             self.callback()
  149.         
  150.         bytes_written = self.device.writePCard(request)
  151.         log.debug('%d bytes written' % bytes_written)
  152.         data = self.device.readPCard(2)
  153.         code = struct.unpack('!H', data)[0]
  154.         log.debug('Return code: %x' % code)
  155.         if code == 272:
  156.             data = self.device.readPCard(6)
  157.             (nsector_read, ver) = struct.unpack('!IH', data)
  158.             log.debug('code=0x%x, nsector=%d, ver=%d' % (code, nsector_read, ver))
  159.             buffer = ''
  160.             data_read = 0
  161.             total_to_read = nsector * SECTOR_SIZE
  162.             while data_read < total_to_read:
  163.                 data = self.device.readPCard(total_to_read)
  164.                 data_read += len(data)
  165.                 buffer = ''.join([
  166.                     buffer,
  167.                     data])
  168.                 if self.callback is not None:
  169.                     self.callback()
  170.                     continue
  171.             if self.cache_flag:
  172.                 i = 0
  173.                 for s in range(sector, sector + nsector_read):
  174.                     self.sector_buffer[s] = buffer[i:i + SECTOR_SIZE]
  175.                     log.debug('Sector %d data=\n%s' % (s, repr(self.sector_buffer[s])))
  176.                     count = self.sector_buffer_counts.get(s, 0)
  177.                     self.sector_buffer_counts[s] = count + 1
  178.                     i += SECTOR_SIZE
  179.                     if self.callback is not None:
  180.                         self.callback()
  181.                         continue
  182.                 
  183.                 self._check_cache(nsector)
  184.             
  185.             return buffer
  186.         else:
  187.             log.error('Error code: %d' % code)
  188.             return ''
  189.  
  190.     
  191.     def _write(self, sector, nsector, buffer):
  192.         log.debug('write pcard sector: sector=%d count=%d len=%d data=\n%s' % (sector, nsector, len(buffer), repr(buffer)))
  193.         if not self.channel_opened:
  194.             self.open_channel()
  195.         
  196.         sectors_to_write = range(sector, sector + nsector)
  197.         request = struct.pack('!HHH' + 'I' * nsector, WRITE_CMD, nsector, 0, *sectors_to_write)
  198.         request = ''.join([
  199.             request,
  200.             buffer])
  201.         if self.callback is not None:
  202.             self.callback()
  203.         
  204.         self.device.writePCard(request)
  205.         data = self.device.readPCard(2)
  206.         if self.callback is not None:
  207.             self.callback()
  208.         
  209.         code = struct.unpack('!H', data)[0]
  210.         if code != NAK:
  211.             if self.cache_flag:
  212.                 i = 0
  213.                 for s in range(sector, sector + nsector):
  214.                     log.debug('Caching sector %d' % sector)
  215.                     self.sector_buffer[s] = buffer[i:i + SECTOR_SIZE]
  216.                     self.sector_buffer_counts[s] = 1
  217.                     i += SECTOR_SIZE
  218.                 
  219.                 if self.callback is not None:
  220.                     self.callback()
  221.                 
  222.                 self._check_cache(nsector)
  223.             
  224.             return 0
  225.         elif self.cache_flag:
  226.             for s in range(sector, sector + nsector):
  227.                 
  228.                 try:
  229.                     del self.sector_buffer[s]
  230.                     del self.sector_buffer_counts[s]
  231.                 continue
  232.                 except KeyError:
  233.                     continue
  234.                 
  235.  
  236.             
  237.         
  238.         log.error('Photo card write failed (Card may be write protected)')
  239.         self.close_channel()
  240.         return 1
  241.  
  242.     
  243.     def _check_cache(self, nsector):
  244.         if len(self.sector_buffer) > MAX_CACHE:
  245.             t = self.sector_buffer.keys()[:]
  246.             n = 0
  247.             for s in t:
  248.                 if self.sector_buffer_counts[s] == 1:
  249.                     del self.sector_buffer[s]
  250.                     del self.sector_buffer_counts[s]
  251.                     n += 1
  252.                     if n >= nsector:
  253.                         break
  254.                     
  255.                     if self.callback is not None:
  256.                         self.callback()
  257.                     
  258.                 self.callback is not None
  259.             
  260.         
  261.  
  262.     
  263.     def cache_info(self):
  264.         return self.sector_buffer_counts
  265.  
  266.     
  267.     def cache_check(self, sector):
  268.         return self.sector_buffer_counts.get(sector, 0)
  269.  
  270.     
  271.     def cache_control(self, control):
  272.         self.cache_flag = control
  273.         if not self.cache_flag:
  274.             self.cache_reset()
  275.         
  276.  
  277.     
  278.     def cache_state(self):
  279.         return self.cache_flag
  280.  
  281.     
  282.     def cache_reset(self):
  283.         self.sector_buffer.clear()
  284.         self.sector_buffer_counts.clear()
  285.  
  286.     
  287.     def df(self):
  288.         df = 0
  289.         self.START_OPERATION('df')
  290.         
  291.         try:
  292.             df = pcardext.df()
  293.         finally:
  294.             self.END_OPERATION('df')
  295.             return df
  296.  
  297.  
  298.     
  299.     def ls(self, force_read = True, glob_list = '*', openclose = True):
  300.         if not glob_list:
  301.             glob_list = '*'
  302.         
  303.         if force_read:
  304.             self.START_OPERATION('ls')
  305.             
  306.             try:
  307.                 self.current_dir = pcardext.ls()
  308.             finally:
  309.                 self.END_OPERATION('ls', openclose)
  310.  
  311.         
  312.         self.current_dir = [ (n.lower(), a, s) for n, a, s in self.current_dir ]
  313.         return [ fnmatch.filter(self.current_dir, x) for x in glob_list.strip().lower().split() ][0]
  314.  
  315.     
  316.     def size(self, name):
  317.         for f in self.current_dir:
  318.             if f == name:
  319.                 return self.current_dir[f][2]
  320.                 continue
  321.         
  322.         return 0
  323.  
  324.     
  325.     def current_files(self):
  326.         return _[1]
  327.  
  328.     
  329.     def current_directories(self):
  330.         return _[1]
  331.  
  332.     
  333.     def match_files(self, glob_list):
  334.         return []
  335.  
  336.     
  337.     def match_dirs(self, glob_list):
  338.         return []
  339.  
  340.     
  341.     def classify_file(self, filename):
  342.         t = mimetypes.guess_type(filename)[0]
  343.         if t is None:
  344.             return 'unknown/unknown'
  345.         
  346.         return t
  347.  
  348.     
  349.     def cp(self, name, local_file, openclose = True):
  350.         self.START_OPERATION('cp')
  351.         total = 0
  352.         
  353.         try:
  354.             f = file(local_file, 'w')
  355.             total = pcardext.cp(name, f.fileno())
  356.             f.close()
  357.         finally:
  358.             self.END_OPERATION('cp', openclose)
  359.             return total
  360.  
  361.  
  362.     
  363.     def cp_multiple(self, filelist, remove_after_copy, cp_status_callback = None, rm_status_callback = None):
  364.         (delta, total) = (0, 0)
  365.         self.START_OPERATION('cp_multiple')
  366.         t1 = time.time()
  367.         
  368.         try:
  369.             for f in filelist:
  370.                 size = self.cp(f, f, False)
  371.                 if cp_status_callback:
  372.                     cp_status_callback(os.path.join(self.pwd(), f), os.path.join(os.getcwd(), f), size)
  373.                 
  374.                 total += size
  375.                 if remove_after_copy:
  376.                     pcardext.rm(f)
  377.                 
  378.             
  379.             t2 = time.time()
  380.             delta = t2 - t1
  381.         finally:
  382.             if remove_after_copy:
  383.                 self.ls(True, '*', False)
  384.             
  385.             self.END_OPERATION('cp_multiple')
  386.             return (total, delta)
  387.  
  388.  
  389.     
  390.     def cp_list(self, filelist, remove_after_copy, cp_status_callback = None, rm_status_callback = None):
  391.         self.save_wd()
  392.         (delta, total) = (0, 0)
  393.         self.START_OPERATION('cp_list')
  394.         t1 = time.time()
  395.         
  396.         try:
  397.             for f in filelist:
  398.                 path_list = f.split('/')[:-1]
  399.                 filename = f.split('/')[-1]
  400.                 for p in path_list:
  401.                     self.cd(p, False)
  402.                 
  403.                 size = self.cp(filename, filename, False)
  404.                 if cp_status_callback is not None:
  405.                     cp_status_callback(f, os.path.join(os.getcwd(), filename), size)
  406.                 
  407.                 total += size
  408.                 if remove_after_copy:
  409.                     pcardext.rm(filename)
  410.                     if rm_status_callback is not None:
  411.                         rm_status_callback(f)
  412.                     
  413.                 
  414.                 self.cd('/', False)
  415.             
  416.             t2 = time.time()
  417.             delta = t2 - t1
  418.         finally:
  419.             self.restore_wd()
  420.             self.END_OPERATION('cp_list')
  421.             return (total, delta)
  422.  
  423.  
  424.     
  425.     def cp_fd(self, name, fd):
  426.         total = 0
  427.         self.START_OPERATION('cp_fd')
  428.         
  429.         try:
  430.             total = pcardext.cp(name, fd)
  431.         finally:
  432.             self.END_OPERATION('cp_fd')
  433.             return total
  434.  
  435.  
  436.     
  437.     def unload(self, unload_list, cp_status_callback = None, rm_status_callback = None, dont_remove = False):
  438.         was_cancelled = False
  439.         self.save_wd()
  440.         self.START_OPERATION('unload')
  441.         total = 0
  442.         t1 = time.time()
  443.         for f in unload_list:
  444.             if not was_cancelled:
  445.                 (name, size, typ, subtyp) = f
  446.                 p = name.split('/')
  447.                 dirs = p[:-1]
  448.                 filename = p[-1]
  449.                 self.cd('/', False)
  450.                 if cp_status_callback is not None:
  451.                     if cp_status_callback(os.path.join(self.pwd(), filename), os.path.join(os.getcwd(), filename), 1):
  452.                         was_cancelled = True
  453.                         break
  454.                     
  455.                 
  456.                 if len(dirs) > 0:
  457.                     for d in dirs:
  458.                         self.cd(d, False)
  459.                     
  460.                 
  461.                 if os.path.exists(os.path.join(os.getcwd(), filename)):
  462.                     i = 2
  463.                     while True:
  464.                         if not os.path.exists(os.path.join(os.getcwd(), filename + ' (%d)' % i)):
  465.                             break
  466.                         
  467.                         i += 1
  468.                     total += self.cp(filename, filename + ' (%d)' % i, False)
  469.                 else:
  470.                     total += self.cp(filename, filename, False)
  471.                 if cp_status_callback is not None:
  472.                     if cp_status_callback(os.path.join(self.pwd(), filename), os.path.join(os.getcwd(), filename), size):
  473.                         was_cancelled = True
  474.                         break
  475.                     
  476.                 
  477.                 if not dont_remove:
  478.                     if rm_status_callback is not None:
  479.                         rm_status_callback(os.path.join(self.pwd(), filename))
  480.                     
  481.                     self.rm(filename, False, False)
  482.                 
  483.             dont_remove
  484.         
  485.         t2 = time.time()
  486.         self.restore_wd(False)
  487.         self.ls(True, '*', False)
  488.         self.END_OPERATION('unload')
  489.         return (total, t2 - t1, was_cancelled)
  490.  
  491.     
  492.     def get_unload_list(self):
  493.         tree = self.tree()
  494.         return self._PhotoCard__build_unload_list(tree)
  495.  
  496.     
  497.     def __build_unload_list(self, tree, path = None, out = None):
  498.         if path is None:
  499.             out = []
  500.             path = utils.Stack()
  501.         
  502.         for d in tree:
  503.             if type(tree[d]) == type({ }):
  504.                 path.push(d)
  505.                 self._PhotoCard__build_unload_list(tree[d], path, out)
  506.                 path.pop()
  507.                 continue
  508.             (typ, subtyp) = self.classify_file(d).split('/')
  509.             if typ in ('image', 'audio', 'video'):
  510.                 p = path.as_list()
  511.                 name = '/'.join([
  512.                     '/'.join(p),
  513.                     d])
  514.                 out.append((name, tree[d], typ, subtyp))
  515.                 continue
  516.         
  517.         return out
  518.  
  519.     
  520.     def info(self):
  521.         return pcardext.info()
  522.  
  523.     
  524.     def cd(self, dirs, openclose = True):
  525.         self.START_OPERATION('cd')
  526.         
  527.         try:
  528.             stat = pcardext.cd(dirs)
  529.             if stat:
  530.                 if dirs == '/':
  531.                     self.dir_stack.clear()
  532.                 else:
  533.                     dirs = dirs.split('/')
  534.                     for d in dirs:
  535.                         self.dir_stack.push(d)
  536.                     
  537.                 self.ls(True, '*', False)
  538.         finally:
  539.             self.END_OPERATION('cd', openclose)
  540.  
  541.  
  542.     
  543.     def cdup(self, openclose = True):
  544.         if len(self.dir_stack.as_list()) == 0:
  545.             return self.cd('/', openclose)
  546.         
  547.         self.dir_stack.pop()
  548.         self.START_OPERATION('cdup')
  549.         
  550.         try:
  551.             pcardext.cd('/')
  552.             for d in self.dir_stack.as_list():
  553.                 pcardext.cd(d)
  554.             
  555.             self.ls(True, '*', False)
  556.         finally:
  557.             self.END_OPERATION('cdup', openclose)
  558.  
  559.  
  560.     
  561.     def rm(self, name, refresh_dir = True, openclose = True):
  562.         self.START_OPERATION()
  563.         
  564.         try:
  565.             r = pcardext.rm(name)
  566.             if refresh_dir:
  567.                 self.ls(True, '*', False)
  568.         finally:
  569.             self.END_OPERATION(openclose)
  570.             return r
  571.  
  572.  
  573.     
  574.     def mount(self):
  575.         log.debug('Mounting photocard...')
  576.         self.START_OPERATION('mount')
  577.         
  578.         try:
  579.             stat = pcardext.mount(self._read, self._write)
  580.             disk_info = pcardext.info()
  581.             self.write_protect = disk_info[8]
  582.             log.debug('stat=%d' % stat)
  583.             if stat == 0:
  584.                 if self.write_protect:
  585.                     self.open_channel()
  586.                 
  587.                 self.pcard_mounted = True
  588.                 pcardext.cd('/')
  589.                 self.ls(True, '*', False)
  590.             else:
  591.                 self.pcard_mounted = False
  592.                 raise Error(ERROR_DEVICE_DOES_NOT_SUPPORT_OPERATION)
  593.         finally:
  594.             if self.pcard_mounted:
  595.                 self.END_OPERATION('mount')
  596.             
  597.  
  598.  
  599.     
  600.     def pwd(self):
  601.         return '/' + '/'.join(self.dir_stack.as_list())
  602.  
  603.     
  604.     def save_wd(self):
  605.         self.saved_pwd = self.dir_stack.as_list()[:]
  606.  
  607.     
  608.     def restore_wd(self, openclose = True):
  609.         self.cd('/', openclose)
  610.         for d in self.saved_pwd:
  611.             self.cd(d, openclose)
  612.         
  613.  
  614.     
  615.     def tree(self):
  616.         self.START_OPERATION('tree')
  617.         dir_tree = { }
  618.         
  619.         try:
  620.             self.save_wd()
  621.             dir_tree = self._PhotoCard__tree()
  622.             self.restore_wd(False)
  623.         finally:
  624.             self.END_OPERATION('tree')
  625.             return dir_tree
  626.  
  627.  
  628.     
  629.     def __tree(self, _PhotoCard__d = None):
  630.         if _PhotoCard__d is None:
  631.             _PhotoCard__d = { }
  632.             pcardext.cd('/')
  633.         
  634.         for f in pcardext.ls():
  635.             fname = f[0].lower()
  636.             if self.callback is not None:
  637.                 self.callback()
  638.             
  639.             if fname not in ('.', '..'):
  640.                 if f[1] == 'd':
  641.                     self.cd(fname, False)
  642.                     _PhotoCard__d[fname] = { }
  643.                     _PhotoCard__d[fname] = self._PhotoCard__tree(_PhotoCard__d[fname])
  644.                     self.cdup(False)
  645.                 else:
  646.                     _PhotoCard__d[fname] = f[2]
  647.             f[1] == 'd'
  648.         
  649.         return _PhotoCard__d
  650.  
  651.     
  652.     def get_exif(self, name):
  653.         exif_info = { }
  654.         self.START_OPERATION('get_exif')
  655.         pcf = None
  656.         
  657.         try:
  658.             pcf = PhotoCardFile(self, name)
  659.             exif_info = exif.process_file(pcf)
  660.         finally:
  661.             if pcf is not None:
  662.                 pcf.close()
  663.             
  664.             self.END_OPERATION('get_exif')
  665.             return exif_info
  666.  
  667.  
  668.     
  669.     def get_exif_path(self, name):
  670.         exif_info = { }
  671.         self.START_OPERATION('get_exif_path')
  672.         self.save_wd()
  673.         
  674.         try:
  675.             path_list = name.split('/')[:-1]
  676.             filename = name.split('/')[-1]
  677.             for p in path_list:
  678.                 self.cd(p, False)
  679.             
  680.             pcf = PhotoCardFile(self, filename)
  681.             exif_info = exif.process_file(pcf)
  682.         finally:
  683.             self.restore_wd(False)
  684.             pcf.close()
  685.             self.END_OPERATION('get_exif_path')
  686.             return exif_info
  687.  
  688.  
  689.     
  690.     def sector(self, sector):
  691.         self.START_OPERATION('sector')
  692.         
  693.         try:
  694.             data = self._read(sector, 1)
  695.         finally:
  696.             self.END_OPERATION('sector')
  697.             return data
  698.  
  699.  
  700.     
  701.     def umount(self):
  702.         pcardext.umount()
  703.         self.pcard_mounted = False
  704.  
  705.     
  706.     def open_channel(self):
  707.         self.channel_opened = True
  708.         self.device.openPCard()
  709.  
  710.     
  711.     def close_channel(self):
  712.         self.channel_opened = False
  713.         self.device.closePCard()
  714.  
  715.  
  716.