示例#1
0
    def refresh(self, which_jobs=None, refresh_all=True):
        debugprint ("refresh")

        self.emit ('refresh')
        if which_jobs != None:
            self.which_jobs = which_jobs

        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)
        except RuntimeError:
            self.emit ('cups-connection-error')
            cups.setUser (user)
            return

        if self.sub_id != -1:
            try:
                c.cancelSubscription (self.sub_id)
            except cups.IPPError, (e, m):
                self.emit ('cups-ipp-error', e, m)

            if self.update_timer:
                gobject.source_remove (self.update_timer)

            debugprint ("Canceled subscription %d" % self.sub_id)
    def _connect (self, allow_pk=True):
        cups.setUser (self._use_user)

        self._use_pk = (allow_pk and
                        (self._server[0] == '/' or self._server == 'localhost')
                        and os.getuid () != 0)
        if self._use_pk:
            create_object = cupspk.Connection
        else:
            create_object = cups.Connection

        self._connection = create_object (host=self._server,
                                            port=self._port,
                                            encryption=self._encryption)

        if self._use_pk:
            self._connection.set_parent(self._parent)

        self._user = self._use_user
        debugprint ("Connected as user %s" % self._user)
        methodtype_lambda = type (self._connection.getPrinters)
        methodtype_real = type (self._connection.addPrinter)
        for fname in dir (self._connection):
            if fname[0] == '_':
                continue
            fn = getattr (self._connection, fname)
            if not type (fn) in [methodtype_lambda, methodtype_real]:
                continue
            setattr (self, fname, self._make_binding (fname, fn))
示例#3
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
示例#4
0
文件: main.py 项目: 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
    def cleanup(self):
        if self.sub_id != -1:
            user = cups.getUser()
            try:
                cups.setUser(self.user)
                c = cups.Connection(host=self.host,
                                    port=self.port,
                                    encryption=self.encryption)
                c.cancelSubscription(self.sub_id)
                debugprint("Canceled subscription %d" % self.sub_id)
            except:
                pass
            cups.setUser(user)

        if self.bus is not None:
            self.bus.remove_signal_receiver(self.handle_dbus_signal,
                                            path=self.DBUS_PATH,
                                            dbus_interface=self.DBUS_IFACE)

        timers = list(self.connecting_timers.values())
        for timer in [self.update_timer, self.fetch_jobs_timer]:
            if timer:
                timers.append(timer)
        for timer in timers:
            GLib.source_remove(timer)

        self.emit('monitor-exited')
示例#6
0
    def cleanup (self):
        if self.sub_id != -1:
            user = cups.getUser ()
            try:
                cups.setUser (self.user)
                c = cups.Connection (host=self.host,
                                     port=self.port,
                                     encryption=self.encryption)
                c.cancelSubscription (self.sub_id)
                debugprint ("Canceled subscription %d" % self.sub_id)
            except:
                pass
            cups.setUser (user)

        if self.bus is not None:
            self.bus.remove_signal_receiver (self.handle_dbus_signal,
                                             path=self.DBUS_PATH,
                                             dbus_interface=self.DBUS_IFACE)

        timers = list(self.connecting_timers.values ())
        for timer in [self.update_timer, self.fetch_jobs_timer]:
            if timer:
                timers.append (timer)
        for timer in timers:
            GLib.source_remove (timer)

        self.emit ('monitor-exited')
示例#7
0
def print_photos(jpg_group, img_size):
    conn = cups.Connection()
    printers = conn.getPrinters()
    print('Printers: ' + str(list(printers)))
    cups.setUser('pi')
    if config.print_to_pdf or len(printers) == 1:
        print('Printing to PDF')
        if 'PDF' in printers.keys():
            printer_name = 'PDF'
        else:
            print('No PDF driver.')
            return
    else:
        try:
            printer_name = config.printer_name
            if not printer_name in printers.keys():
                print('Cannot find printer (' + printer_name + ')')
                return
        except AttributeError:
            printer_name = None
            for key in printers.keys():
                if key != 'PDF':
                    printer_name = key
                    break
            if printer_name is None:
                print('no valid printer found')
                return
    img = create_collage(jpg_group, img_size)
    filename = config.file_path + jpg_group + '-collage.jpg'
    pygame.image.save(img, filename)
    print('Printing to ' + printer_name)
    conn.printFile(printer_name, filename, 'Photobooth-' + jpg_group, {'fit-to-page':'true'})
示例#8
0
    def run (self):
        if self.host == None:
            self.host = cups.getServer ()
        if self.port == None:
            self.port = cups.getPort ()
        if self._encryption == None:
            self._encryption = cups.getEncryption ()

        if self.user:
            cups.setUser (self.user)
        else:
            self.user = cups.getUser ()

        try:
            cups.setPasswordCB2 (self._auth)
        except AttributeError:
            # Requires pycups >= 1.9.47.  Fall back to rubbish API.
            cups.setPasswordCB (self._auth)

        try:
            conn = cups.Connection (host=self.host,
                                    port=self.port,
                                    encryption=self._encryption)
            self._reply (None)
        except RuntimeError, e:
            conn = None
            self._error (e)
示例#9
0
    def _connect (self, allow_pk=True):
        cups.setUser (self._use_user)

        self._use_pk = (allow_pk and
                        (self._server[0] == '/' or self._server == 'localhost')
                        and os.getuid () != 0)
        if self._use_pk:
            create_object = cupspk.Connection
        else:
            create_object = cups.Connection

        self._connection = create_object (host=self._server,
                                            port=self._port,
                                            encryption=self._encryption)

        if self._use_pk:
            self._connection.set_parent(self._parent)

        self._user = self._use_user
        debugprint ("Connected as user %s" % self._user)
        methodtype_lambda = type (self._connection.getPrinters)
        methodtype_real = type (self._connection.addPrinter)
        for fname in dir (self._connection):
            if fname[0] == '_':
                continue
            fn = getattr (self._connection, fname)
            if not type (fn) in [methodtype_lambda, methodtype_real]:
                continue
            setattr (self, fname, self._make_binding (fname, fn))
示例#10
0
def cups_print(username, printer_name):
    conn = cups.Connection()
    filename = eg.fileopenbox("Select the file to be printed", "File Selector")
    title = "Filename : " + filename
    msg = "empty - print all pages, '-' for range, ',' separate ranges)"

    field_names = ["Pages to be printed"]
    field_values = []  # we start with blanks for the values
    field_values = eg.multenterbox(msg, title, field_names, field_values)

    job_id = 0
    if filename:
        cups.setUser(username)
        options = {'sides': 'two-sided-long-edge'}
        val = str(field_values[0]).replace(" ", "").strip(',')
        if bool(val):
            options['page-ranges'] = val

        try:
            conn.setPrinterUsersAllowed(printer_name, [username])
            job_id = conn.printFile(printer_name, filename, filename, options)
            conn.setPrinterUsersAllowed(printer_name, [''])
        except cups.IPPError as (status, description):
            eg.msgbox(title='IPP status is %d' % status,
                      msg='Meaning: %s' % description)
