Example #1
0
    def get_printers_list(self, ip="localhost", port=631):
        printer_list = []
        try:
            import cups
        except ImportError:
            frappe.throw(
                _("""This feature can not be used as dependencies are missing.
				Please contact your system manager to enable this by installing pycups!""")
            )
            return
        try:
            cups.setServer(self.server_ip)
            cups.setPort(self.port)
            conn = cups.Connection()
            printers = conn.getPrinters()
            for printer_id, printer in printers.items():
                printer_list.append({
                    "value": printer_id,
                    "label": printer["printer-make-and-model"]
                })

        except RuntimeError:
            frappe.throw(_("Failed to connect to server"))
        except frappe.ValidationError:
            frappe.throw(_("Failed to connect to server"))
        return printer_list
Example #2
0
    def __init__(self,
                 parent=None,
                 try_as_root=True,
                 lock=False,
                 host=None,
                 port=None,
                 encryption=None):
        if host != None:
            cups.setServer(host)
        if port != None:
            cups.setPort(port)
        if encryption != None:
            cups.setEncryption(encryption)

        self._use_password = ''
        self._parent = parent
        self._try_as_root = try_as_root
        self._use_user = cups.getUser()
        self._server = cups.getServer()
        self._port = cups.getPort()
        self._encryption = cups.getEncryption()
        self._prompt_allowed = True
        self._operation_stack = []
        self._lock = lock
        self._gui_event = threading.Event()

        self._connect()
Example #3
0
def print_by_server(doctype, name, print_format=None, doc=None, no_letterhead=0):
	print_settings = frappe.get_doc("Print Settings")
	try:
		import cups
	except ImportError:
		frappe.throw("You need to install pycups to use this feature!")
		return
	try:
		cups.setServer(print_settings.server_ip)
		cups.setPort(print_settings.port)
		conn = cups.Connection()
		output = PdfFileWriter()
		output = frappe.get_print(doctype, name, print_format, doc=doc, no_letterhead=no_letterhead, as_pdf = True, output = output)
		file = os.path.join("/", "tmp", "frappe-pdf-{0}.pdf".format(frappe.generate_hash()))
		output.write(open(file,"wb"))
		conn.printFile(print_settings.printer_name,file , name, {})
	except IOError as e:
		if ("ContentNotFoundError" in e.message
			or "ContentOperationNotPermittedError" in e.message
			or "UnknownContentError" in e.message
			or "RemoteHostClosedError" in e.message):
			frappe.throw(_("PDF generation failed"))
	except cups.IPPError:
		frappe.throw(_("Printing failed"))
	finally:
		cleanup(file,{})
Example #4
0
File: main.py Project: gonicus/gosa
    def serve(self):
        try:
            server = self.env.config.get("cups.server")
            port = self.env.config.get("cups.port")
            user = self.env.config.get("cups.user")
            password = self.env.config.get("cups.password")
            encryption_policy = getattr(cups, "HTTP_ENCRYPT_%s" % self.env.config.get("cups.encryption-policy",
                                                                                      default="IF_REQUESTED").upper())
            if server is not None:
                cups.setServer(server)
            if port is not None:
                cups.setPort(int(port))
            if user is not None:
                cups.setUser(user)
            if encryption_policy is not None:
                cups.setEncryption(encryption_policy)

            if password is not None:
                def pw_callback(prompt):
                    return password

                cups.setPasswordCB(pw_callback)

            self.client = cups.Connection()

            sched = PluginRegistry.getInstance("SchedulerService").getScheduler()
            sched.add_interval_job(self.__gc, minutes=60, tag='_internal', jobstore="ram")
            sched.add_interval_job(self.__update_printer_list, minutes=30, tag='_internal', jobstore="ram")

        except RuntimeError as e:
            self.log.error(str(e))
            self.client = None
Example #5
0
def getippqueue( dev, queue, depth ): 
	name = dev.rfind ( '/' )
	name = dev[ name + 1: ]
	dev  = dev[ 6: ]
	e    = dev.find( ':' )
	
	if e == -1:
		e = dev.find( '/' )
	host = dev[ :e ]
	cups.setServer( host )
	try:
		c = cups.Connection ()
		printers = c.getPrinters ()
		classes  = c.getClasses ()
	except RuntimeError:
		# Failed to connect.
		return
	except cups.IPPError as e:
		if e == cups.IPP_OPERATION_NOT_SUPPORTED:
			# CUPS-Get-Printers not supported so not a CUPS server.
			printers = {}
			classes  = {}
		else:
			return

	queue = c.getPrinterAttributes( name )
	dev = queue[ 'device-uri' ]
	getqueue( name, queue, host, depth + 1, printers, classes )
 def handle(self, *args, **options):
     cups.setServer(settings.CUPS_SERVER)
     c = cups.Connection()
     printers = c.getPrinters()
     for name, printer in printers.iteritems():
         inv_printer = Printer.objects.get_or_create(name=name)[0]
         inv_printer.update_data_from_cups()
Example #7
0
    def __init__ (self, parent=None, try_as_root=True, lock=False,
                  host=None, port=None, encryption=None):
        if host != None:
            cups.setServer (host)
        if port != None:
            cups.setPort (port)
        if encryption != None:
            cups.setEncryption (encryption)

        self._use_password = ''
        self._parent = parent
        self._try_as_root = try_as_root
        self._use_user = cups.getUser ()
        self._server = cups.getServer ()
        self._port = cups.getPort()
        self._encryption = cups.getEncryption ()
        self._prompt_allowed = True
        self._operation_stack = []
        self._lock = lock
        self._gui_event = threading.Event ()

        creds = global_authinfocache.lookup_auth_info (host=host, port=port)
        if creds != None:
            if (creds[0] != 'root' or try_as_root):
                (self._use_user, self._use_password) = creds
            del creds

        self._connect ()
Example #8
0
    def collect(self):
        """Collects the metrics from cups
        """
        start = time.time()

        self._setup_empty_prometheus_metrics()

        cups.setServer(self.host)
        cups.setPort(self.port)
        cups.setUser(self.user)

        try:
            conn = cups.Connection()

            printers = conn.getPrinters()
            self._prometheus_metrics['printersNum'].add_metric([],
                                                               len(printers))

            self._getPrinterStatus(printers)
            self._getJobData(conn)

            self._prometheus_metrics['cupsUp'].add_metric([], 1)
        except Exception as e:
            self._prometheus_metrics['cupsUp'].add_metric([], 0)
            print(e)

        duration = time.time() - start
        self._prometheus_metrics['scrape_duration_seconds'].add_metric(
            [], duration)

        for metric in self._prometheus_metrics.values():
            yield metric
