Changes in / [20:30]

Location:

/pkipplib/trunk

Files:

• tests/test.py (modified) (1 diff)
• bin (added)
• bin/cupssubscribe (added)
• pkipplib/pkipplib.py (modified) (13 diffs)
• pkipplib/version.py (modified) (1 diff)
• README (modified) (2 diffs)

/pkipplib/trunk/tests/test.py

@@ -26 +26 @@
 import pkipplib        
     
-cups = pkipplib.CUPS()    
-answer = cups.getPPD("HL6050DN")
-#answer = cups.getJobAttributes(566)
+cups = pkipplib.CUPS()
+answer = cups.createSubscription("ipp://localhost/", ["printer-added", "printer-deleted"],
+                                                     userdata="samplenotifier:blah",
+                                                     recipient="samplenotifier",
+                                                     charset="utf-8")
 print answer
+
 #print answer.operation["attributes-charset"]
 

/pkipplib/trunk/pkipplib/pkipplib.py

@@ -24 +24 @@
 
 import sys
+import os
 import urllib2
+import socket
 from struct import pack, unpack
 
@@ -236 +238 @@
 IPP_PRINTER_IS_DEACTIVATED = 0x50a
   
+CUPS_PRINTER_LOCAL = 0x0000
+CUPS_PRINTER_CLASS = 0x0001
+CUPS_PRINTER_REMOTE = 0x0002
+CUPS_PRINTER_BW = 0x0004
+CUPS_PRINTER_COLOR = 0x0008
+CUPS_PRINTER_DUPLEX = 0x0010
+CUPS_PRINTER_STAPLE = 0x0020
+CUPS_PRINTER_COPIES = 0x0040
+CUPS_PRINTER_COLLATE = 0x0080
+CUPS_PRINTER_PUNCH = 0x0100
+CUPS_PRINTER_COVER = 0x0200
+CUPS_PRINTER_BIND = 0x0400
+CUPS_PRINTER_SORT = 0x0800
+CUPS_PRINTER_SMALL = 0x1000
+CUPS_PRINTER_MEDIUM = 0x2000
+CUPS_PRINTER_LARGE = 0x4000
+CUPS_PRINTER_VARIABLE = 0x8000
+CUPS_PRINTER_IMPLICIT = 0x1000
+CUPS_PRINTER_DEFAULT = 0x2000
+CUPS_PRINTER_FAX = 0x4000
+CUPS_PRINTER_REJECTING = 0x8000
+CUPS_PRINTER_DELETE = 0x1000
+CUPS_PRINTER_NOT_SHARED = 0x2000
+CUPS_PRINTER_AUTHENTICATED = 0x4000
+CUPS_PRINTER_COMMANDS = 0x8000
+CUPS_PRINTER_OPTIONS = 0xe6ff
+  
+  
 class IPPError(Exception) :
     """An exception for IPP related stuff."""
@@ -266 +296 @@
     def __getitem__(self, key) :
         """Returns an attribute's value."""
+        answer = []
         attributeslist = getattr(self.request, "_%s_attributes" % self.name)
         for i in range(len(attributeslist)) :
@@ -272 +303 @@
                 (attrname, attrvalue) = attribute[j]
                 if attrname == key :
-                    return attrvalue
+                    answer.extend(attrvalue)
+        if answer :
+            return answer
         raise KeyError, key            
     
@@ -282 +315 @@
                                 operation_id=None, \
                                 request_id=None, \
-                                url = "http://localhost:631", \
-                                username = None, \
-                                password = None, \
                                 debug=False) :
         """Initializes an IPP Message object.
@@ -293 +323 @@
              debug : a boolean value to output debug info on stderr.
         """
-        self.url = url
-        self.username = username
-        self.password = password
         self.debug = debug
         self._data = data
@@ -319 +346 @@
         self.tags[0x05] = "unsupported-attributes-tag"
         self.tags[0x06] = "subscription-attributes-tag"
-        self.tags[0x07] = "event-notification-attributes-tag"
+        self.tags[0x07] = "event_notification-attributes-tag"
         
         # out of band values