示例#11
0
    def _authloop (self, fname, fn, *args, **kwds):
        self._passes = 0
        c = self._connection
        retry = False
        while True:
            try:
                if self._perform_authentication () == 0:
                    break

                if c != self._connection:
                    # We have reconnected.
                    fn = getattr (self._connection, fname)
                    c = self._connection

                cups.setUser (self._use_user)

                result = fn.__call__ (*args, **kwds)

                if fname == 'adminGetServerSettings':
                    # Special case for a rubbish bit of API.
                    if result == {}:
                        # Authentication failed, but we aren't told that.
                        raise cups.IPPError (cups.IPP_NOT_AUTHORIZED, '')
                break
            except cups.IPPError, (e, m):
                if self._use_pk and m == 'pkcancel':
                    raise cups.IPPError (0, _("Operation canceled"))

                if not self._cancel and (e == cups.IPP_NOT_AUTHORIZED or
                                         e == cups.IPP_FORBIDDEN or
                                         e == cups.IPP_AUTHENTICATION_CANCELED):
                    self._failed (e == cups.IPP_FORBIDDEN)
                elif not self._cancel and e == cups.IPP_SERVICE_UNAVAILABLE:
                    if self._lock:
                        self._gui_event.clear ()
                        gobject.timeout_add (1, self._ask_retry_server_error, m)
                        self._gui_event.wait ()
                    else:
                        self._ask_retry_server_error (m)

                    if self._retry_response == gtk.RESPONSE_OK:
                        debugprint ("retrying operation...")
                        retry = True
                        self._passes -= 1
                        self._has_failed = True
                    else:
                        self._cancel = True
                        raise
                else:
                    if self._cancel and not self._cannot_auth:
                        raise cups.IPPError (0, _("Operation canceled"))

                    debugprint ("%s: %s" % (e, m))
                    raise
            except cups.HTTPError, (s,):
                if not self._cancel:
                    self._failed (s == cups.HTTP_FORBIDDEN)
                else:
                    raise
示例#12
0
def printPic(*args):
    conn = cups.Connection()
    printers = conn.getPrinters()
    printer_name = printers.keys()[0]
    cups.setUser('pi')
    output = custom.PROC_FILENAME
    print_id = conn.printFile(printer_name, output, "Photobooth", {})
    start_img()
    def __init__(self, host=None, user=None, port=None, adminurl=False):
        self.host = host
        self.user = user
        self.port = port
        self.adminurl = adminurl

        if self.user:
            cups.setUser(self.user)
示例#14
0
文件: pbooth.py 项目: zoroloco/boothy
def printPic(fileName):
    addPreviewOverlay(100,200,55,"printing...")
    conn = cups.Connection()
    printers = conn.getPrinters()
    default_printer = printers.keys()[0]
    cups.setUser('pi')
    conn.printFile (default_printer, fileName, "boothy", {'fit-to-page':'True'})
    logging.info("Print job successfully created.");
示例#15
0
def printPic(fileName):
    conn = cups.Connection()
    printers = conn.getPrinters()
    default_printer = printers.keys()[0]
    cups.setUser('pi')
    conn.printFile(default_printer, fileName, "boothy",
                   {'fit-to-page': 'True'})
    logging.info("Print job successfully created.")
示例#16
0
 def __init__(self, butterfly):
     cups.setPasswordCB(self.password_response)
     cups.setUser("cups_ctrl")
     self.bad_password = False
     self.IPP_STATUS_CODES = {
         cups.IPP_PRINTER_IDLE: "IDLE",
         cups.IPP_PRINTER_PROCESSING: "PROCESSING",
         cups.IPP_PRINTER_STOPPED: "STOPPED"
     }
示例#17
0
def printPic2Cut(fileName):
    #addPreviewOverlay(100,200,55,"printing...")
    conn = cups.Connection()
    printers = conn.getPrinters()
    default_printer = list(printers.keys())[0]
    cups.setUser('pi')
    conn.printFile(default_printer, fileName, "boothy",
                   {'fit-to-page': 'True'})
    print("Print job successfully created.")
示例#18
0
    def __init__(self):

        try:
            self.conn = cups.Connection()
            self.printers = self.conn.getPrinters()
            cups.setUser(getpass.getuser())
        except:
            print("Drucker konnte nicht intitialisiert werden.")
            self.printers = {}
            CfgService.set(CfgKey.PRINTER_IS_ACTIVE, False)
def printCups(photo_number, filename_prefix):
    filename = filename_prefix + '_' + str(photo_number) + 'of' + str(
        total_pics) + '.jpg'
    conn = cups.Connection()
    printers = conn.getPrinters()
    printer_name = list(printers)[0]
    cups.setUser('pi')
    #Photo printed one time
    conn.enablePrinter(printer_name)
    conn.printFile(printer_name, filename, filename, {"copies": "1"})
示例#20
0
 def send_print(self, filename):
     try:
         conn = cups.Connection()
         printers = conn.getPrinters()
         # default_printer = printers.keys()[self.selected_printer]#defaults to the first printer installed
         default_printer = conn.getDefault()
         cups.setUser("pi")
         conn.printFile(default_printer, filename, '',
                        {'fit-to-page': 'True'})
     except:
         pass
示例#21
0
def print_image(path):
	connection = cups.Connection()
	printers = connection.getPrinters()
	printer = printers.keys()[0]
	cups.setUser('pi')

	img_to_print = os.path.join(IMAGES_PATH, IMAGE_NAME_TEMPLATE.format(format(get_next_image_number(IMAGES_PATH)-1, '04d')))

	print "Sending "+img_to_print+" to printer ..."

	connection.printFile(printer, img_to_print, "PhotoboxImage", {})
示例#22
0
def print_image(path):
	connection = cups.Connection()
	printers = connection.getPrinters()
	printer = printers.keys()[0]
	cups.setUser('pi')

	img_to_print = os.path.join(PRINT_PATH, IMAGE_NAME_TEMPLATE.format(format(get_next_image_number(IMAGES_PATH)-1, '04d')))

	print "Sending "+img_to_print+" to printer ..."

	connection.printFile(printer, img_to_print, "PhotoboxImage", {})