Example #9
0
    def display(self):
        self.answers = {}
        cups.setServer('')
        parent = self.troubleshooter.get_window()
        try:
            c = self.timedop(cups.Connection, parent=parent).run()
            printers = self.timedop(c.getPrinters, parent=parent).run()
            if len(printers) == 0:
                return False

            for name, printer in printers.iteritems():
                if printer.get('printer-is-shared', False):
                    break

            attr = self.timedop(c.getPrinterAttributes,
                                args=(name, ),
                                parent=parent).run()
        except RuntimeError:
            return False
        except cups.IPPError:
            return False

        if not printer.get('printer-is-shared', False):
            return False

        if attr.get('server-is-sharing-printers', True):
            # server-is-sharing-printers is in CUPS 1.4
            return False

        return True
 def handle(self, *args, **options):
     cups.setServer(settings.CUPS_SERVER)
     c = cups.Connection()
     printers = c.getPrinters()
     for name, printer in printers.iteritems():
         inv_printer = Printer.objects.get_or_create(name=name)[0]
         inv_printer.update_data_from_cups()
Example #11
0
def print_by_server(doctype, name, print_format=None, doc=None, no_letterhead=0):
	print_settings = frappe.get_doc("Print Settings")
	try:
		import cups
	except ImportError:
		frappe.throw(_("You need to install pycups to use this feature!"))
		return
	try:
		cups.setServer(print_settings.server_ip)
		cups.setPort(print_settings.port)
		conn = cups.Connection()
		output = PdfFileWriter()
		output = frappe.get_print(doctype, name, print_format, doc=doc, no_letterhead=no_letterhead, as_pdf = True, output = output)
		file = os.path.join("/", "tmp", "frappe-pdf-{0}.pdf".format(frappe.generate_hash()))
		output.write(open(file,"wb"))
		conn.printFile(print_settings.printer_name,file , name, {})
	except IOError as e:
		if ("ContentNotFoundError" in e.message
			or "ContentOperationNotPermittedError" in e.message
			or "UnknownContentError" in e.message
			or "RemoteHostClosedError" in e.message):
			frappe.throw(_("PDF generation failed"))
	except cups.IPPError:
		frappe.throw(_("Printing failed"))
	finally:
		cleanup(file,{})
    def display (self):
        self.answers = {}
        cups.setServer ('')
        parent = self.troubleshooter.get_window ()
        try:
            c = self.timedop (cups.Connection, parent=parent).run ()
            printers = self.timedop (c.getPrinters, parent=parent).run ()
            if len (printers) == 0:
                return False

            for name, printer in printers.iteritems ():
                if printer.get ('printer-is-shared', False):
                    break

            attr = self.timedop (c.getPrinterAttributes,
                                 args=(name,),
                                 parent=parent).run ()
        except RuntimeError:
            return False
        except cups.IPPError:
            return False

        if not printer.get ('printer-is-shared', False):
            return False

        if attr.get ('server-is-sharing-printers', True):
            # server-is-sharing-printers is in CUPS 1.4
            return False

        return True
Example #13
0
def getippqueue(dev, queue, depth):
    name = dev.rfind('/')
    name = dev[name + 1:]
    dev = dev[6:]
    e = dev.find(':')
    if e == -1:
        e = dev.find('/')
    host = dev[:e]
    cups.setServer(host)
    try:
        c = cups.Connection()
        printers = c.getPrinters()
        classes = c.getClasses()
    except RuntimeError:
        # Failed to connect.
        return
    except cups.IPPError as e:
        if e == cups.IPP_OPERATION_NOT_SUPPORTED:
            # CUPS-Get-Printers not supported so not a CUPS server.
            printers = {}
            classes = {}
        else:
            return

    queue = c.getPrinterAttributes(name)
    dev = queue['device-uri']
    getqueue(name, queue, host, depth + 1, printers, classes)
Example #14
0
	def getPrinterInfo(server, self):
		
		cups.setServer(server)
		#cups.setUser(user)
		conn = cups.Connection()
		printers = conn.getPrinters()
		for printer in printers:
			print printer, printers[printer]["device-uri"]
Example #15
0
 def get(self, request, *args, **kwargs):
     cups.setServer(CUPS_IP)
     cups_instance = cups.Connection()
     try:
         items = cups_instance.getJobs(requested_attributes=["job-id", "job-media-sheets-completed", "time-at-creation"])
     except:
         return HttpResponse("error")
     for key in items:
         items[key]["time-at-creation"] = datetime.datetime.fromtimestamp(items[key]["time-at-creation"]).isoformat()
     return HttpResponse(json.dumps(items), content_type="application/json")
    def __init__(self,
                 bus=None,
                 my_jobs=True,
                 specific_dests=None,
                 monitor_jobs=True,
                 host=None,
                 port=None,
                 encryption=None):
        GObject.GObject.__init__(self)
        self.my_jobs = my_jobs
        self.specific_dests = specific_dests
        self.monitor_jobs = monitor_jobs
        self.jobs = {}
        self.printer_state_reasons = {}
        self.printers = set()
        self.process_pending_events = True
        self.fetch_jobs_timer = None
        self.cups_connection_in_error = False

        if host:
            cups.setServer(host)
        if port:
            cups.setPort(port)
        if encryption:
            cups.setEncryption(encryption)
        self.user = cups.getUser()
        self.host = cups.getServer()
        self.port = cups.getPort()
        self.encryption = cups.getEncryption()
        self.ppdcache = ppdcache.PPDCache(host=self.host,
                                          port=self.port,
                                          encryption=self.encryption)

        self.which_jobs = "not-completed"
        self.reasons_seen = {}
        self.connecting_timers = {}
        self.still_connecting = set()
        self.connecting_to_device = {}
        self.received_any_dbus_signals = False
        self.update_timer = None

        if bus is None:
            try:
                bus = dbus.SystemBus()
            except dbus.exceptions.DBusException:
                # System bus not running.
                pass

        self.bus = bus
        if bus is not None:
            bus.add_signal_receiver(self.handle_dbus_signal,
                                    path=self.DBUS_PATH,
                                    dbus_interface=self.DBUS_IFACE)
        self.sub_id = -1
Example #17
0
def gethost(host=None, depth=0):
    if host:
        cups.setServer(host)
    else:
        host = "localhost"
    c = cups.Connection()
    printers = c.getPrinters()
    classes = c.getClasses()
    indent = do_indent(depth)
    for name, queue in printers.items():
        getqueue(name, queue, host, depth, printers, classes)
