Python Logger.warn方法代码示例

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def log_screen_sizes(root_w, root_h, sizes):
    try:
        do_log_screen_sizes(root_w, root_h, sizes)
    except Exception:
        from xpra.log import Logger
        log = Logger("util")
        log.warn("failed to parse screen size information: %s", sys.exc_info()[1])

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def log_screen_sizes(root_w, root_h, sizes):
    try:
        do_log_screen_sizes(root_w, root_h, sizes)
    except Exception as e:
        from xpra.log import Logger
        log = Logger("screen")
        log.warn("failed to parse screen size information: %s", e, exc_info=True)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def log_screen_sizes(root_w, root_h, ss):
    try:
        do_log_screen_sizes(root_w, root_h, ss)
    except Exception, e:
        from xpra.log import Logger
        log = Logger()
        log.warn("failed to parse screen size information: %s", e)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def get_icc_info():
    from xpra.log import Logger

    log = Logger("platform")
    info = {}
    try:
        from PIL.ImageCms import (
            get_display_profile,
            getProfileName,
            getProfileInfo,
            getProfileCopyright,
            getProfileManufacturer,
            getProfileModel,
            getProfileDescription,
            getDefaultIntent,
            INTENT_PERCEPTUAL,
            INTENT_RELATIVE_COLORIMETRIC,
            INTENT_SATURATION,
            INTENT_ABSOLUTE_COLORIMETRIC,
        )

        INTENT_STR = {
            INTENT_PERCEPTUAL: "perceptual",
            INTENT_RELATIVE_COLORIMETRIC: "relative-colorimetric",
            INTENT_SATURATION: "saturation",
            INTENT_ABSOLUTE_COLORIMETRIC: "absolute-colorimetric",
        }

        def getDefaultIntentStr(_p):
            return INTENT_STR.get(getDefaultIntent(_p), "unknown")

        def getData(_p):
            return _p.tobytes()

        p = get_display_profile()
        if p:
            for (k, fn) in {
                "name": getProfileName,
                "info": getProfileInfo,
                "copyright": getProfileCopyright,
                "manufacturer": getProfileManufacturer,
                "model": getProfileModel,
                "description": getProfileDescription,
                "default-intent": getDefaultIntentStr,
                "data": getData,
            }.items():
                try:
                    v = fn(p)
                    info[k] = v
                except Exception as e:
                    log("ICC profile error on %s using %s: %s", k, fn, e)
    except Exception as e:
        log.warn("Warning: cannot query ICC profiles:")
        log.warn(" %s", e)
    return info

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def get_icc_info():
    from xpra.log import Logger
    log = Logger("platform")
    ENV_ICC_DATA = os.environ.get("XPRA_ICC_DATA")
    if ENV_ICC_DATA:
        import binascii
        return {
                "source"    : "environment-override",
                "data"      : binascii.unhexlify(ENV_ICC_DATA),
                }
    info = {}
    try:
        from PIL import ImageCms
        from PIL.ImageCms import get_display_profile, getDefaultIntent
        INTENT_STR = {}
        for x in ("PERCEPTUAL", "RELATIVE_COLORIMETRIC", "SATURATION", "ABSOLUTE_COLORIMETRIC"):
            v = getattr(ImageCms, "INTENT_%s" % x, None)
            if v:
                INTENT_STR[v] = x.lower().replace("_", "-")
        log("get_icc_info() intents=%s", INTENT_STR)
        def getDefaultIntentStr(_p):
            return INTENT_STR.get(getDefaultIntent(_p), "unknown")
        def getData(_p):
            return _p.tobytes()
        p = get_display_profile()
        log("get_icc_info() display_profile=%s", p)
        if p:
            for (k, fn) in {
                            "name"          : "getProfileName",
                            "info"          : "getProfileInfo",
                            "copyright"     : "getProfileCopyright",
                            "manufacturer"  : "getProfileManufacturer",
                            "model"         : "getProfileModel",
                            "description"   : "getProfileDescription",
                            "default-intent": "getDefaultIntentStr",
                            "data"          : "getData",
                            }.items():
                m = getattr(ImageCms, fn, None)
                if not m:
                    log("%s lacks %s", ImageCms, fn)
                    continue
                try:
                    v = m(p)
                    info[k] = v
                except Exception as e:
                    log("ICC profile error on %s using %s: %s", k, fn, e)
    except Exception as e:
        log("get_icc_info()", exc_info=True)
        log.warn("Warning: cannot query ICC profiles:")
        log.warn(" %s", e)
    return info

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def ival(key, default, minv=0, maxv=None):
    try:
        v = os.environ.get("XPRA_BATCH_%s" % key)
        if v is None:
            return default
        iv = int(v)
        assert minv is None or minv<=iv, "value for %s is too small: %s (minimum is %s)" % (key, iv, minv)
        assert maxv is None or maxv>=iv, "value for %s is too high: %s (maximum is %s)" % (key, iv, maxv)
        return iv
    except Exception as e:
        from xpra.log import Logger
        log = Logger("util")
        log.warn("failed to parse value '%s' for %s: %s", v, key, e)
        return default

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def set_application_name(name):
    global NAME_SET
    if NAME_SET:
        return
    NAME_SET = True
    from xpra.log import Logger
    log = Logger()
    if sys.version_info[:2]<(2,5):
        log.warn("Python %s is too old!", sys.version_info)
        return
    try:
        import glib
        glib.set_application_name(name or "Xpra")
    except ImportError, e:
        log.warn("glib is missing, cannot set the application name, please install glib's python bindings: %s", e)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def parse_simple_dict(s="", sep=","):
    #parse the options string and add the pairs:
    d = {}
    for s in s.split(sep):
        if not s:
            continue
        try:
            k,v = s.split("=", 1)
            d[k] = v
        except Exception as e:
            from xpra.log import Logger
            log = Logger("util")
            log.warn("Warning: failed to parse dictionary option '%s':", s)
            log.warn(" %s", e)
    return d

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
def mdns_publish(display_name, mode, listen_on, text_dict={}):
    try:
        from xpra.net.avahi_publisher import AvahiPublishers
    except Exception as e:
        global MDNS_WARNING
        if not MDNS_WARNING:
            MDNS_WARNING = True
            from xpra.log import Logger
            log = Logger("mdns")
            log.warn("Warning: failed to load the mdns avahi publisher: %s", e)
            log.warn(" either fix your installation or use the 'mdns=no' option")
        return
    d = text_dict.copy()
    d["mode"] = mode
    ap = AvahiPublishers(listen_on, "Xpra %s %s" % (mode, display_name), text_dict=d)
    _when_ready.append(ap.start)
    _cleanups.append(ap.stop)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