示例#23
0
def print_picture(environment, filepath):
    """Print the filepath picture"""
    lg.info("Seems like printing has been asked")
    #Todo handle here
    if ENABLE_PRINTING and environment["printer_enabled"]:
        if os.path.isfile(filepath):
            # Open a connection to cups
            conn = cups.Connection()
            # get a list of printers
            printers = conn.getPrinters()
            # select printer 0
            printer_name = environment["printer_selected"]
            my_printer = printers.get(environment["printer_selected"], None)
            if my_printer is None:
                lg.critical("The printer " + str(printer_name) +
                            " does not exists in list:" + str(printers.keys()))
                update_display(environment, "", "!! Merci pour vos photos !!",
                               "", "", False)
                time.sleep(1)
                update_display(environment, "",
                               "Nous vous enverrons vos photos...", "", "",
                               False)
                time.sleep(1)
            cups.setUser('pi')
            # print the buffer file
            printqueuelength = len(conn.getJobs())
            if printqueuelength > 1:
                play_a_sound(environment["buzz_sound"])
                #show_image(environment, filepath)
                #time.sleep(3)
                conn.enablePrinter(printer_name)
                update_display(environment, "", "!! Merci pour vos photos !!",
                               "", "", False)
                time.sleep(1)
                update_display(environment, "",
                               "Nous vous enverrons vos photos...", "", "",
                               False)
                time.sleep(1)
            else:
                update_display(environment, "", "Impression en cours...", "",
                               "", False)
                tmp_filepath = creation_montage_to_print_a_format(
                    filepath, environment["printer_tmp_filepath"])
                conn.printFile(printer_name, tmp_filepath, "PhotoBoothBouin",
                               environment["printer_options"])
                time.sleep(20)
    else:
        play_a_sound(environment["buzz_sound"])
        update_display(environment, "", "!! Merci pour vos photos !!", "", "",
                       False)
        time.sleep(1)
        update_display(environment, "", "Nous vous enverrons vos photos...",
                       "", "", False)
        time.sleep(1)
示例#24
0
    def __init__(self, host=None, user=None, port=None, verbose=False,
        directory=None, prefix='AirPrint-', adminurl=False):
        self.host = host
        self.user = user
        self.port = port
        self.verbose = verbose
        self.directory = directory
        self.prefix = prefix
        self.adminurl = adminurl

        if self.user:
            cups.setUser(self.user)
示例#25
0
    def config_printer(self, config):
        try:
            conn = cups.Connection()
            printers = conn.getPrinters()
            logger.debug('printers: %s' % printers)
            default_printer = printers.keys()[config['printer_key']]
            cups.setUser(config['user'])
        except (IPPError, HTTPError) as e:
            raise PimatonPrintExceptions('Couldnt connect to cups')

        self.printer = default_printer
        self.conn = conn
示例#26
0
 def __init__(self, host=None, user=None, port=None, verbose=False,
     directory=None, prefix='AirPrint-', adminurl=False):
     self.host = host
     self.user = user
     self.port = port
     self.verbose = verbose
     self.directory = directory
     self.prefix = prefix
     self.adminurl = adminurl
     
     if self.user:
         cups.setUser(self.user)
示例#27
0
 def send(self, file, user, **kwargs):
     try:
         cups.setUser(user)
         conn = cups.Connection()
         job_name = str(uuid.uuid4())
         content = file.file.read()
         with tempfile.NamedTemporaryFile(prefix="tmp_print") as f:
             f.write(content)
             f.flush()
             id = conn.printFile('MFP', f.name, job_name, {})
         msg = "success, job id: {}, job name: {}".format(id, job_name)
     except cups.IPPError as (status, description):
         msg = "IPP status is {}, meaning: {}".format(status, description)
示例#28
0
def printFile(selected_frame_num, num_times):
    conn = cups.Connection()
    printers = conn.getPrinters()
    printer_name = printers.keys()[0]
    cups.setUser('pi')
    
    if selected_frame_num < 8:
        selected_frame_pic = "tmp/frame_%i.jpg" % (selected_frame_num)
    else:
        selected_frame_pic = "nice_image.jpg"
    
    for i in xrange(0, num_times):
        conn.printFile(printer_name, os.path.abspath(selected_frame_pic), "Photo_Booth_Print", { "media": "Custom.4x6in" })
示例#29
0
def printFile(selected_frame_num, num_times):
    conn = cups.Connection()
    printers = conn.getPrinters()
    printer_name = printers.keys()[0]
    cups.setUser('pi')

    if selected_frame_num < 8:
        selected_frame_pic = "tmp/frame_%i.jpg" % (selected_frame_num)
    else:
        selected_frame_pic = "nice_image.jpg"

    for i in xrange(0, num_times):
        conn.printFile(printer_name, os.path.abspath(selected_frame_pic),
                       "Photo_Booth_Print", {"media": "Custom.4x6in"})
示例#30
0
    def printit(self, username, printjob, printer):
        """Print a given document on the given printer

		requests.options = {}
		'username' -- owner of the print job
		'printjob' -- relative filename of the print job
		'printer' -- the printer to use (<hostname>://<printer>)

		return: <PDF document>
		"""

        path = self._get_path(username, printjob)

        try:
            spoolhost, printer = printer.split('://', 1)
        except ValueError:
            raise UMC_Error(_('Invalid printer URI'))

        if not os.path.exists(path):
            raise UMC_Error(
                _('File %r could not be printed as it does not exists (anymore).'
                  ) % (printjob, ))

        MODULE.process('Printing: %s' % path)
        self.pw_callback_bad_password = False
        try:
            cups.setUser(self.username)
            cups.setEncryption(cups.HTTP_ENCRYPT_ALWAYS)
            cups.setPasswordCB(self.pw_callback)
            conn = cups.Connection(spoolhost)
            conn.printFile(printer, path, Printjob.filename2label(printjob),
                           {})
        except RuntimeError:
            raise UMC_Error(
                _('Failed to connect to print server %(printserver)s.') %
                {'printserver': spoolhost})
        except cups.IPPError as (errno, description):
            IPP_AUTHENTICATION_CANCELED = 4096
            description = {
                cups.IPP_NOT_AUTHORIZED: _('No permission to print'),
                IPP_AUTHENTICATION_CANCELED: _('Wrong password'),
            }.get(errno, description)
            raise UMC_Error(
                _('Failed to print on %(printer)s: %(stderr)s (error %(errno)d).'
                  ) % {
                      'printer': printer,
                      'stderr': description,
                      'errno': errno
                  })
示例#31
0
def print_file(filename, tmp_file, printer, uni, options):
	cups.setUser(uni)
	conn = cups.Connection()
	try:
		conv_file = convert_file(tmp_file)
		if conv_file:
			conn.printFile(printer, conv_file, filename, options)
			sys.stderr.write('File '+conv_file+' printed successfully\n')
			sys.stderr.flush()
		else:
			sys.stderr.write("Could not convert "+tmp_file+" successfully\n")
			sys.stderr.flush()
	except cups.IPPError:
		sys.stderr.write('Printing '+tmp_file+' unsuccessful\n')
		sys.stderr.flush()
示例#32
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))
示例#33
0
def printFrame():
    cam = Camera()
    json = request.get_json()

    print(json)

    if json is None:
        return "invalid", 400
    else:
        firstname = json["firstname"]
        lastname = json["lastname"]

        if firstname is None or lastname is None:
            # TODO error page
            return "invalid", 400

    # save file to ms since epoch
    now = datetime.datetime.now()
    msSinceEpoch = str(now.timestamp() * 1000000)
    filename = msSinceEpoch + '.jpg'
    path = BASE_PATH + filename

    #capture current frame #maybe better if frame comes from web whatever
    with open(path, 'wb') as f:
        f.write(cam.get_frame())

    #write into db
    db.insert({
        'firstname': firstname,
        'lastname': lastname,
        'date': now.strftime("%Y-%m-%d %H:%M:%S"),
        'filename': filename
    })

    # Set up CUPS
    conn = cups.Connection()

    # code only for testing without really printing to not waste
    # return 'success'

    cups.setUser('pi')
    # Send the picture to the printer
    # give custom media size in pin size with into it
    # CHANGE CM VALUES HERE IF BIGGER OR SMALLER PRINT SIZE
    print_id = conn.printFile(PRINTER_NAME, path, "Projekt Webcam Print",
                              {"media": "Custom.8.5x8.5cm"})

    return "success"
 def __init__(self, host=None, user=None, port=None, verbose=False,
     directory=None, prefix='AirPrint-', adminurl=False, usecups=True, 
     useavahi=False, dnsdomain=None):
     self.host = host
     self.user = user
     self.port = port
     self.verbose = verbose
     self.directory = directory
     self.prefix = prefix
     self.adminurl = adminurl
     self.usecups = usecups and cups
     self.useavahi = useavahi and avahisearch
     self.dnsdomain = dnsdomain
     
     if self.user:
         cups.setUser(self.user)