Example #18
0
def gethost (host=None, depth=0):
	if host:
		cups.setServer (host)
	else:
		host = "localhost"
	c = cups.Connection ()
	printers = c.getPrinters ()
	classes = c.getClasses ()
	indent = do_indent(depth)
	for name, queue in printers.items ():
		getqueue (name, queue, host, depth, printers, classes)
Example #19
0
    def display (self):
        model = Gtk.ListStore (str,
                               str,
                               str,
                               GObject.TYPE_PYOBJECT)
        self.treeview.set_model (model)
        iter = model.append (None)
        model.set (iter, 0, _("Not listed"), 1, '', 2, '', 3, NotListed)

        parent = self.troubleshooter.get_window ()
        try:
            cups.setServer ('')
            c = self.timedop (cups.Connection, parent=parent).run ()
            dests = self.timedop (c.getDests, parent=parent).run ()
            printers = None
            dests_list = []
            for (name, instance), dest in dests.iteritems ():
                if name == None:
                    continue

                if instance != None:
                    queue = "%s/%s" % (name, instance)
                else:
                    queue = name

                if printers == None:
                    printers = self.timedop (c.getPrinters,
                                             parent=parent).run ()

                if not printers.has_key (name):
                    info = _("Unknown")
                    location = _("Unknown")
                else:
                    printer = printers[name]
                    info = printer.get('printer-info', _("Unknown"))
                    location = printer.get('printer-location', _("Unknown"))

                dests_list.append ((queue, location, info, dest))

            dests_list.sort (lambda x, y: cmp (x[0], y[0]))
            for queue, location, info, dest in dests_list:
                iter = model.append (None)
                model.set (iter, 0, queue, 1, location, 2, info, 3, dest)

        except cups.HTTPError:
            pass
        except cups.IPPError:
            pass
        except RuntimeError:
            pass

        return True
Example #20
0
    def display (self):
        model = gtk.ListStore (gobject.TYPE_STRING,
                               gobject.TYPE_STRING,
                               gobject.TYPE_STRING,
                               gobject.TYPE_PYOBJECT)
        self.treeview.set_model (model)
        iter = model.append (None)
        model.set (iter, 0, _("Not listed"), 1, '', 2, '', 3, None)

        parent = self.troubleshooter.get_window ()
        try:
            cups.setServer ('')
            c = self.timedop (cups.Connection, parent=parent).run ()
            dests = self.timedop (c.getDests, parent=parent).run ()
            printers = None
            dests_list = []
            for (name, instance), dest in dests.iteritems ():
                if name == None:
                    continue

                if instance != None:
                    queue = "%s/%s" % (name, instance)
                else:
                    queue = name

                if printers == None:
                    printers = self.timedop (c.getPrinters,
                                             parent=parent).run ()

                if not printers.has_key (name):
                    info = _("Unknown")
                    location = _("Unknown")
                else:
                    printer = printers[name]
                    info = printer.get('printer-info', _("Unknown"))
                    location = printer.get('printer-location', _("Unknown"))

                dests_list.append ((queue, location, info, dest))

            dests_list.sort (lambda x, y: cmp (x[0], y[0]))
            for queue, location, info, dest in dests_list:
                iter = model.append (None)
                model.set (iter, 0, queue, 1, location, 2, info, 3, dest)

        except cups.HTTPError:
            pass
        except cups.IPPError:
            pass
        except RuntimeError:
            pass

        return True
Example #21
0
def gethost(host=None, depth=0):
   # print "entro aqui"
    if not host:
        host = "localhost"
    cups.setServer(host)
    c = cups.Connection()
    printers = c.getPrinters()
    do_indent(depth)
    lista_impresoras = []
    for name, queue in printers.iteritems():
        getqueue(name, queue, host, depth, printers, classes)
        lista_impresoras.append(name)
    return lista_impresoras
Example #22
0
def gethost(host=None, depth=0):
   # print "entro aqui"
    if not host:
        host = "localhost"
    cups.setServer(host)
    c = cups.Connection()
    printers = c.getPrinters()
    indent = do_indent(depth)
    lista_impresoras = []
    for name, queue in printers.iteritems():
        getqueue(name, queue, host, depth, printers, classes)
        lista_impresoras.append(name)
    return lista_impresoras
Example #23
0
    def __init__(self, bus=None, my_jobs=True,
                 specific_dests=None, monitor_jobs=True, host=None,
                 port=None, encryption=None):
        GObject.GObject.__init__ (self)
        self.my_jobs = my_jobs
        self.specific_dests = specific_dests
        self.monitor_jobs = monitor_jobs
        self.jobs = {}
        self.printer_state_reasons = {}
        self.printers = set()
        self.process_pending_events = True
        self.fetch_jobs_timer = None
        self.cups_connection_in_error = False

        if host:
            cups.setServer (host)
        if port:
            cups.setPort (port)
        if encryption:
            cups.setEncryption (encryption)
        self.user = cups.getUser ()
        self.host = cups.getServer ()
        self.port = cups.getPort ()
        self.encryption = cups.getEncryption ()
        self.ppdcache = ppdcache.PPDCache (host=self.host,
                                           port=self.port,
                                           encryption=self.encryption)

        self.which_jobs = "not-completed"
        self.reasons_seen = {}
        self.connecting_timers = {}
        self.still_connecting = set()
        self.connecting_to_device = {}
        self.received_any_dbus_signals = False
        self.update_timer = None

        if bus is None:
            try:
                bus = dbus.SystemBus ()
            except dbus.exceptions.DBusException:
                # System bus not running.
                pass

        self.bus = bus
        if bus is not None:
            bus.add_signal_receiver (self.handle_dbus_signal,
                                     path=self.DBUS_PATH,
                                     dbus_interface=self.DBUS_IFACE)
        self.sub_id = -1
Example #24
0
 def _connect (self):
     cups.setUser (self._use_user)
     cups.setServer (self._server)
     cups.setPort (self._port)
     self._connection = cups.Connection ()
     self._user = self._use_user
     debugprint ("Connected as user %s" % self._user)
     methodtype = type (self._connection.getPrinters)
     for fname in dir (self._connection):
         if fname[0] == '_':
             continue
         fn = getattr (self._connection, fname)
         if type (fn) != methodtype:
             continue
         setattr (self, fname, self._make_binding (fname, fn))