from xpra.x11.bindings.window_bindings import (
                constants,                      #@UnresolvedImport
                X11WindowBindings,          #@UnresolvedImport
                PropertyError)              #@UnresolvedImport
X11Window = X11WindowBindings()

from xpra.os_util import StringIOClass
from xpra.x11.xsettings_prop import set_settings, get_settings
from xpra.gtk_common.error import trap, XError
from xpra.log import Logger
log = Logger("x11", "window")

try:
    from xpra.codecs.argb.argb import premultiply_argb_in_place #@UnresolvedImport
except:
    log.warn("argb module is missing, icon transparency will be incorrect")
    premultiply_argb_in_place = None

import sys
if sys.version > '3':
    long = int              #@ReservedAssignment
    unicode = str           #@ReservedAssignment


USPosition      = constants["USPosition"]
PPosition       = constants["PPosition"]
PMaxSize        = constants["PMaxSize"]
PMinSize        = constants["PMinSize"]
PBaseSize       = constants["PBaseSize"]
PResizeInc      = constants["PResizeInc"]
PAspect         = constants["PAspect"]

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
log("pycups settings: ALLOW=%s", ALLOW)
log("pycups settings: FORWARDER_TMPDIR=%s", FORWARDER_TMPDIR)
log("pycups settings: SKIPPED_PRINTERS=%s", SKIPPED_PRINTERS)

MIMETYPE_TO_PRINTER = {"application/postscript": "Generic PostScript Printer", "application/pdf": "Generic PDF Printer"}
MIMETYPE_TO_PPD = {"application/postscript": "CUPS-PDF.ppd", "application/pdf": "Generic-PDF_Printer-PDF.ppd"}


DEFAULT_CUPS_OPTIONS = {}
dco = os.environ.get("XPRA_DEFAULT_CUPS_OPTIONS", "fit-to-page=True")
if dco:
    for opt in dco.split(","):
        opt = opt.strip(" ")
        parts = opt.split("=", 1)
        if len(parts) != 2:
            log.warn("Warning: invalid cups option: '%s'", opt)
            continue
        # is it a boolean?
        k, v = parts
        DEFAULT_CUPS_OPTIONS[k] = v
    log("DEFAULT_CUPS_OPTIONS=%s", DEFAULT_CUPS_OPTIONS)


# allows us to inject the lpadmin and lpinfo commands from the config file
def set_lpadmin_command(lpadmin):
    global LPADMIN
    LPADMIN = lpadmin