示例#35
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
示例#36
0
def printPhotos(obj):
    logging.info('Function printPhotos was called.')
    global printerBusy
    
    if printerBusy == False:
        conn = cups.Connection()
        cups.setUser(cupsUser)
        conn.printFile(printerName, photoOne, "RasPi_Booth", {'fit-to-page':'True'})
        conn.printFile(printerName, photoTwo, "RasPi_Booth", {'fit-to-page':'True'})
        conn.printFile(printerName, photoThree, "RasPi_Booth", {'fit-to-page':'True'})
        global printerTime
        global printerTimeout
        printerTime = 0
        printerTimeout = 180
        printerBusy = True
        logging.info('Function printPhotos completed.')
示例#37
0
def print_file(filename, tmp_file, printer, uni, options):
    cups.setUser(uni)
    conn = cups.Connection()
    try:
        conv_file = convert_file(tmp_file)
        if conv_file:
            conn.printFile(printer, conv_file, filename, options)
            sys.stderr.write('File ' + conv_file + ' printed successfully\n')
            sys.stderr.flush()
        else:
            sys.stderr.write("Could not convert " + tmp_file +
                             " successfully\n")
            sys.stderr.flush()
    except cups.IPPError:
        sys.stderr.write('Printing ' + tmp_file + ' unsuccessful\n')
        sys.stderr.flush()
示例#38
0
def print_picture():
    global names
    global person
    global lastPick
    global first_pick
    conn = cups.Connection()
    printers = conn.getPrinters()
    printer_name = list(printers.keys())[0]
    cups.setUser('pi')
 
    latest_print = Image.new('RGBA', (683, 384))
    latest_print.paste(Image.open("/home/pi/SSanta/"+str(person)+".jpg").resize((683, 384)), ( 0, 0, 683, 384))
   
    output = "/home/pi/SSanta/"+str(person)+".jpg"
 
    print_id = conn.printFile(printer_name, output, "Photo Booth", {})
    while conn.getJobs().get(print_id, None):
        sleep(1)
示例#39
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')
示例#40
0
    def cleanup (self):
        if self.sub_id != -1:
            user = cups.getUser ()
            try:
                cups.setUser (self.user)
                c = cups.Connection (host=self.host,
                                     port=self.port,
                                     encryption=self.encryption)
                c.cancelSubscription (self.sub_id)
                debugprint ("Canceled subscription %d" % self.sub_id)
            except:
                pass
            cups.setUser (user)

        if self.bus != None:
            self.bus.remove_signal_receiver (self.handle_dbus_signal,
                                             path=self.DBUS_PATH,
                                             dbus_interface=self.DBUS_IFACE)

        self.watcher.monitor_exited (self)
示例#41
0
文件: booth_tk.py 项目: cayek/boothy
 def print_pic(self):
     self.logger.info("PRINT")
     self.current_img = ImageTk.PhotoImage(self.imgs["print"])
     self.canvas.itemconfig(self.imagesprite,
                            image=self.current_img)
     self.root.update()
     self.logger.info("show print in progress")
     # to be sure that the montage is over :D
     self.to_print_p.wait()
     # send print
     conn = cups.Connection()
     printers = conn.getPrinters()
     default_printer = "Canon_SELPHY_CP1300"
     if (default_printer in printers.keys()):
         cups.setUser('pi')
         conn.printFile(default_printer, self.toprint_path,
                        "boothy", {'fit-to-page':'True'})
     else:
         self.logger.info("Printer not found ! ")
     time.sleep(5)
示例#42
0
def printFile(selected_frame_num, num_times):
    print(" ** Printing!")
    try:
        conn = cups.Connection()
        printers = conn.getPrinters()
        printer_name = list(printers.keys())[0]
        cups.setUser('pi')
        
        if selected_frame_num < 8:
            selected_frame_pic = "tmp/frame_%i.jpg" % (selected_frame_num)
        else:
            selected_frame_pic = "nice_image.jpg"
        
        print(" ** Image is %s | fnum is %i | num_times is %i" % (selected_frame_pic, selected_frame_num, num_times))
        
        for i in range(0, num_times):
            print(" ** Printing iteration!")
            conn.printFile(printer_name, os.path.abspath(selected_frame_pic), "Photo_Booth_Print", { "media": "Custom.4x6in" })
    except:
        print(" ** Printing FAILED!")
        traceback.print_exc()
示例#43
0
def printPic(fileName):
    #fileName = "bl.jpg"
    #return
        
    addPreviewOverlay(100,200,55,"Printing...")
    conn = cups.Connection()
    printers = conn.getPrinters()
    print "PRINT!"
    print printers
    default_printer = printers.keys()[0]
    print "Default P:"
    print default_printer
    cups.setUser('pi')
    conn.printFile (default_printer, "photos//" + fileName, "boothy", {}) #, {'fit-to-page':'True'})
    logging.info("Print job successfully created.");
    counter=50
    pstatus="-"
    while True:
        time.sleep(1)
        
        if counter > 0:
                counter=counter-1
        else:
            return

        if len(conn.getJobs()) != 0:
            sta=conn.getJobAttributes(next(iter(conn.getJobs())))["job-state"]
            if sta == 5: #IPP_JOB_PROCESSING
                pstatus="Processing... (5)"
                if counter == 0:
                    counter=counter+5
                
            elif sta == 9: #IPP_JOB_COMPLETED
                pstatus="Completed... (9)"
            
            elif sta == 4: #IPP_JOB_HELD no paper
                pstatus="No paper!"
                counter=counter+1
        
        addPreviewOverlayP("Printing... [" + str(counter) + "]", pstatus)
示例#44
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))
示例#45
0
    def fetch_jobs (self, refresh_all):
        if not self.process_pending_events:
            # Skip this call.  We'll get called again soon.
            return True

        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)
        except RuntimeError:
            self.watcher.cups_connection_error (self)
            self.fetch_jobs_timer = None
            cups.setUser (user)
            return False

        limit = 1
        try:
            fetched = c.getJobs (which_jobs=self.which_jobs,
                                 my_jobs=self.my_jobs,
                                 first_job_id=self.fetch_first_job_id,
                                 limit=limit)
        except cups.IPPError, (e, m):
            self.watcher.cups_ipp_error (self, e, m)
            self.fetch_jobs_timer = None
            cups.setUser (user)
            return False