Example #25
0
 def create(cls, printer=None, server="", port=0, user=""):
     """Return a handle to print using a connection to the (local) CUPS server, if available."""
     try:
         import cups
     except ImportError:
         return
     cups.setServer(server or "")
     cups.setPort(port or 0)
     cups.setUser(user or "")
     try:
         c = cups.Connection()
     except RuntimeError:
         return
     h = cls(c, printer)
     if h.printer().printerName() in c.getPrinters():
         return h
Example #26
0
def get_printers( host = None, depth = 0 ) :
	if not host:
		try:
			host = settings.HOST
		except:
			host = "localhost"
		
	msg = "OK"
	try:
		cups.setServer( host )
	except:
		print( "cupstree/get_printers( )" )
		type, value, tb = exc_info()
		msg = "cups.setServer() for host %s failed" % host
		print( "%s\n" % msg )
		return { "msg" : msg, "list" : [] }

	printers = None
	classes  = None
	indent   = None
	
	msg = "OK"
	try:
		c = cups.Connection()
		printers = c.getPrinters ()
		classes  = c.getClasses ()
		indent   = do_indent( depth )
	except:
		print( "cupstree/get_printers( )" )
		type, value, tb = exc_info()
		msg = "cups.Connection() for host %s failed" % host
		print( "%s\n" % msg )
		return { "msg" : msg, "list" : [] }
	
	printer_list = []
	try:
		for ( name, queue ) in iteritems( printers ):
			printer_dict = getqueue( name, queue, host, depth, printers, classes )
			printer_list.append( printer_dict )
	except:
		print( "cupstree/get_printers( )" )
		type, value, tb = exc_info()
		msg = "cups getqueue for host %s failed" % host
		print( "%s\n" % msg )
	
	return { "msg" : msg, "list" : printer_list }
Example #27
0
	def get_printers(self,ip="localhost",port=631):
		printer_list = []
		try:
			import cups
		except ImportError:
			frappe.throw("You need to install pycups to use this feature!")
			return
		try:
			cups.setServer(self.server_ip)
			cups.setPort(self.port)
			conn = cups.Connection()
			printers = conn.getPrinters()
			printer_list = printers.keys()
		except RuntimeError:
			frappe.throw(_("Failed to connect to server"))
		except ValidationError:
			frappe.throw(_("Failed to connect to server"))
		return printer_list
Example #28
0
	def get_printers(self, ip="localhost", port=631):
		printer_list = []
		try:
			import cups
		except ImportError:
			frappe.throw(_("You need to install pycups to use this feature!"))
			return
		try:
			cups.setServer(self.server_ip)
			cups.setPort(self.port)
			conn = cups.Connection()
			printers = conn.getPrinters()
			printer_list = printers.keys()
		except RuntimeError:
			frappe.throw(_("Failed to connect to server"))
		except frappe.ValidationError:
			frappe.throw(_("Failed to connect to server"))
		return printer_list
Example #29
0
def print_label(label_file, name):
    printerName = PRINTER_NAME
    if os.environ.get('WEB_USER') in REMOTES:
        settings = REMOTES[os.environ['WEB_USER']]
        if 'host' not in settings:
            settings['host'] = os.environ.get('WEB_REMOTE_IP')
        if settings['host'] == '::1':
            settings['host'] = '127.0.0.1'
        if 'username' in settings: cups.setUser(settings['username'])
        debug('connecting to remote cups %s' % settings['host'])
        cups.setServer(settings['host'])
        conn = cups.Connection(settings['host'])
        if 'printer' in settings:
            printerName = settings['printer']
    else:
        conn = cups.Connection()
    printer = printerName or conn.getDefault()
    debug('print_label connection done')
    conn.printFile(printer, label_file.name, name, {})
    debug('print_label print job sent')
Example #30
0
    def start(self):
        self._cpt = 0

        if not cups_module:
            print(
                '/!\\ ERROR /!\\: the PrinterTarget has been disabled because python-cups module is not installed'
            )
            return False

        if not self._target_ip:
            print('/!\\ ERROR /!\\: the PrinterTarget IP has not been set')
            return False

        if self._target_port is None:
            self._target_port = 631

        cups.setServer(self._target_ip)
        cups.setPort(self._target_port)

        self.__connection = cups.Connection()

        try:
            printers = self.__connection.getPrinters()
        except cups.IPPError as err:
            print('CUPS Server Errror: ', err)
            return False

        if self._printer_name is not None:
            try:
                params = printers[self._printer_name]
            except:
                print("Printer '%s' is not connected to CUPS server!" %
                      self._printer_name)
                return False
        else:
            self._printer_name, params = printers.popitem()

        print("\nDevice-URI: %s\nPrinter Name: %s" %
              (params["device-uri"], self._printer_name))

        return True
    def __init__(self, parent=None, try_as_root=True, lock=False, host=None, port=None, encryption=None):
        if host != None:
            cups.setServer(host)
        if port != None:
            cups.setPort(port)
        if encryption != None:
            cups.setEncryption(encryption)

        self._use_password = ""
        self._parent = parent
        self._try_as_root = try_as_root
        self._use_user = cups.getUser()
        self._server = cups.getServer()
        self._port = cups.getPort()
        self._encryption = cups.getEncryption()
        self._prompt_allowed = True
        self._operation_stack = []
        self._lock = lock
        self._gui_event = threading.Event()

        self._connect()
Example #32
0
    def serve(self):
        try:
            server = self.env.config.get("cups.server")
            port = self.env.config.get("cups.port")
            user = self.env.config.get("cups.user")
            password = self.env.config.get("cups.password")
            encryption_policy = getattr(
                cups, "HTTP_ENCRYPT_%s" % self.env.config.get(
                    "cups.encryption-policy", default="IF_REQUESTED").upper())
            if server is not None:
                cups.setServer(server)
            if port is not None:
                cups.setPort(int(port))
            if user is not None:
                cups.setUser(user)
            if encryption_policy is not None:
                cups.setEncryption(encryption_policy)

            if password is not None:

                def pw_callback(prompt):
                    return password

                cups.setPasswordCB(pw_callback)

            self.client = cups.Connection()

            sched = PluginRegistry.getInstance(
                "SchedulerService").getScheduler()
            sched.add_interval_job(self.__gc,
                                   minutes=60,
                                   tag='_internal',
                                   jobstore="ram")
            sched.add_interval_job(self.__update_printer_list,
                                   minutes=30,
                                   tag='_internal',
                                   jobstore="ram")

        except RuntimeError as e:
            self.log.error(str(e))