def set_lpinfo_command(lpinfo):
    global LPINFO

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
            g.Commit()
            self.group = g
            log("dbus service added")
        except DBusException, e:
            # use try+except as older versions may not have those modules?
            message = e.get_dbus_message()
            dbus_error_name = e.get_dbus_name()
            if dbus_error_name == "org.freedesktop.Avahi.CollisionError":
                log.error(
                    "error starting publisher %s: another instance already claims this dbus name: %s, message: %s",
                    self,
                    e,
                    message,
                )
                return
            log.warn("failed to start %s: %s", self, e)
            helpmsg()

    def stop(self):
        log("%s.stop() group=%s", self, self.group)
        if self.group:
            try:
                self.group.Reset()
                self.group = None
            except Exception, e:
                log.error("error stopping publisher %s: %s", self, e)


def main():
    import gobject

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
 if len(line)==0 or line.startswith("#"):
     continue
 debug("line %s: %s", i, line)
 if line.find("|")<0:
     #assume old style file with just the password
     #get all the displays for the current user:
     sockdir = DotXpra(socket_dir)
     results = sockdir.sockets()
     displays = [display for state, display in results if state==DotXpra.LIVE]
     auth_data[""] = line, os.getuid(), os.getgid(), displays, {}, {}
     debug("Warning: assuming this is a single password for all users")
     continue
 ldata = line.split("|")
 debug("found %s fields at line %s", len(ldata), i)
 if len(ldata)<4:
     log.warn("skipped line %s of %s: not enough fields", i, password_file)
     continue
 #parse fields:
 username = ldata[0]
 password = ldata[1]
 def getsysid(s, default_value):
     if not s:
         return default_value
     try:
         return int(s)
     except:
         return default_value
 uid = getsysid(ldata[2], os.getuid())
 gid = getsysid(ldata[3], os.getgid())
 displays = ldata[4].split(",")
 env_options = {}

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
log = Logger("x11", "window")
workspacelog = Logger("x11", "window", "workspace")
metalog = Logger("x11", "window", "metadata")
geomlog = Logger("x11", "window", "geometry")
menulog = Logger("x11", "window", "menu")


dbus_helper = None
MENU_FORWARDING = os.environ.get("XPRA_MENU_FORWARDING", "1")=="1"
if MENU_FORWARDING:
    try:
        from xpra.dbus.helper import DBusHelper
        dbus_helper = DBusHelper()
        from xpra.dbus.gtk_menuactions import query_actions, query_menu, ACTIONS, MENUS
    except Exception as e:
        log.warn("Warning: menu forwarding is disabled:")
        log.warn(" cannot load dbus helper: %s", e)
        MENU_FORWARDING = False


X11Window = X11WindowBindings()

#_NET_WM_STATE:
_NET_WM_STATE_REMOVE = 0
_NET_WM_STATE_ADD    = 1
_NET_WM_STATE_TOGGLE = 2
STATE_STRING = {
            _NET_WM_STATE_REMOVE    : "REMOVE",
            _NET_WM_STATE_ADD       : "ADD",
            _NET_WM_STATE_TOGGLE    : "TOGGLE",
                }

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import warn [as 别名]
        PRINTER_ENUM_NAMES[v] = k
log("PRINTER_ENUM_VALUES: %s", PRINTER_ENUM_VALUES)

PRINTER_LEVEL = int(os.environ.get("XPRA_WIN32_PRINTER_LEVEL", "1"))
#DEFAULT_PRINTER_FLAGS = "LOCAL"
DEFAULT_PRINTER_FLAGS = "LOCAL,SHARED+NETWORK+CONNECTIONS"
PRINTER_FLAGS = [x.strip() for x in os.environ.get("XPRA_WIN32_PRINTER_FLAGS", DEFAULT_PRINTER_FLAGS).split(",")]
log("PRINTER_FLAGS=%s", csv(PRINTER_FLAGS))
VALID_PRINTER_FLAGS = ("LOCAL", "SHARED", "CONNECTIONS", "NETWORK", "REMOTE")
PRINTER_ENUMS = []
for v in PRINTER_FLAGS:                     #ie: "SHARED+NETWORK+CONNECTIONS"
    flags = v.replace('|','+').split("+")   #ie: ["SHARED", "NETWORK", "CONNECTIONS"]
    values = []
    for flag in flags:                      #ie: "SHARED"
        if flag not in VALID_PRINTER_FLAGS:
            log.warn("Warning: the following printer flag is invalid and will be ignored: %s", flag)
        else:
            values.append(flag)             #ie: "SHARED"
    PRINTER_ENUMS.append(values)
log("PRINTER_ENUMS=%s", PRINTER_ENUMS)


#emulate pycups job id
JOB_ID = 0
PROCESSES = {}

GSVIEW_DIR = None
GSPRINT_EXE = None
GSWIN32C_EXE = None
printers_modified_callback = None
def init_printing(callback=None):