示例#46
0
文件: test.py 项目: Distrotech/pycups
def test_cups_module ():
	cups.setUser ("root")
	cups.setPasswordCB (callback)
	conn = cups.Connection ()
	printers = list(conn.getPrinters ().keys ())

	if 0:
		print ("Getting cupsd.conf")
		file ("cupsd.conf", "w")
		conn.getFile ("/admin/conf/cupsd.conf", "cupsd.conf")
		print ("Putting cupsd.conf")
		conn.putFile ("/admin/conf/cupsd.conf", "cupsd.conf")

	print ("Getting PPD for %s" % printers[len (printers) - 1])
	f = conn.getPPD (printers[len (printers) - 1])
	ppd = cups.PPD (f)
	ppd.markDefaults ()
	print (ppd.conflicts ())
	groups = ppd.optionGroups
	for group in groups:
		for opt in group.options:
			print (list (map (lambda x: x["text"], opt.choices)))
示例#47
0
 def print_pic(self, image_name):
     # Dateinahmen bestimmen:
     print 'printing:',self.__library.get_image_path(image_name)
     try:
         conn = cups.Connection()
         printers = conn.getPrinters()
         printer_name = printers.keys()[1] # Drucker auswaehlen
         cups.setUser('pi') #Benutzer einstellen
         # Drucker Queue lesen
         PrinterQueue = conn.getJobs(which_jobs='not-completed')
         # Drucken (Drucker, Datei, PrintJob Name, Optionen)
         if len(PrinterQueue)==0:  #länge der Queue über 0 kein drucken
             conn.printFile(printer_name,
                            self.__library.get_image_path(image_name),
                            "Photobooth",{})
             self.printing_image.emit(image_name)
         elif len(PrinterQueue)>0:
             print 'Printer busy'
         # Fehler abfangen und ausgeben (z.B. Papierstau oder kein Papier
     except cups.IPPError as (status, description):
         print 'IPP statis is %d' % status
         print 'Meaning:', description
示例#48
0
def test_cups_module():
    cups.setUser("root")
    cups.setPasswordCB(callback)
    conn = cups.Connection()
    printers = list(conn.getPrinters().keys())

    if 0:
        print("Getting cupsd.conf")
        file("cupsd.conf", "w")
        conn.getFile("/admin/conf/cupsd.conf", "cupsd.conf")
        print("Putting cupsd.conf")
        conn.putFile("/admin/conf/cupsd.conf", "cupsd.conf")

    print("Getting PPD for %s" % printers[len(printers) - 1])
    f = conn.getPPD(printers[len(printers) - 1])
    ppd = cups.PPD(f)
    ppd.markDefaults()
    print(ppd.conflicts())
    groups = ppd.optionGroups
    for group in groups:
        for opt in group.options:
            print(list(map(lambda x: x["text"], opt.choices)))
示例#49
0
    def run (self):
        if self.host == None:
            self.host = cups.getServer ()
        if self.port == None:
            self.port = cups.getPort ()
        if self._encryption == None:
            self._encryption = cups.getEncryption ()

        if self.user:
            cups.setUser (self.user)
        else:
            self.user = cups.getUser ()

        cups.setPasswordCB2 (self._auth)

        try:
            conn = cups.Connection (host=self.host,
                                    port=self.port,
                                    encryption=self._encryption)
            self._reply (None)
        except RuntimeError, e:
            conn = None
            self._error (e)
示例#50
0
def cups_print(username, printer_name):
    conn = cups.Connection()
    filename = eg.fileopenbox("Select the file to be printed", "File Selector")
    title = "Filename : " + filename
    msg = "empty - print all pages, '-' for range, ',' separate ranges)"

    field_names = ["Pages to be printed"]
    field_values = []  # we start with blanks for the values
    field_values = eg.multenterbox(msg, title, field_names, field_values)

    job_id = 0
    if filename:
        cups.setUser(username)
        options = {'sides': 'two-sided-long-edge'}
        val = str(field_values[0]).replace(" ", "").strip(',')
        if bool(val):
            options['page-ranges'] = val

        try:
            conn.setPrinterUsersAllowed(printer_name, [username])
            job_id = conn.printFile(printer_name, filename, filename, options)
            conn.setPrinterUsersAllowed(printer_name, [''])
        except cups.IPPError as (status, description):
            eg.msgbox(title='IPP status is %d' % status, msg='Meaning: %s' % description)
示例#51
0
    def refresh(self, which_jobs=None, refresh_all=True):
        debugprint ("refresh")

        if which_jobs != None:
            self.which_jobs = which_jobs

        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)
        except RuntimeError:
            self.watcher.cups_connection_error (self)
            cups.setUser (user)
            return

        if self.sub_id != -1:
            try:
                c.cancelSubscription (self.sub_id)
            except cups.IPPError, (e, m):
                self.watcher.cups_ipp_error (self, e, m)

            debugprint ("Canceled subscription %d" % self.sub_id)
示例#52
0
    def fetch_jobs (self, refresh_all):
        if not self.process_pending_events:
            # Skip this call.  We'll get called again soon.
            return True

        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)
        except RuntimeError:
            self.emit ('cups-connection-error')
            self.fetch_jobs_timer = None
            cups.setUser (user)
            return False

        limit = 1
        r = ["job-id",
             "job-printer-uri",
             "job-state",
             "job-originating-user-name",
             "job-k-octets",
             "job-name",
             "time-at-creation"]
        try:
            try:
                fetched = c.getJobs (which_jobs=self.which_jobs,
                                     my_jobs=self.my_jobs,
                                     first_job_id=self.fetch_first_job_id,
                                     limit=limit,
                                     requested_attributes=r)
            except TypeError:
                # requested_attributes requires pycups 1.9.50
                fetched = c.getJobs (which_jobs=self.which_jobs,
                                     my_jobs=self.my_jobs,
                                     first_job_id=self.fetch_first_job_id,
                                     limit=limit)
        except cups.IPPError, (e, m):
            self.emit ('cups-ipp-error', e, m)
            self.fetch_jobs_timer = None
            cups.setUser (user)
            return False
    def run(self):
        if self.host == None:
            self.host = cups.getServer()
        if self.port == None:
            self.port = cups.getPort()
        if self._encryption == None:
            self._encryption = cups.getEncryption()

        if self.user:
            cups.setUser(self.user)
        else:
            self.user = cups.getUser()

        cups.setPasswordCB2(self._auth)

        try:
            conn = cups.Connection(host=self.host, port=self.port, encryption=self._encryption)
            self._reply(None)
        except RuntimeError as e:
            conn = None
            self._error(e)

        while True:
            # Wait to find out what operation to try.
            debugprint("Awaiting further instructions")
            self.idle = self._queue.empty()
            item = self._queue.get()
            debugprint("Next task: %s" % repr(item))
            if item == None:
                # Our signal to quit.
                self._queue.task_done()
                break
            elif self._destroyed:
                # Just mark all tasks done
                self._queue.task_done()
                continue

            self.idle = False
            (fn, args, kwds, rh, eh, ah) = item
            if rh != False:
                self._reply_handler = rh
            if eh != False:
                self._error_handler = eh
            if ah != False:
                self._auth_handler = ah

            if fn == True:
                # Our signal to change user and reconnect.
                self.user = args[0]
                cups.setUser(self.user)
                debugprint("Set user=%s; reconnecting..." % self.user)
                cups.setPasswordCB2(self._auth)

                try:
                    conn = cups.Connection(host=self.host, port=self.port, encryption=self._encryption)
                    debugprint("...reconnected")

                    self._queue.task_done()
                    self._reply(None)
                except RuntimeError as e:
                    debugprint("...failed")
                    self._queue.task_done()
                    self._error(e)

                continue

            # Normal IPP operation.  Try to perform it.
            try:
                debugprint("Call %s" % fn)
                result = fn(conn, *args, **kwds)
                if fn == cups.Connection.adminGetServerSettings.__call__:
                    # Special case for a rubbish bit of API.
                    if result == {}:
                        # Authentication failed, but we aren't told that.
                        raise cups.IPPError(cups.IPP_NOT_AUTHORIZED, "")

                debugprint("...success")
                self._reply(result)
            except Exception as e:
                debugprint("...failure (%s)" % repr(e))
                self._error(e)

            self._queue.task_done()

        debugprint("Thread exiting")
        del self._conn  # already destroyed
        del self._reply_handler
        del self._error_handler
        del self._auth_handler
        del self._queue
        del self._auth_queue
        del conn

        cups.setPasswordCB2(None)