Example #33
0
def main():
    global c, f, p
    c = None
    f = None
    p = None

    # test for directory existance
    uppath = __UPLOADS__ + "sample.txt"
    uppath = os.path.dirname(uppath)
    if not os.path.exists(uppath):
        print "making directories at " + uppath
        os.makedirs(uppath)

    temppath = __TMP__ + "sample.txt"
    temppath = os.path.dirname(temppath)
    if not os.path.exists(temppath):
        print "making directories at " + temppath
        os.makedirs(temppath)

    cups.setServer("localhost")
    application = Application()
    application.listen(8080, '0.0.0.0')
    tornado.ioloop.IOLoop.instance().start()
Example #34
0
def getippqueue(dev, queue, depth):
  #  print "entro en el metodo: getippqueue"
    name = dev.rfind('/')
    name = dev[name + 1:]
    dev = dev[6:]
    e = dev.find(':')
    if e == -1:
        e = dev.find('/')
    host = dev[:e]
    cups.setServer(host)
    try:
        c = cups.Connection()
        printers = c.getPrinters()
    except RuntimeError:
        # Failed to connect.
        return
    except cups.IPPError, e:
        if e == cups.IPP_OPERATION_NOT_SUPPORTED:
            # CUPS-Get-Printers not supported so not a CUPS server.
            printers = {}
            classes = {}
        else:
            return
Example #35
0
def getippqueue(dev, queue, depth):
  #  print "entro en el metodo: getippqueue"
    name = dev.rfind('/')
    name = dev[name + 1:]
    dev = dev[6:]
    e = dev.find(':')
    if e == -1:
        e = dev.find('/')
    host = dev[:e]
    cups.setServer(host)
    try:
        c = cups.Connection()
        printers = c.getPrinters()
    except RuntimeError:
        # Failed to connect.
        return
    except cups.IPPError, e:
        if e == cups.IPP_OPERATION_NOT_SUPPORTED:
            # CUPS-Get-Printers not supported so not a CUPS server.
            printers = {}
            classes = {}
        else:
            return
Example #36
0
class Printer(models.Model):
    name = models.CharField(max_length=255, unique=True)
    location = models.CharField(max_length=255, blank=True)
    uri = models.CharField(max_length=255, blank=True)
    model = models.CharField(max_length=255, blank=True)
    asset_tag = models.CharField(max_length=255, blank=True)
    toner_levels = models.CharField(max_length=1024, blank=True)
    connection = models.CharField(max_length=1024, blank=True, null=True)

    cups.setServer(settings.CUPS_SERVER)
    c = cups.Connection()

    def update_data_from_cups(self):
        try:
            all_data = c.getPrinterAttributes(name=self.name)
        except:  # Renew connection
            c = cups.Connection()
            all_data = c.getPrinterAttributes(name=self.name)
        self.location = all_data.get('printer-location', '')
        self.uri = all_data.get('printer-uri-supported', '')
        self.model = all_data.get('printer-make-and-model', '')
        self.connection = all_data.get('device-uri', '')
        marker_names = all_data.get('marker-names', '')
        marker_levels = all_data.get('marker-levels', '')
        if marker_names and marker_levels:
            toner_txt = ''
            # I've never seen this used.
            #toner_high_level = all_data.get('toner_high_level', '')
            for name, level in zip(marker_names, marker_levels):
                # A value of -1 indicates the level is unavailable, -2 indicates unknown, and -3 indicates the level is unknown but has not yet reached capacity
                if level != -1 and level != -2:
                    if level == -3:
                        level = "Not at capacity"
                    toner_txt += '%s: %s, ' % (
                        name,
                        level,
                    )
            self.toner_levels = toner_txt[:-2]

        self.save()

    @property
    def state(self):
        try:
            state = self.c.getPrinterAttributes(name=self.name,
                                                requested_attributes=[
                                                    'printer-state'
                                                ])['printer-state']
        except:
            try:
                c = cups.Connection()
                state = self.c.getPrinterAttributes(name=self.name,
                                                    requested_attributes=[
                                                        'printer-state'
                                                    ])['printer-state']
            except:
                return "Can't connect"
        if state == 3:
            return "Idle"
        elif state == 4:
            return "Printing"
        elif state == 5:
            return "Stopped"
        else:
            return state

    @property
    def state_reason(self):
        try:
            state_reasons = self.c.getPrinterAttributes(
                name=self.name,
                requested_attributes=['printer-state-reasons'
                                      ])['printer-state-reasons']
            txt = ''
            for reason in state_reasons:
                txt += '%s, ' % (reason, )
            return txt[:-2]
        except:
            c = cups.Connection()
 def getServerSettings ():
     # Fail if auth required.
     cups.setPasswordCB (lambda x: '')
     cups.setServer ('')
     c = cups.Connection ()
     return c.adminGetServerSettings ()
Example #38
0
import argparse
import cups

parser = argparse.ArgumentParser(description='List CUPS jobs on remote print server')
parser.add_argument('-l', '--limit', type=int, default=10, help='Number of jobs to return')
parser.add_argument('status', choices=['completed', 'not-completed', 'all'], help='CUPS Job Status')
parser.add_argument('server', nargs='+', help='Print Server')
args = parser.parse_args()

# Placeholder to track if we already printed
printed = None

for server in args.server:
    # Only print a blank line when multiple servers are queried
    if printed:
        print()
    printed = True

    cups.setServer(server)
    conn = cups.Connection()
    jobs = conn.getJobs(which_jobs=args.status, limit=args.limit)

    print('Jobs on server: {0}'.format(server))
    print('  {0:<10} {1:<18} {2}'.format('USER', 'HOST', 'JOB'))

    for job in jobs:
        print('  {0:<10} {1:<18} {2}'.format(
                                            jobs[job]['job-originating-user-name'],
                                            jobs[job]['job-originating-host-name'],
                                            jobs[job]['job-name']))
Example #39
0
while not camera_connected:
    try:
        camera = gp.Camera()
        camera.init()
        camera_connected = True
    except gp.GPhoto2Error:
        print(
            "Camera not detected, please turn camera on. Attempting to connect again in 3 seconds..."
        )
        pg.time.wait(3000)

#initialize button
button = Button(25)

