Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
icons	[ DIR ]	drwxr-xr-x
__pycache__	[ DIR ]	drwxr-xr-x
troubleshoot	[ DIR ]	drwxr-xr-x
ui	[ DIR ]	drwxr-xr-x
xml	[ DIR ]	drwxr-xr-x
applet.py	16.83 KB	-rwxr-xr-x
asyncconn.py	9.6 KB	-rw-r--r--
asyncipp.py	26.13 KB	-rw-r--r--
asyncpk1.py	25.86 KB	-rw-r--r--
authconn.py	18.85 KB	-rw-r--r--
check-device-ids.py	11.16 KB	-rwxr-xr-x
config.py	1.19 KB	-rw-r--r--
cupspk.py	27.48 KB	-rw-r--r--
debug.py	1.62 KB	-rw-r--r--
dnssdresolve.py	4.66 KB	-rw-r--r--
errordialogs.py	3.12 KB	-rw-r--r--
firewallsettings.py	9.38 KB	-rw-r--r--
gtkinklevel.py	4.71 KB	-rw-r--r--
gui.py	2.13 KB	-rw-r--r--
HIG.py	57 B	-rw-r--r--
installpackage.py	2.2 KB	-rw-r--r--
install-printerdriver.py	5.34 KB	-rwxr-xr-x
jobviewer.py	96.57 KB	-rw-r--r--
killtimer.py	2.08 KB	-rw-r--r--
monitor.py	32.36 KB	-rw-r--r--
newprinter.py	178.27 KB	-rw-r--r--
OpenPrintingRequest.py	6.81 KB	-rw-r--r--
options.py	18.97 KB	-rw-r--r--
optionwidgets.py	8.89 KB	-rw-r--r--
PhysicalDevice.py	16.19 KB	-rw-r--r--
ppdcache.py	7.57 KB	-rw-r--r--
ppdippstr.py	16.19 KB	-rw-r--r--
ppdsloader.py	10.98 KB	-rw-r--r--
printerproperties.py	78.11 KB	-rw-r--r--
probe_printer.py	15.82 KB	-rw-r--r--
pysmb.py	6.81 KB	-rwxr-xr-x
scp-dbus-service.py	22.22 KB	-rwxr-xr-x
SearchCriterion.py	1.32 KB	-rw-r--r--
serversettings.py	21.83 KB	-rw-r--r--
smburi.py	3.22 KB	-rw-r--r--
statereason.py	6.83 KB	-rw-r--r--
system-config-printer.py	86.48 KB	-rwxr-xr-x
timedops.py	8.21 KB	-rw-r--r--
ToolbarSearchEntry.py	6.96 KB	-rw-r--r--
userdefault.py	6.2 KB	-rw-r--r--

Code Editor : ppdcache.py

#!/usr/bin/python3

## Copyright (C) 2010, 2011, 2012, 2013, 2014 Red Hat, Inc.
## Authors:
##  Tim Waugh <twaugh@redhat.com>

## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.

## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.

## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

import asyncconn
import cups
from gi.repository import GLib
from gi.repository import Gdk
from gi.repository import Gtk
import os
from shutil import copyfileobj
from tempfile import NamedTemporaryFile
from debug import *

cups.require ("1.9.50")

class PPDCache:
    def __init__ (self, host=None, port=None, encryption=None):
        self._cups = None
        self._exc = None
        self._cache = dict()
        self._modtimes = dict()
        self._host = host
        self._port = port
        self._encryption = encryption
        self._queued = list()
        self._connecting = False
        debugprint ("+%s" % self)

def __del__ (self):
        debugprint ("-%s" % self)
        if self._cups:
            self._cups.destroy ()

def fetch_ppd (self, name, callback, check_uptodate=True):
        if check_uptodate and name in self._modtimes:
            # We have getPPD3 so we can check whether the PPD is up to
            # date.
            debugprint ("%s: check if %s is up to date" % (self, name))
            self._cups.getPPD3 (name,
                                modtime=self._modtimes[name],
                                reply_handler=lambda c, r:
                                    self._got_ppd3 (c, name, r, callback),
                                error_handler=lambda c, r:
                                    self._got_ppd3 (c, name, r, callback))
            return