@@ -418 +445 @@
         self.request_id = reqid
         
-    def nextRequestId(self) :        
-        """Increments the current request id and returns the new value."""
-        try :
-            self.request_id += 1
-        except TypeError :    
-            self.request_id = 1
-        return self.request_id
-            
     def dump(self) :    
         """Generates an IPP Message.
@@ -433 +452 @@
         mybuffer = []
         if None not in (self.version, self.operation_id) :
-            if self.request_id is None :
-                self.nextRequestId()
             mybuffer.append(chr(self.version[0]) + chr(self.version[1]))
             mybuffer.append(pack(">H", self.operation_id))
-            mybuffer.append(pack(">I", self.request_id))
+            mybuffer.append(pack(">I", self.request_id or 1))
             for attrtype in self.attributes_types :
                 for attribute in getattr(self, "_%s_attributes" % attrtype) :
@@ -478 +495 @@
         self.position = 8
         endofattributes = self.tagvalues["end-of-attributes-tag"]
-        maxdelimiter = self.tagvalues["event-notification-attributes-tag"]
+        maxdelimiter = self.tagvalues["event_notification-attributes-tag"]
         nulloffset = lambda : 0
         try :
@@ -562 +579 @@
         return self.parseTag()
         
-    def doRequest(self, url=None, username=None, password=None, samerequestid=False) :
-        """Sends the current request to the URL.
-           NB : only ipp:// URLs are currently unsupported so use
-           either http://host:631/ or https://host:443 instead...
-           
-           returns a new IPPRequest object, containing the parsed answer.
-        """   
-        if not samerequestid :
-            self.nextRequestId()
-        cx = urllib2.Request(url=url or self.url or "http://localhost:631/", 
-                             data=self.dump())
-        cx.add_header("Content-Type", "application/ipp")
-        response = urllib2.urlopen(cx)
-        datas = response.read()
-        ippresponse = IPPRequest(datas)
-        ippresponse.parse()
-        return ippresponse
-        
             
 class CUPS :
     """A class for a CUPS instance."""
-    def __init__(self, url="http://localhost:631", username=None, password=None, charset="utf-8", language="en-us") :
+    def __init__(self, url=None, username=None, password=None, charset="utf-8", language="en-us", debug=False) :
         """Initializes the CUPS instance."""
-        self.url = url
+        if url is not None :
+            self.url = url.replace("ipp://", "http://")
+            if self.url.endswith("/") :
+                self.url = self.url[:-1]
+        else :        
+            self.url = self.getDefaultURL()
         self.username = username
         self.password = password
         self.charset = charset
         self.language = language
-        
+        self.debug = debug
+        self.lastError = None
+        self.lastErrorMessage = None
+        self.requestId = None
+        
+    def getDefaultURL(self) :    
+        """Builds a default URL."""
+        # TODO : encryption methods.
+        server = os.environ.get("CUPS_SERVER") or "localhost"
+        port = os.environ.get("IPP_PORT") or 631
+        if server.startswith("/") :
+            # it seems it's a unix domain socket.
+            # we can't handle this right now, so we use the default instead.
+            return "http://localhost:%s" % port
+        else :    
+            return "http://%s:%s" % (server, port)
+            
     def identifierToURI(self, service, ident) :
         """Transforms an identifier into a particular URI depending on requested service."""
@@ -597 +617 @@
                              ident)
         
+    def nextRequestId(self) :        
+        """Increments the current request id and returns the new value."""
+        try :
+            self.requestId += 1
+        except TypeError :    
+            self.requestId = 1
+        return self.requestId
+            
     def newRequest(self, operationid=None) :
         """Generates a new empty request."""
         if operationid is not None :
             req = IPPRequest(operation_id=operationid, \
-                             url=self.url, \
-                             username=self.username, \
-                             password=self.password)
+                             request_id=self.nextRequestId(), \
+                             debug=self.debug)
             req.operation["attributes-charset"] = ("charset", self.charset)
             req.operation["attributes-natural-language"] = ("naturalLanguage", self.language)
             return req
     
-    def getDefault(self) :
-        """Retrieves CUPS' default printer."""
-        return self.newRequest(CUPS_GET_DEFAULT).doRequest()
+    def doRequest(self, req, url=None) :
+        """Sends a request to the CUPS server.
+           returns a new IPPRequest object, containing the parsed answer.
+        """   
+        connexion = urllib2.Request(url=url or self.url, \
+                             data=req.dump())
+        connexion.add_header("Content-Type", "application/ipp")
+        if self.username :
+            pwmanager = urllib2.HTTPPasswordMgrWithDefaultRealm()
+            pwmanager.add_password(None, \
+                                   "%s%s" % (connexion.get_host(), connexion.get_selector()), \
+                                   self.username, \
+                                   self.password or "")
+            authhandler = urllib2.HTTPBasicAuthHandler(pwmanager)                       
+            opener = urllib2.build_opener(authhandler)
+            urllib2.install_opener(opener)
+        self.lastError = None    
+        self.lastErrorMessage = None
+        try :    
+            response = urllib2.urlopen(connexion)
+        except (urllib2.URLError, urllib2.HTTPError, socket.error), error :    
+            self.lastError = error
+            self.lastErrorMessage = str(error)
+            return None
+        else :    
+            datas = response.read()
+            ippresponse = IPPRequest(datas)
+            ippresponse.parse()
+            return ippresponse
     