示例#54
0
    def fetch_jobs (self, refresh_all):
        if not self.process_pending_events:
            # Skip this call.  We'll get called again soon.
            return True

        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)
        except RuntimeError:
            self.emit ('cups-connection-error')
            self.fetch_jobs_timer = None
            cups.setUser (user)
            return False

        limit = 1
        r = ["job-id",
             "job-printer-uri",
             "job-state",
             "job-originating-user-name",
             "job-k-octets",
             "job-name",
             "time-at-creation"]
        try:
            fetched = c.getJobs (which_jobs=self.which_jobs,
                                 my_jobs=self.my_jobs,
                                 first_job_id=self.fetch_first_job_id,
                                 limit=limit,
                                 requested_attributes=r)
        except cups.IPPError as e:
            (e, m) = e.args
            self.emit ('cups-ipp-error', e, m)
            self.fetch_jobs_timer = None
            cups.setUser (user)
            return False

        cups.setUser (user)
        got = len (fetched)
        debugprint ("Got %s jobs, asked for %s" % (got, limit))

        jobs = self.jobs.copy ()
        jobids = list(fetched.keys ())
        jobids.sort ()
        if got > 0:
            last_jobid = jobids[got - 1]
            if last_jobid < self.fetch_first_job_id:
                last_jobid = self.fetch_first_job_id + limit - 1
                debugprint ("Unexpected job IDs returned: %s" % repr (jobids))
                debugprint ("That's not what we asked for!")
        else:
            last_jobid = self.fetch_first_job_id + limit - 1
        for jobid in range (self.fetch_first_job_id, last_jobid + 1):
            try:
                job = fetched[jobid]
                if self.specific_dests is not None:
                    uri = job.get('job-printer-uri', '/')
                    i = uri.rfind ('/')
                    printer = uri[i + 1:]
                    if printer not in self.specific_dests:
                        raise KeyError

                if jobid in jobs:
                    n = 'job-event'
                else:
                    n = 'job-added'

                jobs[jobid] = job
                self.emit (n, jobid, '', {}, job.copy ())
            except KeyError:
                # No job by that ID.
                if jobid in jobs:
                    del jobs[jobid]
                    self.emit ('job-removed', jobid, '', {})

        jobids = list(jobs.keys ())
        jobids.sort ()
        if got < limit:
            trim = False
            for i in range (len (jobids)):
                jobid = jobids[i]
                if not trim and jobid > last_jobid:
                    trim = True
            
                if trim:
                    del jobs[jobid]
                    self.emit ('job-removed', jobid, '', {})

        self.update_jobs (jobs)
        self.jobs = jobs

        if got < limit:
            # That's all.  Don't run this timer again.
            self.fetch_jobs_timer = None
            return False

        # Remember where we got up to and run this timer again.
        next = jobid + 1

        while not refresh_all and next in self.jobs:
            next += 1

        self.fetch_first_job_id = next
        return True
示例#55
0
    def refresh(self, which_jobs=None, refresh_all=True):
        debugprint ("refresh")

        self.emit ('refresh')
        if which_jobs is not None:
            self.which_jobs = which_jobs

        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)
        except RuntimeError:
            GLib.idle_add (self.emit, 'cups-connection-error')
            cups.setUser (user)
            return

        if self.sub_id != -1:
            try:
                c.cancelSubscription (self.sub_id)
            except cups.IPPError as e:
                (e, m) = e.args
                GLib.idle_add (lambda e, m: self.emit ('cups-ipp-error', e, m),
                               e, m)

            if self.update_timer:
                GLib.source_remove (self.update_timer)

            self.update_timer = None
            debugprint ("Canceled subscription %d" % self.sub_id)

        try:
            del self.sub_seq
        except AttributeError:
            pass

        events = ["printer-added",
                  "printer-modified",
                  "printer-deleted",
                  "printer-state-changed"]
        if self.monitor_jobs:
            events.extend (["job-created",
                            "job-completed",
                            "job-stopped",
                            "job-state-changed",
                            "job-progress"])

        try:
            self.sub_id = c.createSubscription ("/", events=events)
            debugprint ("Created subscription %d, events=%s" % (self.sub_id,
                                                                repr (events)))
        except cups.IPPError as e:
            (e, m) = e.args
            GLib.idle_add (lambda e, m: self.emit ('cups-ipp-error', e, m),
                           e, m)

        cups.setUser (user)

        if self.sub_id != -1:
            if self.update_timer:
                GLib.source_remove (self.update_timer)

            self.update_timer = GLib.timeout_add_seconds (
                MIN_REFRESH_INTERVAL,
                self.get_notifications)
            debugprint ("Next notifications fetch in %ds" %
                        MIN_REFRESH_INTERVAL)

        if self.monitor_jobs:
            jobs = self.jobs.copy ()
            if self.which_jobs not in ['all', 'completed']:
                # Filter out completed jobs.
                filtered = {}
                for jobid, job in jobs.items ():
                    if job.get ('job-state',
                                cups.IPP_JOB_CANCELED) < cups.IPP_JOB_CANCELED:
                        filtered[jobid] = job
                jobs = filtered

            self.fetch_first_job_id = 1
            if self.fetch_jobs_timer:
                GLib.source_remove (self.fetch_jobs_timer)
            self.fetch_jobs_timer = GLib.timeout_add (5, self.fetch_jobs,
                                                      refresh_all)
        else:
            jobs = {}

        try:
            r = collect_printer_state_reasons (c, self.ppdcache)
            self.printer_state_reasons = r
            dests = c.getPrinters ()
            self.printers = set(dests.keys ())
        except cups.IPPError as e:
            (e, m) = e.args
            GLib.idle_add (lambda e, m: self.emit ('cups-ipp-error', e, m),
                           e, m)
            return
        except RuntimeError:
            GLib.idle_add (self.emit, 'cups-connection-error')
            return

        if self.specific_dests is not None:
            for jobid in jobs.keys ():
                uri = jobs[jobid].get('job-printer-uri', '/')
                i = uri.rfind ('/')
                printer = uri[i + 1:]
                if printer not in self.specific_dests:
                    del jobs[jobid]

        self.set_process_pending (False)
        for printer in self.printers:
            GLib.idle_add (lambda x: self.emit ('printer-added', x), printer)
        for jobid, job in jobs.items ():
            GLib.idle_add (lambda jobid, job:
                                  self.emit ('job-added', jobid, '', {}, job),
                           jobid, job)
        self.update_jobs (jobs)
        self.jobs = jobs
        self.set_process_pending (True)
        return False
