Show
Ignore:
Timestamp:
09/27/08 22:02:37 (16 years ago)
Author:
jerome
Message:

Removed unnecessary spaces at EOL.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • pykota/trunk/pykota/accounters/pjl.py

    r3411 r3413  
    88# the Free Software Foundation, either version 3 of the License, or 
    99# (at your option) any later version. 
    10 #  
     10# 
    1111# This program is distributed in the hope that it will be useful, 
    1212# but WITHOUT ANY WARRANTY; without even the implied warranty of 
    1313# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1414# GNU General Public License for more details. 
    15 #  
     15# 
    1616# You should have received a copy of the GNU General Public License 
    1717# along with this program.  If not, see <http://www.gnu.org/licenses/>. 
     
    2121# 
    2222 
    23 """This module defines the necessary classes and methods to retrieve  
    24 a printer's internal page counter over a TCP connection."""  
     23"""This module defines the necessary classes and methods to retrieve 
     24a printer's internal page counter over a TCP connection.""" 
    2525 
    2626import sys 
     
    3636 
    3737# Old method : PJLMESSAGE = "\033%-12345X@PJL USTATUSOFF\r\n@PJL INFO STATUS\r\n@PJL INFO PAGECOUNT\r\n\033%-12345X" 
    38 # Here's a new method, which seems to work fine on my HP2300N, while the  
     38# Here's a new method, which seems to work fine on my HP2300N, while the 
    3939# previous one didn't. 
    40 # TODO : We could also experiment with USTATUS JOB=ON and we would know for sure  
     40# TODO : We could also experiment with USTATUS JOB=ON and we would know for sure 
    4141# when the job is finished, without having to poll the printer repeatedly. 
    4242PJLMESSAGE = "\033%-12345X@PJL USTATUS DEVICE=ON\r\n@PJL INFO STATUS\r\n@PJL INFO PAGECOUNT\r\n@PJL USTATUS DEVICE=OFF\033%-12345X" 
     
    5252                    "40000" : "Sleep Mode",             # Standby 
    5353                  } 
    54                    
     54 
    5555class Handler : 
    5656    """A class for PJL print accounting.""" 
     
    6969        self.readthread = None 
    7070        self.quitEvent = threading.Event() 
    71          
    72     def __del__(self) :     
     71 
     72    def __del__(self) : 
    7373        """Ensures the network connection is closed at object deletion time.""" 
    7474        self.close() 
    75          
    76     def open(self) :     
     75 
     76    def open(self) : 
    7777        """Opens the network connection.""" 
    7878        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
     
    9393            self.parent.filter.logdebug("Connected to printer %s:%s" % (self.printerHostname, self.port)) 
    9494            return True 
    95          
    96     def close(self) :     
     95 
     96    def close(self) : 
    9797        """Closes the network connection.""" 
    9898        if not self.closed : 
     
    107107            self.queue = None 
    108108            self.closed = True 
    109              
    110     def readloop(self) :         
     109 
     110    def readloop(self) : 
    111111        """Reading loop thread.""" 
    112112        self.parent.filter.logdebug("Reading thread started.") 
     
    115115            try : 
    116116                answer = self.sock.recv(1) 
    117             except socket.timeout :     
     117            except socket.timeout : 
    118118                pass 
    119119            except socket.error, (dummy, msg) : 
    120120                self.parent.filter.printInfo(_("Problem while receiving PJL answer from %s:%s : %s") % (self.printerHostname, self.port, str(msg)), "warn") 
    121             else :     
     121            else : 
    122122                if answer : 
    123123                    readbuffer.append(answer) 
     
    125125                        self.queue.put("".join(readbuffer)) 
    126126                        readbuffer = [] 
    127         if readbuffer :              
    128             self.queue.put("".join(readbuffer))             
     127        if readbuffer : 
     128            self.queue.put("".join(readbuffer)) 
    129129        self.parent.filter.logdebug("Reading thread ended.") 
    130              
    131     def retrievePJLValues(self) :     
     130 
     131    def retrievePJLValues(self) : 
    132132        """Retrieves a printer's internal page counter and status via PJL.""" 
    133133        while not self.open() : 
     
    141141            except socket.error, msg : 
    142142                self.parent.filter.printInfo(_("Problem while sending PJL query to %s:%s : %s") % (self.printerHostname, self.port, str(msg)), "warn") 
    143             else :     
     143            else : 
    144144                self.parent.filter.logdebug("Query sent to %s : %s" % (self.printerHostname, repr(PJLMESSAGE))) 
    145145                actualpagecount = self.printerStatus = None 
     
    147147                    try : 
    148148                        answer = self.queue.get(True, 5) 
    149                     except Queue.Empty :     
     149                    except Queue.Empty : 
    150150                        self.parent.filter.logdebug("Timeout when reading printer's answer from %s:%s" % (self.printerHostname, self.port)) 
    151                     else :     
     151                    else : 
    152152                        readnext = False 
    153153                        self.parent.filter.logdebug("PJL answer : %s" % repr(answer)) 
    154                         for line in [l.strip() for l in answer.split()] :  
     154                        for line in [l.strip() for l in answer.split()] : 
    155155                            if line.startswith("CODE=") : 
    156156                                self.printerStatus = line.split("=")[1] 
    157157                                self.parent.filter.logdebug("Found status : %s" % self.printerStatus) 
    158                             elif line.startswith("PAGECOUNT=") :     
     158                            elif line.startswith("PAGECOUNT=") : 
    159159                                try : 
    160160                                    actualpagecount = int(line.split('=')[1].strip()) 
    161                                 except ValueError :     
     161                                except ValueError : 
    162162                                    self.parent.filter.logdebug("Received incorrect datas : [%s]" % line.strip()) 
    163163                                else : 
    164164                                    self.parent.filter.logdebug("Found pages counter : %s" % actualpagecount) 
    165                             elif line.startswith("PAGECOUNT") :     
     165                            elif line.startswith("PAGECOUNT") : 
    166166                                readnext = True # page counter is on next line 
    167                             elif readnext :     
     167                            elif readnext : 
    168168                                try : 
    169169                                    actualpagecount = int(line.strip()) 
    170                                 except ValueError :     
     170                                except ValueError : 
    171171                                    self.parent.filter.logdebug("Received incorrect datas : [%s]" % line.strip()) 
    172172                                else : 
     
    174174                                    readnext = False 
    175175                self.printerInternalPageCounter = max(actualpagecount, self.printerInternalPageCounter) 
    176         finally :         
     176        finally : 
    177177            self.close() 
    178          
     178 
    179179    def waitPrinting(self) : 
    180180        """Waits for printer status being 'printing'.""" 
     
    183183        if not noprintingmaxdelay : 
    184184            self.parent.filter.logdebug("Will wait indefinitely until printer %s is in 'printing' state." % self.parent.filter.PrinterName) 
    185         else :     
     185        else : 
    186186            self.parent.filter.logdebug("Will wait until printer %s is in 'printing' state or %i seconds have elapsed." % (self.parent.filter.PrinterName, noprintingmaxdelay)) 
    187187        previousValue = self.parent.getLastPageCounter() 
     
    192192            if self.printerStatus in ('10023', '10003') : 
    193193                break 
    194             if self.printerInternalPageCounter is not None :     
     194            if self.printerInternalPageCounter is not None : 
    195195                if firstvalue is None : 
    196196                    # first time we retrieved a page counter, save it 
    197197                    firstvalue = self.printerInternalPageCounter 
    198                 else :      
     198                else : 
    199199                    # second time (or later) 
    200200                    if firstvalue < self.printerInternalPageCounter : 
     
    213213                                # the printer rejected it for some reason. 
    214214                                self.parent.filter.printInfo("Printer %s probably won't print this job !!!" % self.parent.filter.PrinterName, "warn") 
    215                             else :      
     215                            else : 
    216216                                # Here the job has already been entirely printed, and 
    217217                                # the printer has already passed from 'idle' to 'printing' to 'idle' again. 
     
    220220            self.parent.filter.logdebug(_("Waiting for printer %s to be printing...") % self.parent.filter.PrinterName) 
    221221            time.sleep(statusstabilizationdelay) 
    222          
     222 
    223223    def waitIdle(self) : 
    224224        """Waits for printer status being 'idle'.""" 
     
    233233                   and (os.environ.get("PYKOTAPHASE") == "BEFORE") : 
    234234                    self.parent.filter.logdebug("No need to wait for the printer to be idle, it is the case already.") 
    235                     return  
     235                    return 
    236236                idle_num += 1 
    237237                if idle_num >= statusstabilizationloops : 
    238238                    # printer status is stable, we can exit 
    239239                    break 
    240             else :     
     240            else : 
    241241                idle_num = 0 
    242242            self.parent.filter.logdebug(_("Waiting for printer %s's idle status to stabilize...") % self.parent.filter.PrinterName) 
    243243            time.sleep(statusstabilizationdelay) 
    244      
     244 
    245245    def retrieveInternalPageCounter(self) : 
    246246        """Returns the page counter from the printer via internal PJL handling.""" 
     
    251251               self.parent.filter.JobSizeBytes : 
    252252                self.waitPrinting() 
    253             self.waitIdle()     
    254         except :     
     253            self.waitIdle() 
     254        except : 
    255255            self.parent.filter.printInfo(_("PJL querying stage interrupted. Using latest value seen for internal page counter (%s) on printer %s.") % (self.printerInternalPageCounter, self.parent.filter.PrinterName), "warn") 
    256256            raise 
    257         else :     
     257        else : 
    258258            return self.printerInternalPageCounter 
    259              
     259 
    260260def main(hostname) : 
    261261    """Tries PJL accounting for a printer host.""" 
     
    266266            self.PrinterName = "FakePrintQueue" 
    267267            self.JobSizeBytes = 1 
    268              
     268 
    269269        def printInfo(self, msg, level="info") : 
    270270            """Prints informational message.""" 
    271271            sys.stderr.write("%s : %s\n" % (level.upper(), msg)) 
    272272            sys.stderr.flush() 
    273              
    274         def logdebug(self, msg) :     
     273 
     274        def logdebug(self, msg) : 
    275275            """Prints debug message.""" 
    276276            self.printInfo(msg, "debug") 
    277              
    278     class FakeAccounter :         
     277 
     278    class FakeAccounter : 
    279279        """Fakes an accounter for testing purposes.""" 
    280280        def __init__(self, hostname) : 
     
    283283            self.filter = FakeFilter() 
    284284            self.protocolHandler = Handler(self, hostname) 
    285              
    286         def getLastPageCounter(self) :     
     285 
     286        def getLastPageCounter(self) : 
    287287            """Fakes the return of a page counter.""" 
    288288            return 0 
    289          
     289 
    290290    acc = FakeAccounter(hostname) 
    291291    return acc.protocolHandler.retrieveInternalPageCounter() 
    292      
    293 if __name__ == "__main__" :             
    294     if len(sys.argv) != 2 :     
     292 
     293if __name__ == "__main__" : 
     294    if len(sys.argv) != 2 : 
    295295        sys.stderr.write("Usage :  python  %s  printer_ip_address\n" % sys.argv[0]) 
    296     else :     
     296    else : 
    297297        def _(msg) : 
    298298            """Fake gettext method.""" 
    299299            return msg 
    300              
     300 
    301301        pagecounter = main(sys.argv[1]) 
    302302        print "Internal page counter's value is : %s" % pagecounter 
    303          
     303