try:
            f = self._cache[name]
        except RuntimeError as e:
            self._schedule_callback (callback, name, None, e)
            return
        except KeyError:
            if not self._cups:
                self._queued.append ((name, callback))
                if not self._connecting:
                    self._connect ()

return

debugprint ("%s: fetch PPD for %s" % (self, name))
            self._cups.getPPD3 (name,
                                reply_handler=lambda c, r:
                                    self._got_ppd3 (c, name, r, callback),
                                error_handler=lambda c, r:
                                    self._got_ppd3 (c, name, r, callback))
            return

# Copy from our file object to a new temporary file, create a
        # PPD object from it, then remove the file.  This way we don't
        # leave temporary files around even though we are caching...
        f.seek (0)
        with NamedTemporaryFile () as tmpf:
            copyfileobj (f, tmpf)

try:
                ppd = cups.PPD (tmpf.file)
                self._schedule_callback (callback, name, ppd, None)
            except Exception as e:
                self._schedule_callback (callback, name, None, e)

def _connect (self, callback=None):
        self._connecting = True
        asyncconn.Connection (host=self._host, port=self._port,
                              encryption=self._encryption,
                              reply_handler=self._connected,
                              error_handler=self._connected)

def _got_ppd (self, connection, name, result, callback):
        if isinstance (result, Exception):
            self._schedule_callback (callback, name, none, result)
        else:
            # Store an open file object, then remove the actual file.
            # This way we don't leave temporary files around.
            try:
                self._cache[name] = open (result, "rb")
                debugprint ("%s: caching %s (fd %d)" %
                            (self, result,
                             self._cache[name].fileno()))
                os.unlink (result)
            except IOError as exc:
                self._schedule_callback (callback, name, None, exc)
                return

self.fetch_ppd (name, callback)

def _got_ppd3 (self, connection, name, result, callback):
        (status, modtime, filename) = result
        if status in [cups.HTTP_OK, cups.HTTP_NOT_MODIFIED]:
            if status == cups.HTTP_NOT_MODIFIED:
                # The file is no newer than the one we already have.

# CUPS before 1.5.3 created a temporary file in error
                # in this situation (STR #4018) so remove that.
                try:
                    os.unlink (filename)
                except OSError:
                    pass

elif status == cups.HTTP_OK:
                # Our version of the file was older.  Cache the new version.

# Store an open file object, then remove the actual
                # file.  This way we don't leave temporary files
                # around.
                try:
                    self._cache[name] = open (filename, "rb")
                    debugprint ("%s: caching %s (fd %d) "
                                "(%s) - %s" % (self, filename,
                                               self._cache[name].fileno (),
                                               modtime, status))
                    os.unlink (filename)
                    self._modtimes[name] = modtime
                except IOError as exc:
                    # File disappeared?
                    debugprint ("%s: file %s disappeared? Unable to cache it"
                                % (self, filename))
                    self._schedule_callback (callback, name, None, exc)
                    return

# Now fetch it from our own cache.
            self.fetch_ppd (name, callback, check_uptodate=False)
        else:
            self._schedule_callback (callback, name,
                                     None, cups.HTTPError (status))

def _connected (self, connection, exc):
        self._connecting = False
        if isinstance (exc, Exception):
            self._cups = None
            self._exc = exc
        else:
            self._cups = connection

queued = self._queued
        self._queued = list()
        for name, callback in queued:
            self.fetch_ppd (name, callback)

def _schedule_callback (self, callback, name, result, exc):
        def cb_func (callback, name, result, exc):
            Gdk.threads_enter ()
            callback (name, result, exc)
            Gdk.threads_leave ()
            return False

GLib.idle_add (cb_func, callback, name, result, exc)

if __name__ == "__main__":
    import sys
    from debug import *
    from gi.repository import GObject
    set_debugging (True)
    Gdk.threads_init ()
    loop = GObject.MainLoop ()

def signal (name, result, exc):
        debugprint ("**** %s" % name)
        debugprint (repr (result))
        debugprint (repr (exc))

c = cups.Connection ()
    printers = c.getPrinters ()
    del c

cache = PPDCache ()
    p = None
    for p in printers:
        cache.fetch_ppd (p, signal)

if p:
        GLib.timeout_add_seconds (1, cache.fetch_ppd, p, signal)
        GLib.timeout_add_seconds (5, loop.quit)
    loop.run ()

${this.title}

Code Editor : ppdcache.py