-    def getJobAttributes(self, jobid) :    
-        """Retrieves a print job's attributes."""
-        req = self.newRequest(IPP_GET_JOB_ATTRIBUTES)
-        req.operation["job-uri"] = ("uri", self.identifierToURI("jobs", jobid))
-        return req.doRequest()
-        
     def getPPD(self, queuename) :    
         """Retrieves the PPD for a particular queuename."""
@@ -624 +671 @@
         for attrib in ("printer-uri-supported", "printer-type", "member-uris") :
             req.operation["requested-attributes"] = ("nameWithoutLanguage", attrib)
-        return req.doRequest()  # TODO : get the PPD from the actual print server
-        
-            
+        return self.doRequest(req)  # TODO : get the PPD from the actual print server
+        
+    def getDefault(self) :
+        """Retrieves CUPS' default printer."""
+        return self.doRequest(self.newRequest(CUPS_GET_DEFAULT))
+    
+    def getJobAttributes(self, jobid) :    
+        """Retrieves a print job's attributes."""
+        req = self.newRequest(IPP_GET_JOB_ATTRIBUTES)
+        req.operation["job-uri"] = ("uri", self.identifierToURI("jobs", jobid))
+        return self.doRequest(req)
+        
+    def getPrinters(self) :    
+        """Returns the list of print queues names."""
+        req = self.newRequest(CUPS_GET_PRINTERS)
+        req.operation["requested-attributes"] = ("keyword", "printer-name")
+        req.operation["printer-type"] = ("enum", 0)
+        req.operation["printer-type-mask"] = ("enum", CUPS_PRINTER_CLASS)
+        return [printer[1] for printer in self.doRequest(req).printer["printer-name"]]
+        
+    def getDevices(self) :    
+        """Returns a list of devices as (deviceclass, deviceinfo, devicemakeandmodel, deviceuri) tuples."""
+        answer = self.doRequest(self.newRequest(CUPS_GET_DEVICES))
+        return zip([d[1] for d in answer.printer["device-class"]], \
+                   [d[1] for d in answer.printer["device-info"]], \
+                   [d[1] for d in answer.printer["device-make-and-model"]], \
+                   [d[1] for d in answer.printer["device-uri"]])
+                   
+    def getPPDs(self) :    
+        """Returns a list of PPDs as (ppdnaturallanguage, ppdmake, ppdmakeandmodel, ppdname) tuples."""
+        answer = self.doRequest(self.newRequest(CUPS_GET_PPDS))
+        return zip([d[1] for d in answer.printer["ppd-natural-language"]], \
+                   [d[1] for d in answer.printer["ppd-make"]], \
+                   [d[1] for d in answer.printer["ppd-make-and-model"]], \
+                   [d[1] for d in answer.printer["ppd-name"]])
+                   
+    def createSubscription(self, uri, events=["all"],
+                                      userdata=None,
+                                      recipient=None,
+                                      pullmethod=None,
+                                      charset=None,
+                                      naturallanguage=None,
+                                      leaseduration=None,
+                                      timeinterval=None,
+                                      jobid=None) :
+        """Creates a job, printer or server subscription."""
+        if jobid is not None :
+            opid = IPP_CREATE_JOB_SUBSCRIPTION
+            uritype = "job-uri"
+        else :
+            opid = IPP_CREATE_PRINTER_SUBSCRIPTION
+            uritype = "printer-uri"
+        req = self.newRequest(opid)
+        req.operation[uritype] = ("uri", uri)
+        for event in events :
+            req.subscription["notify-events"] = ("keyword", event)
+        if userdata is not None :    
+            req.subscription["notify-user-data"] = ("octetString-with-an-unspecified-format", userdata)
+        if recipient is not None :    
+            req.subscription["notify-recipient"] = ("uri", recipient)
+        if pullmethod is not None :
+            req.subscription["notify-pull-method"] = ("keyword", pullmethod)
+        if charset is not None :
+            req.subscription["notify-charset"] = ("charset", charset)
+        if naturallanguage is not None :
+            req.subscription["notify-natural-language"] = ("naturalLanguage", naturallanguage)
+        if leaseduration is not None :
+            req.subscription["notify-lease-duration"] = ("integer", leaseduration)
+        if timeinterval is not None :
+            req.subscription["notify-time-interval"] = ("integer", timeinterval)
+        if jobid is not None :
+            req.subscription["notify-job-id"] = ("integer", jobid)
+        return self.doRequest(req)
+            
+    def cancelSubscription(self, uri, subscriptionid, jobid=None) :    
+        """Cancels a subscription."""
+        req = self.newRequest(IPP_CANCEL_SUBSCRIPTION)
+        if jobid is not None :
+            uritype = "job-uri"
+        else :
+            uritype = "printer-uri"
+        req.operation[uritype] = ("uri", uri)
+        req.event_notification["notify-subscription-id"] = ("integer", subscriptionid)
+        return self.doRequest(req)
+        
 if __name__ == "__main__" :            
     if (len(sys.argv) < 2) or (sys.argv[1] == "--debug") :