#initialzie printer
cups.setServer("localhost")
success = False
while not success:
    try:
        conn = cups.Connection()
        printers = conn.getPrinters()

        if DEBUG:
            for printer in printers:
                print("{} - {}".format(printer,
                                       printers[printer]['device-uri']))
                PRINTER_NAME = printer
            print("Main printer: {}".format(PRINTER_NAME))
        success = True
    except RuntimeError:
        print("Not able to connect to printer, trying again in one second...")
    def display (self):
        self.answers = {}

        answers = self.troubleshooter.answers
        if not answers['cups_queue_listed']:
            return False

        parent = self.troubleshooter.get_window ()
        name = answers['cups_queue']
        tmpf = None
        try:
            cups.setServer ('')
            self.op = TimedOperation (cups.Connection, parent=parent)
            c = self.op.run ()
            self.op = TimedOperation (c.getPPD, args=(name,), parent=parent)
            tmpf = self.op.run ()
        except RuntimeError:
            return False
        except cups.IPPError:
            return False

        self.install_button.hide ()
        title = None
        text = None
        try:
            ppd = cups.PPD (tmpf)
            self.answers['cups_printer_ppd_valid'] = True

            def options (options_list):
                o = {}
                for option in options_list:
                    o[option.keyword] = option.defchoice
                return o

            defaults = {}
            for group in ppd.optionGroups:
                g = options (group.options)
                for subgroup in group.subgroups:
                    g[subgroup.name] = options (subgroup.options)
                defaults[group.name] = g
            self.answers['cups_printer_ppd_defaults'] = defaults
        except RuntimeError:
            title = _("Invalid PPD File")
            self.answers['cups_printer_ppd_valid'] = False
            try:
                self.op = TimedSubprocess (parent=parent,
                                           args=['cupstestppd', '-rvv', tmpf],
                                           close_fds=True,
                                           stdin=subprocess.DEVNULL,
                                           stdout=subprocess.PIPE,
                                           stderr=subprocess.PIPE)
                result = self.op.run ()
                self.answers['cupstestppd_output'] = result
                text = _("The PPD file for printer '%s' does not conform "
                         "to the specification.  "
                         "Possible reason follows:") % name
                text += '\n' + reduce (lambda x, y: x + '\n' + y, result[0])
            except OSError:
                # Perhaps cupstestppd is not in the path.
                text = _("There is a problem with the PPD file for "
                         "printer '%s'.") % name

        if tmpf:
            os.unlink (tmpf)

        if title == None and not answers['cups_printer_remote']:
            (pkgs, exes) = cupshelpers.missingPackagesAndExecutables (ppd)
            self.answers['missing_pkgs_and_exes'] = (pkgs, exes)
            if len (pkgs) > 0 or len (exes) > 0:
                title = _("Missing Printer Driver")
                if len (pkgs) > 0:
                    try:
                        self.packagekit = installpackage.PackageKit ()
                    except:
                        pkgs = []

                if len (pkgs) > 0:
                    self.package = pkgs[0]
                    text = _("Printer '%s' requires the %s package but it "
                             "is not currently installed.") % (name,
                                                               self.package)
                    self.install_button.show ()
                else:
                    text = _("Printer '%s' requires the '%s' program but it "
                             "is not currently installed.") % (name,
                                                               (exes + pkgs)[0])

        if title != None:
            self.label.set_markup ('<span weight="bold" size="larger">' +
                                   title + '</span>\n\n' + text)

        return title != None
Example #41
0
 def __init__(self, usuario, clave):
     self.gpp = clave
     cups.setServer(settings.CUPS_SERVER.get('maestro'))
     cups.setUser(usuario)
Example #42
0
 def __init__(self):
     cups.setServer("localhost")
     self.printer_name = self.load_default_printer()
     self.conn = ""
Example #43
0
 def get(self, request, *args, **kwargs):
     cups.setServer(CUPS_IP)
     cups_instance = cups.Connection()
     items = cups_instance.getPrinters()
     return HttpResponse(json.dumps(items), content_type="application/json")
Example #44
0
    def display(self):
        self.answers = {}

        answers = self.troubleshooter.answers
        if not answers['cups_queue_listed']:
            return False

        parent = self.troubleshooter.get_window()
        name = answers['cups_queue']
        tmpf = None
        try:
            cups.setServer('')
            self.op = TimedOperation(cups.Connection, parent=parent)
            c = self.op.run()
            self.op = TimedOperation(c.getPPD, args=(name, ), parent=parent)
            tmpf = self.op.run()
        except RuntimeError:
            return False
        except cups.IPPError:
            return False

        self.install_button.hide()
        title = None
        text = None
        try:
            ppd = cups.PPD(tmpf)
            self.answers['cups_printer_ppd_valid'] = True

            def options(options_list):
                o = {}
                for option in options_list:
                    o[option.keyword] = option.defchoice
                return o

            defaults = {}
            for group in ppd.optionGroups:
                g = options(group.options)
                for subgroup in group.subgroups:
                    g[subgroup.name] = options(subgroup.options)
                defaults[group.name] = g
            self.answers['cups_printer_ppd_defaults'] = defaults
        except RuntimeError:
            title = _("Invalid PPD File")
            self.answers['cups_printer_ppd_valid'] = False
            try:
                self.op = TimedSubprocess(parent=parent,
                                          args=['cupstestppd', '-rvv', tmpf],
                                          close_fds=True,
                                          stdin=file("/dev/null"),
                                          stdout=subprocess.PIPE,
                                          stderr=subprocess.PIPE)
                result = self.op.run()
                self.answers['cupstestppd_output'] = result
                text = _("The PPD file for printer '%s' does not conform "
                         "to the specification.  "
                         "Possible reason follows:") % name
                text += '\n' + reduce(lambda x, y: x + '\n' + y, result[0])
            except OSError:
                # Perhaps cupstestppd is not in the path.
                text = _("There is a problem with the PPD file for "
                         "printer '%s'.") % name

        if tmpf:
            os.unlink(tmpf)

        if title == None and not answers['cups_printer_remote']:
            (pkgs, exes) = cupshelpers.missingPackagesAndExecutables(ppd)
            self.answers['missing_pkgs_and_exes'] = (pkgs, exes)
            if len(pkgs) > 0 or len(exes) > 0:
                title = _("Missing Printer Driver")
                if len(pkgs) > 0:
                    try:
                        self.packagekit = installpackage.PackageKit()
                    except:
                        pkgs = []

                if len(pkgs) > 0:
                    self.package = pkgs[0]
                    text = _(
                        "Printer '%s' requires the %s package but it "
                        "is not currently installed.") % (name, self.package)
                    self.install_button.show()
                else:
                    text = _(
                        "Printer '%s' requires the '%s' program but it "
                        "is not currently installed.") % (name,
                                                          (exes + pkgs)[0])

        if title != None:
            self.label.set_markup('<span weight="bold" size="larger">' +
                                  title + '</span>\n\n' + text)

        return title != None