示例#56
0
    def get_notifications(self):
        if self.update_timer:
            GLib.source_remove (self.update_timer)

        self.update_timer = None
        if not self.process_pending_events:
            # Defer the timer callback.
            self.update_timer = GLib.timeout_add (200,
                                                     self.get_notifications)
            debugprint ("Deferred get_notifications by 200ms")
            return False

        debugprint ("get_notifications")
        user = cups.getUser ()
        try:
            cups.setUser (self.user)
            c = cups.Connection (host=self.host,
                                 port=self.port,
                                 encryption=self.encryption)

            try:
                try:
                    notifications = c.getNotifications ([self.sub_id],
                                                        [self.sub_seq + 1])
                except AttributeError:
                    notifications = c.getNotifications ([self.sub_id])
            except cups.IPPError as e:
                (e, m) = e.args
                cups.setUser (user)
                if e == cups.IPP_NOT_FOUND:
                    # Subscription lease has expired.
                    self.sub_id = -1
                    debugprint ("Subscription not found, will refresh")
                    self.refresh ()
                    return False

                self.emit ('cups-ipp-error', e, m)
                if e == cups.IPP_FORBIDDEN:
                    return False

                debugprint ("getNotifications failed with %d (%s)" % (e, m))
                return True
        except RuntimeError:
            cups.setUser (user)
            debugprint ("cups-connection-error, will retry")
            self.cups_connection_in_error = True
            self.emit ('cups-connection-error')
            return True

        if self.cups_connection_in_error:
            self.cups_connection_in_error = False
            debugprint ("cups-connection-recovered")
            self.emit ('cups-connection-recovered')

        cups.setUser (user)
        jobs = self.jobs.copy ()
        for event in notifications['events']:
            seq = event['notify-sequence-number']
            self.sub_seq = seq
            nse = event['notify-subscribed-event']
            debugprint ("%d %s %s" % (seq, nse, event['notify-text']))
            if get_debugging ():
                debugprint (pprint.pformat (event))
            if nse.startswith ('printer-'):
                # Printer events
                name = event['printer-name']
                if nse == 'printer-added' and name not in self.printers:
                    self.printers.add (name)
                    self.emit ('printer-added', name)

                elif nse == 'printer-deleted' and name in self.printers:
                    self.printers.remove (name)
                    items = list(self.reasons_seen.keys ())
                    for tuple in items:
                        if tuple[1] == name:
                            reason = self.reasons_seen[tuple]
                            del self.reasons_seen[tuple]
                            self.emit ('state-reason-removed', reason)
                            
                    if name in self.printer_state_reasons:
                        del self.printer_state_reasons[name]

                    self.emit ('printer-removed', name)
                elif name in self.printers:
                    printer_state_reasons = event['printer-state-reasons']
                    reasons = []
                    for reason in printer_state_reasons:
                        if reason == "none":
                            break
                        if state_reason_is_harmless (reason):
                            continue
                        reasons.append (StateReason (name, reason,
                                                     self.ppdcache))
                    self.printer_state_reasons[name] = reasons

                    self.emit ('printer-event', name, nse, event)
                continue

            # Job events
            if not nse.startswith ("job-"):
                # Some versions of CUPS give empty
                # notify-subscribed-event attributes (STR #3608).
                debugprint ("Unhandled nse %s" % repr (nse))
                continue

            jobid = event['notify-job-id']
            if (nse == 'job-created' or
                (nse == 'job-state-changed' and
                 jobid not in jobs and
                 event['job-state'] == cups.IPP_JOB_PROCESSING)):
                if (self.specific_dests is not None and
                    event['printer-name'] not in self.specific_dests):
                    continue

                try:
                    attrs = c.getJobAttributes (jobid)
                    if (self.my_jobs and
                        attrs['job-originating-user-name'] != cups.getUser ()):
                        continue

                    jobs[jobid] = attrs
                except KeyError:
                    jobs[jobid] = {'job-k-octets': 0}
                except cups.IPPError as e:
                    (e, m) = e.args
                    self.emit ('cups-ipp-error', e, m)
                    jobs[jobid] = {'job-k-octets': 0}

                self.emit ('job-added', jobid, nse, event, jobs[jobid].copy ())
            elif (nse == 'job-completed' or
                  (nse == 'job-state-changed' and
                   event['job-state'] == cups.IPP_JOB_COMPLETED)):
                if not (self.which_jobs in ['completed', 'all']):
                    try:
                        del jobs[jobid]
                        self.emit ('job-removed', jobid, nse, event)
                    except KeyError:
                        pass
                    continue

            try:
                job = jobs[jobid]
            except KeyError:
                continue

            if (self.specific_dests is not None and
                event['printer-name'] not in self.specific_dests):
                del jobs[jobid]
                self.emit ('job-removed', jobid, nse, event)
                continue

            for attribute in ['job-state',
                              'job-name']:
                job[attribute] = event[attribute]
            if 'notify-printer-uri' in event:
                job['job-printer-uri'] = event['notify-printer-uri']

            self.emit ('job-event', jobid, nse, event, job.copy ())

        self.set_process_pending (False)
        self.update_jobs (jobs)
        self.jobs = jobs
        self.set_process_pending (True)

        # Update again when we're told to.  If we're getting CUPS
        # D-Bus signals, however, rely on those instead.
        if not self.received_any_dbus_signals:
            interval = notifications['notify-get-interval']
            t = GLib.timeout_add_seconds (interval,
                                          self.get_notifications)
            debugprint ("Next notifications fetch in %ds" % interval)
            self.update_timer = t

        return False
    def _perform_authentication (self):
        self._passes += 1

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

        debugprint ("Authentication pass: %d" % self._passes)
        if self._passes == 1:
            # Haven't yet tried the operation.  Set the password
            # callback and return > 0 so we try it for the first time.
            self._has_failed = False
            self._forbidden = False
            self._auth_called = False
            self._cancel = False
            self._cannot_auth = False
            self._dialog_shown = False
            cups.setPasswordCB (self._password_callback)
            debugprint ("Authentication: password callback set")
            return 1

        debugprint ("Forbidden: %s" % self._forbidden)
        if not self._has_failed:
            # Tried the operation and it worked.  Return 0 to signal to
            # break out of the loop.
            debugprint ("Authentication: Operation successful")
            return 0

        # Reset failure flag.
        self._has_failed = False

        if self._passes >= 2:
            # Tried the operation without a password and it failed.
            if (self._try_as_root and
                self._user != 'root' and
                (self._server[0] == '/' or self._forbidden)):
                # This is a UNIX domain socket connection so we should
                # not have needed a password (or it is not a UDS but
                # we got an HTTP_FORBIDDEN response), and so the
                # operation must not be something that the current
                # user is authorised to do.  They need to try as root,
                # and supply the password.  However, to get the right
                # prompt, we need to try as root but with no password
                # first.
                debugprint ("Authentication: Try as root")
                self._use_user = '******'
                self._auth_called = False
                try:
                    self._connect (allow_pk=False)
                except RuntimeError:
                    raise cups.IPPError (cups.IPP_SERVICE_UNAVAILABLE,
                                         'server-error-service-unavailable')

                return 1

        if not self._prompt_allowed:
            debugprint ("Authentication: prompting not allowed")
            self._cancel = True
            return 1

        if not self._auth_called:
            # We aren't even getting a chance to supply credentials.
            debugprint ("Authentication: giving up")
            self._cancel = True
            self._cannot_auth = True
            return 1

        # Reset the flag indicating whether we were given an auth callback.
        self._auth_called = False

        # If we're previously prompted, explain why we're prompting again.
        if self._dialog_shown:
            if self._lock:
                self._gui_event.clear ()
                GLib.timeout_add (1, self._show_not_authorized_dialog)
                self._gui_event.wait ()
            else:
                self._show_not_authorized_dialog ()

        if self._lock:
            self._gui_event.clear ()
            GLib.timeout_add (1, self._perform_authentication_with_dialog)
            self._gui_event.wait ()
        else:
            self._perform_authentication_with_dialog ()

        if self._cancel:
            debugprint ("cancelled")
            return -1

        cups.setUser (self._use_user)
        debugprint ("Authentication: Reconnect")
        try:
            self._connect (allow_pk=False)
        except RuntimeError:
            raise cups.IPPError (cups.IPP_SERVICE_UNAVAILABLE,
                                 'server-error-service-unavailable')

        return 1
            (e, m) = e.args
            print("Error getting printer attibutes: %s" % m)
            sys.exit (1)

        SPECIFIC_URI = attrs['device-uri']
        print("URI for queue %s is %s" % (sys.argv[1], SPECIFIC_URI))
