Gecko [ lorencats.com ]

Name	Size	Permission
backends	[ DIR ]	drwxr-xr-x
tests	[ DIR ]	drwxr-xr-x
util	[ DIR ]	drwxr-xr-x
__init__.py	277 B	-rw-r--r--
__init__.pyc	494 B	-rw-r--r--
__main__.py	70 B	-rw-r--r--
__main__.pyc	254 B	-rw-r--r--
backend.py	5.93 KB	-rw-r--r--
backend.pyc	8 KB	-rw-r--r--
cli.py	4.13 KB	-rw-r--r--
cli.pyc	4.26 KB	-rw-r--r--
core.py	4.96 KB	-rw-r--r--
core.pyc	6.31 KB	-rw-r--r--
credentials.py	1.34 KB	-rw-r--r--
credentials.pyc	2.93 KB	-rw-r--r--
devpi_client.py	199 B	-rw-r--r--
devpi_client.pyc	506 B	-rw-r--r--
errors.py	1.36 KB	-rw-r--r--
errors.pyc	3.06 KB	-rw-r--r--
http.py	1.24 KB	-rw-r--r--
http.pyc	1.92 KB	-rw-r--r--
py27compat.py	1.06 KB	-rw-r--r--
py27compat.pyc	1.46 KB	-rw-r--r--
py32compat.py	107 B	-rw-r--r--
py32compat.pyc	282 B	-rw-r--r--
py33compat.py	660 B	-rw-r--r--
py33compat.pyc	943 B	-rw-r--r--

Code Editor : core.py

"""
Core API functions and initialization routines.
"""

import os
import sys
import logging

from .py27compat import configparser, filter
from .py33compat import max

from . import backend
from .util import platform_ as platform
from .backends import fail

log = logging.getLogger(__name__)

_keyring_backend = None

def set_keyring(keyring):
    """Set current keyring backend.
    """
    global _keyring_backend
    if not isinstance(keyring, backend.KeyringBackend):
        raise TypeError("The keyring must be a subclass of KeyringBackend")
    _keyring_backend = keyring

def get_keyring():
    """Get current keyring backend.
    """
    return _keyring_backend

def disable():
    """
    Configure the null keyring as the default.
    """
    root = platform.config_root()
    try:
        os.makedirs(root)
    except OSError:
        pass
    filename = os.path.join(root, 'keyringrc.cfg')
    if os.path.exists(filename):
        msg = "Refusing to overwrite {filename}".format(**locals())
        raise RuntimeError(msg)
    with open(filename, 'w') as file:
        file.write('[backend]\ndefault-keyring=keyring.backends.null.Keyring')

def get_password(service_name, username):
    """Get password from the specified service.
    """
    return _keyring_backend.get_password(service_name, username)

def set_password(service_name, username, password):
    """Set password for the user in the specified service.
    """
    _keyring_backend.set_password(service_name, username, password)

def delete_password(service_name, username):
    """Delete the password for the user in the specified service.
    """
    _keyring_backend.delete_password(service_name, username)

def get_credential(service_name, username):
    """Get a Credential for the specified service.
    """
    return _keyring_backend.get_credential(service_name, username)

def recommended(backend):
    return backend.priority >= 1

def init_backend(limit=None):
    """
    Load a keyring specified in the config file or infer the best available.

Limit, if supplied, should be a callable taking a backend and returning
    True if that backend should be included for consideration.
    """
    # save the limit for the chainer to honor
    backend._limit = limit

# get all keyrings passing the limit filter
    keyrings = filter(limit, backend.get_all_keyring())

set_keyring(
        load_env()
        or load_config()
        or max(keyrings, default=fail.Keyring(), key=backend.by_priority)
    )

def _load_keyring_class(keyring_name):
    """
    Load the keyring class indicated by name.

These popular names are tested to ensure their presence.

>>> popular_names = [
    ...      'keyring.backends.Windows.WinVaultKeyring',
    ...      'keyring.backends.OS_X.Keyring',
    ...      'keyring.backends.kwallet.DBusKeyring',
    ...      'keyring.backends.SecretService.Keyring',
    ...  ]
    >>> list(map(_load_keyring_class, popular_names))
    [...]

These legacy names are retained for compatibility.

>>> legacy_names = [
    ...  ]
    >>> list(map(_load_keyring_class, legacy_names))
    [...]
    """
    module_name, sep, class_name = keyring_name.rpartition('.')
    __import__(module_name)
    module = sys.modules[module_name]
    return getattr(module, class_name)

def load_keyring(keyring_name):
    """
    Load the specified keyring by name (a fully-qualified name to the
    keyring, such as 'keyring.backends.file.PlaintextKeyring')
    """
    class_ = _load_keyring_class(keyring_name)
    # invoke the priority to ensure it is viable, or raise a RuntimeError
    class_.priority
    return class_()

def load_env():
    """Load a keyring configured in the environment variable."""
    try:
        return load_keyring(os.environ['PYTHON_KEYRING_BACKEND'])
    except KeyError:
        pass

def load_config():
    """Load a keyring using the config file in the config root."""

filename = 'keyringrc.cfg'

keyring_cfg = os.path.join(platform.config_root(), filename)

if not os.path.exists(keyring_cfg):
        return

config = configparser.RawConfigParser()
    config.read(keyring_cfg)
    _load_keyring_path(config)

# load the keyring class name, and then load this keyring
    try:
        if config.has_section("backend"):
            keyring_name = config.get("backend", "default-keyring").strip()
        else:
            raise configparser.NoOptionError('backend', 'default-keyring')

except (configparser.NoOptionError, ImportError):
        logger = logging.getLogger('keyring')
        logger.warning("Keyring config file contains incorrect values.\n"
                       + "Config file: %s" % keyring_cfg)
        return

return load_keyring(keyring_name)

def _load_keyring_path(config):
    "load the keyring-path option (if present)"
    try:
        path = config.get("backend", "keyring-path").strip()
        sys.path.insert(0, path)
    except (configparser.NoOptionError, configparser.NoSectionError):
        pass

# init the _keyring_backend
init_backend()

${this.title}

Code Editor : core.py