Example #45
0
 def modo_admin(self):
     cups.setServer(settings.CUPS_SERVER.get('maestro'))
     cups.setUser(settings.CUPS_ADMIN[0])
     cups.setPasswordCB(callback_admin)
     self.cups_con = cups.Connection()
Example #46
0
    def display (self):
        # Collect information useful for the various checks.

        self.answers = {}

        answers = self.troubleshooter.answers
        if not answers['cups_queue_listed']:
            return False

        name = answers['cups_queue']

        parent = self.troubleshooter.get_window ()

        # Find out if this is a printer or a class.
        try:
            cups.setServer ('')
            c = TimedOperation (cups.Connection, parent=parent).run ()
            printers = TimedOperation (c.getPrinters, parent=parent).run ()
            if printers.has_key (name):
                self.answers['is_cups_class'] = False
                queue = printers[name]
                self.answers['cups_printer_dict'] = queue
            else:
                self.answers['is_cups_class'] = True
                classes = TimedOperation (c.getClasses, parent=parent).run ()
                queue = classes[name]
                self.answers['cups_class_dict'] = queue

            attrs = TimedOperation (c.getPrinterAttributes, (name,),
                                    parent=parent).run ()
            self.answers['local_cups_queue_attributes'] = attrs
        except:
            pass

        if self.answers.has_key ('cups_printer_dict'):
            cups_printer_dict = self.answers['cups_printer_dict']
            uri = cups_printer_dict['device-uri']
            (scheme, rest) = urllib.splittype (uri)
            self.answers['cups_device_uri_scheme'] = scheme
            if scheme in ["ipp", "http", "https"]:
                (hostport, rest) = urllib.splithost (rest)
                (host, port) = urllib.splitnport (hostport, defport=631)
                self.answers['remote_server_name'] = host
                self.answers['remote_server_port'] = port
            elif scheme == "smb":
                u = smburi.SMBURI (uri)
                (group, host, share, user, password) = u.separate ()
                new_environ = os.environ.copy()
                new_environ['LC_ALL'] = "C"
                if group:
                    args = ["nmblookup", "-W", group, host]
                else:
                    args = ["nmblookup", host]
                try:
                    p = TimedSubprocess (parent=parent,
                                         timeout=5000,
                                         args=args,
                                         env=new_environ,
                                         close_fds=True,
                                         stdin=file("/dev/null"),
                                         stdout=subprocess.PIPE,
                                         stderr=subprocess.PIPE)
                    result = p.run ()
                    self.answers['nmblookup_output'] = result
                    for line in result[0]:
                        if line.startswith ("querying"):
                            continue
                        spc = line.find (' ')
                        if (spc != -1 and
                            not line[spc:].startswith (" failed ")):
                            # Remember the IP address.
                            self.answers['remote_server_name'] = line[:spc]
                            break
                except OSError:
                    # Problem executing command.
                    pass
            elif scheme == "hp":
                new_environ = os.environ.copy()
                new_environ['LC_ALL'] = "C"
                new_environ['DISPLAY'] = ""
                try:
                    p = TimedSubprocess (parent=parent,
                                         timeout=3000,
                                         args=["hp-info", "-d" + uri],
                                         close_fds=True,
                                         env=new_environ,
                                         stdin=file("/dev/null"),
                                         stdout=subprocess.PIPE,
                                         stderr=subprocess.PIPE)
                    self.answers['hplip_output'] = p.run ()
                except OSError:
                    # Problem executing command.
                    pass

            r = cups_printer_dict['printer-type'] & cups.CUPS_PRINTER_REMOTE
            self.answers['cups_printer_remote'] = (r != 0)
        return False
Example #47
0
 def post(self, request, *args, **kwargs):
     cups.setServer(CUPS_IP)
     cups_instance = cups.Connection()
     cups_instance.cancelJob(int(kwargs.get("job_id"))) # This does not return any useful information
     return HttpResponse("ok")
Example #48
0
    def display (self):
        # Collect information useful for the various checks.

        self.answers = {}

        answers = self.troubleshooter.answers
        if not answers['cups_queue_listed']:
            return False

        name = answers['cups_queue']

        parent = self.troubleshooter.get_window ()

        # Find out if this is a printer or a class.
        try:
            cups.setServer ('')
            c = TimedOperation (cups.Connection, parent=parent).run ()
            printers = TimedOperation (c.getPrinters, parent=parent).run ()
            if printers.has_key (name):
                self.answers['is_cups_class'] = False
                queue = printers[name]
                self.answers['cups_printer_dict'] = queue
            else:
                self.answers['is_cups_class'] = True
                classes = TimedOperation (c.getClasses, parent=parent).run ()
                queue = classes[name]
                self.answers['cups_class_dict'] = queue

            attrs = TimedOperation (c.getPrinterAttributes, (name,),
                                    parent=parent).run ()
            self.answers['local_cups_queue_attributes'] = attrs
        except:
            pass

        if self.answers.has_key ('cups_printer_dict'):
            cups_printer_dict = self.answers['cups_printer_dict']
            uri = cups_printer_dict['device-uri']
            (scheme, rest) = urllib.splittype (uri)
            self.answers['cups_device_uri_scheme'] = scheme
            if scheme in ["ipp", "http", "https"]:
                (hostport, rest) = urllib.splithost (rest)
                (host, port) = urllib.splitnport (hostport, defport=631)
                self.answers['remote_server_name'] = host
                self.answers['remote_server_port'] = port
            elif scheme == "smb":
                u = smburi.SMBURI (uri)
                (group, host, share, user, password) = u.separate ()
                new_environ = os.environ.copy()
                new_environ['LC_ALL'] = "C"
                if group:
                    args = ["nmblookup", "-W", group, host]
                else:
                    args = ["nmblookup", host]
                try:
                    p = TimedSubprocess (parent=parent,
                                         timeout=5000,
                                         args=args,
                                         env=new_environ,
                                         close_fds=True,
                                         stdin=file("/dev/null"),
                                         stdout=subprocess.PIPE,
                                         stderr=subprocess.PIPE)
                    result = p.run ()
                    self.answers['nmblookup_output'] = result
                    for line in result[0]:
                        if line.startswith ("querying"):
                            continue
                        spc = line.find (' ')
                        if (spc != -1 and
                            not line[spc:].startswith (" failed ")):
                            # Remember the IP address.
                            self.answers['remote_server_name'] = line[:spc]
                            break
                except OSError:
                    # Problem executing command.
                    pass
            elif scheme == "hp":
                new_environ = os.environ.copy()
                new_environ['LC_ALL'] = "C"
                new_environ['DISPLAY'] = ""
                try:
                    p = TimedSubprocess (parent=parent,
                                         timeout=3000,
                                         args=["hp-info", "-d" + uri],
                                         close_fds=True,
                                         env=new_environ,
                                         stdin=file("/dev/null"),
                                         stdout=subprocess.PIPE,
                                         stderr=subprocess.PIPE)
                    self.answers['hplip_output'] = p.run ()
                except OSError:
                    # Problem executing command.
                    pass

            r = cups_printer_dict['printer-type'] & cups.CUPS_PRINTER_REMOTE
            self.answers['cups_printer_remote'] = (r != 0)
        return False