else:
    print ("\nIf you have not already done so, you may get more results\n"
           "by temporarily disabling your firewall (or by allowing\n"
           "incoming UDP packets on port 161).\n")

if devices == None:
    if not SPECIFIC_URI:
        print("Examining connected devices")

    cups.setUser ('root')
    c = cups.Connection ()

    try:
        if SPECIFIC_URI:
            scheme = str (SPECIFIC_URI.split (":", 1)[0])
            devices = c.getDevices (include_schemes=[scheme])
        else:
            devices = c.getDevices (exclude_schemes=["dnssd", "hal", "hpfax"])
    except cups.IPPError as e:
        (e, m) = e.args
        if e == cups.IPP_FORBIDDEN:
            print("Run this as root to examine IDs from attached devices.")
            sys.exit (1)
        if e in (cups.IPP_NOT_AUTHORIZED, cups.IPP_AUTHENTICATION_CANCELED):
            print("Not authorized.")
def test (xml_path=None, attached=False, deviceid=None, debug=False):
    import cups
    import locale
    from . import ppds
    from pprint import pprint
    from time import time
    import os.path

    if debug:
        def debugprint (x):
            print (x)

        ppds.set_debugprint_fn (debugprint)
            
    locale.setlocale (locale.LC_ALL, "")
    encoding = locale.getlocale (locale.LC_CTYPE)[1]
    if xml_path == None:
        xml_path = os.path.join (os.path.join (os.path.dirname (__file__),
                                               ".."),
                                 "xml")

    os.environ["CUPSHELPERS_XMLDIR"] = xml_path
    xml_path = os.path.join (xml_path, "preferreddrivers.xml")
    loadstart = time ()
    (xmldrivertypes, xmlpreferenceorder) = PreferredDrivers (xml_path)
    drivertypes = DriverTypes ()
    drivertypes.load (xmldrivertypes)

    preforder = PreferenceOrder ()
    preforder.load (xmlpreferenceorder)
    loadtime = time () - loadstart
    if debug:
        print("Time to load %s: %.3fs" % (xml_path, loadtime))

    c = cups.Connection ()
    try:
        cupsppds = c.getPPDs2 ()
    except AttributeError:
        # getPPDs2 requires pycups >= 1.9.52 
        cupsppds = c.getPPDs ()

    ppdfinder = ppds.PPDs (cupsppds)

    if attached or deviceid:
        if attached:
            cups.setUser ("root")
            devices = c.getDevices ()
        else:
            devid = parseDeviceID (deviceid)
            devices = { "xxx://yyy":
                            { "device-id": deviceid,
                              "device-make-and-model": "%s %s" % (devid["MFG"],
                                                                  devid["MDL"])
                              }
                        }

        for uri, device in devices.items ():
            if uri.find (":") == -1:
                continue

            devid = device.get ("device-id", "")
            if isinstance (devid, list):
                devid = devid[0]

            if not devid:
                continue

            if not uri.startswith ("xxx:"):
                print (uri)

            id_dict = parseDeviceID (devid)
            fit = ppdfinder.getPPDNamesFromDeviceID (id_dict["MFG"],
                                                     id_dict["MDL"],
                                                     id_dict["DES"],
                                                     id_dict["CMD"],
                                                     uri)

            mm = device.get ("device-make-and-model", "")
            orderedtypes = preforder.get_ordered_types (drivertypes,
                                                        mm, id_dict)

            ppds = {}
            for ppdname in fit.keys ():
                ppds[ppdname] = ppdfinder.getInfoFromPPDName (ppdname)

            orderedppds = drivertypes.get_ordered_ppdnames (orderedtypes,
                                                            ppds,
                                                            fit)
            i = 1
            for t, ppd in orderedppds:
                print("%d  %s\n    (%s, %s)" % (i, ppd, t, fit[ppd]))
                i += 1
    else:
        for make in ppdfinder.getMakes ():
            for model in ppdfinder.getModels (make):
                ppdsdict = ppdfinder.getInfoFromModel (make, model)
                mm = make + " " + model
                orderedtypes = preforder.get_ordered_types (drivertypes,
                                                            mm, None)

                fit = {}
                for ppdname in ppdsdict.keys ():
                    fit[ppdname] = DriverType.FIT_CLOSE

                orderedppds = drivertypes.get_ordered_ppdnames (orderedtypes,
                                                                ppdsdict, fit)
                print((mm.encode (encoding) + ":"))
                i = 1
                for t, ppd in orderedppds:
                    print("%d  %s\n    (%s)" % (i, ppd, t))
                    i += 1

                print()