-        print "usage : python ipp.py /var/spool/cups/c00005 [--debug] (for example)\n"
+        print "usage : python pkipplib.py /var/spool/cups/c00005 [--debug] (for example)\n"
     else :    
         infile = open(sys.argv[1], "rb")
-        data = infile.read()
+        filedata = infile.read()
         infile.close()
         
-        message = IPPRequest(data, debug=(sys.argv[-1]=="--debug"))
-        message.parse()
-        message2 = IPPRequest(message.dump())
-        message2.parse()
-        data2 = message2.dump()
-        
-        if data == data2 :
+        msg = IPPRequest(filedata, debug=(sys.argv[-1]=="--debug"))
+        msg.parse()
+        msg2 = IPPRequest(msg.dump())
+        msg2.parse()
+        filedata2 = msg2.dump()
+        
+        if filedata == filedata2 :
             print "Test OK : parsing original and parsing the output of the dump produce the same dump !"
-            print str(message)
+            print str(msg)
         else :    
             print "Test Failed !"
-            print str(message)
+            print str(msg)
             print
-            print str(message2)
-        
+            print str(msg2)
+        

/pkipplib/trunk/pkipplib/version.py

@@ -21 +21 @@
 #
 
-__version__ = "0.03"
+__version__ = "0.07"
 
 __doc__ = "pkipplib : IPP and CUPS support for Python."

/pkipplib/trunk/README

@@ -109 +109 @@
 from pkipplib import pkipplib
 
-# By default, connects to http://localhost:631
+# Create a CUPS client instance
+# cups = pkipplib.CUPS(url="http://server:631", username="john", password="blah!")
 cups = pkipplib.CUPS()
 
@@ -129 +130 @@
     
 # Sends this request to the CUPS server    
-answer = request.doRequest()    
+answer = cups.doRequest(request)
 
 # Print the answer as a string of text