Example #49
0
 def getServerSettings():
     # Fail if auth required.
     cups.setPasswordCB(lambda x: '')
     cups.setServer('')
     c = cups.Connection()
     return c.adminGetServerSettings()
    def display (self):
        troubleshooter = self.troubleshooter
        try:
            queue = troubleshooter.answers['cups_queue']
        except KeyError:
            return False

        parent = self.troubleshooter.get_window ()
        cups.setServer ('')
        self.op = TimedOperation (cups.Connection, parent=parent)
        c = self.op.run ()
        self.op = TimedOperation (c.getPrinterAttributes,
                                  args=(queue,),
                                  parent=parent)
        dict = self.op.run ()

        the_ppdcache = ppdcache.PPDCache ()

        text = ''
        state_message = dict['printer-state-message']
        if state_message:
            text += _("The printer's state message is: '%s'.") % state_message
            text += '\n\n'

        state_reasons_list = dict['printer-state-reasons']
        if type (state_reasons_list) == unicode:
            state_reasons_list = [state_reasons_list]

        self.state_message = state_message
        self.state_reasons = state_reasons_list

        human_readable_errors = []
        human_readable_warnings = []
        for reason in state_reasons_list:
            if reason == "none":
                continue

            r = statereason.StateReason (queue, reason, the_ppdcache)
            (title, description) = r.get_description ()
            level = r.get_level ()
            if level == statereason.StateReason.ERROR:
                human_readable_errors.append (description)
            elif level == statereason.StateReason.WARNING:
                human_readable_warnings.append (description)

        if human_readable_errors:
            text += _("Errors are listed below:") + '\n'
            text += reduce (lambda x, y: x + "\n" + y, human_readable_errors)
            text += '\n\n'

        if human_readable_warnings:
            text += _("Warnings are listed below:") + '\n'
            text += reduce (lambda x, y: x + "\n" + y, human_readable_warnings)

        self.label.set_text (text)
        if (state_message == '' and
            len (human_readable_errors) == 0 and
            len (human_readable_warnings) == 0):
            return False

        # If this screen has been show before, don't show it again if
        # nothing changed.
        if troubleshooter.answers.has_key ('printer-state-message'):
            if (troubleshooter.answers['printer-state-message'] ==
                self.state_message and
                troubleshooter.answers['printer-state-reasons'] ==
                self.state_reasons):
                return False

        return True
Example #51
0
        if value['printer-state-reasons'][0] != 'none':
            printersStatus.labels(
                printer=key,
                model=value['printer-make-and-model'],
                status=value['printer-state-reasons'][0]).set(0)
        else:
            printersStatus.labels(printer=key,
                                  model=value['printer-make-and-model'],
                                  status='happy').set(1)


if __name__ == '__main__':
    # Start up the server to expose the metrics.
    start_http_server(args.listen_port)

    cups.setServer(args.cups_host)
    cups.setPort(args.cups_port)
    cups.setUser(args.cups_user)

    while True:
        try:
            conn = cups.Connection()
            printers = getPrinterData(conn)
            getJobData(conn)
            getPrinterStatus(printers)
            cupsUp.set(1)
        except Exception as e:
            cupsUp.set(0)
            print(e)

        time.sleep(5)
    def display (self):
        troubleshooter = self.troubleshooter
        try:
            queue = troubleshooter.answers['cups_queue']
        except KeyError:
            return False

        parent = self.troubleshooter.get_window ()
        cups.setServer ('')
        self.op = TimedOperation (cups.Connection, parent=parent)
        c = self.op.run ()
        self.op = TimedOperation (c.getPrinterAttributes,
                                  args=(queue,),
                                  parent=parent)
        dict = self.op.run ()

        the_ppdcache = ppdcache.PPDCache ()

        text = ''
        state_message = dict['printer-state-message']
        if state_message:
            text += _("The printer's state message is: '%s'.") % state_message
            text += '\n\n'

        state_reasons_list = dict['printer-state-reasons']
        if type (state_reasons_list) == str:
            state_reasons_list = [state_reasons_list]

        self.state_message = state_message
        self.state_reasons = state_reasons_list

        human_readable_errors = []
        human_readable_warnings = []
        for reason in state_reasons_list:
            if reason == "none":
                continue

            r = statereason.StateReason (queue, reason, the_ppdcache)
            (title, description) = r.get_description ()
            level = r.get_level ()
            if level == statereason.StateReason.ERROR:
                human_readable_errors.append (description)
            elif level == statereason.StateReason.WARNING:
                human_readable_warnings.append (description)

        if human_readable_errors:
            text += _("Errors are listed below:") + '\n'
            text += reduce (lambda x, y: x + "\n" + y, human_readable_errors)
            text += '\n\n'

        if human_readable_warnings:
            text += _("Warnings are listed below:") + '\n'
            text += reduce (lambda x, y: x + "\n" + y, human_readable_warnings)

        self.label.set_text (text)
        if (state_message == '' and
            len (human_readable_errors) == 0 and
            len (human_readable_warnings) == 0):
            return False

        # If this screen has been show before, don't show it again if
        # nothing changed.
        if 'printer-state-message' in troubleshooter.answers:
            if (troubleshooter.answers['printer-state-message'] ==
                self.state_message and
                troubleshooter.answers['printer-state-reasons'] ==
                self.state_reasons):
                return False

        return True
Example #53
0
import cups

cups.setServer("121.248.53.183")
cups.setPort(631)
# conn = cups.Connection()
# print cups.getServer(),cups.getPort()
# conn.printFile('xerox','123.pdf','test',{})
# printers = conn.getPrinters ()

# for printer in printers:
# 	print printer, printers[printer]["device-uri"]
conn = cups.Connection()
printers = conn.getPrinters()
printer_name = printers.keys()[0]
print printer_name
conn.printFile(printer_name, "1234.pdf", "Photo Booth", {"page-ranges": "3-4", "sides": "two-sided-long-edges"})

# conn.printFile(printer_name, BPicture, "Photo Booth",{"copies": "2"})