android-notify 1.59.4__py3-none-any.whl → 1.60.0__py3-none-any.whl

venv/Lib/site-packages/jnius/reflect.py

@@ -0,0 +1,440 @@
+from __future__ import absolute_import
+from __future__ import unicode_literals
+from __future__ import division
+from collections import defaultdict
+import logging
+
+
+from .jnius import (
+    JavaClass, MetaJavaClass, JavaMethod, JavaStaticMethod,
+    JavaField, JavaStaticField, JavaMultipleMethod, find_javaclass,
+    JavaException, get_signature
+)
+
+__all__ = ('autoclass', 'ensureclass', 'protocol_map')
+
+log = logging.getLogger('kivy').getChild(__name__)
+
+
+class Class(JavaClass, metaclass=MetaJavaClass):
+    __javaclass__ = 'java/lang/Class'
+
+    desiredAssertionStatus = JavaMethod('()Z')
+    forName = JavaMultipleMethod([
+        ('(Ljava/lang/String,Z,Ljava/lang/ClassLoader;)Ljava/langClass;', True, False),
+        ('(Ljava/lang/String;)Ljava/lang/Class;', True, False), ])
+    getClassLoader = JavaMethod('()Ljava/lang/ClassLoader;')
+    getClasses = JavaMethod('()[Ljava/lang/Class;')
+    getComponentType = JavaMethod('()Ljava/lang/Class;')
+    getConstructor = JavaMethod('([Ljava/lang/Class;)Ljava/lang/reflect/Constructor;')
+    getConstructors = JavaMethod('()[Ljava/lang/reflect/Constructor;')
+    getDeclaredClasses = JavaMethod('()[Ljava/lang/Class;')
+    getDeclaredConstructor = JavaMethod('([Ljava/lang/Class;)Ljava/lang/reflect/Constructor;')
+    getDeclaredConstructors = JavaMethod('()[Ljava/lang/reflect/Constructor;')
+    getDeclaredField = JavaMethod('(Ljava/lang/String;)Ljava/lang/reflect/Field;')
+    getDeclaredFields = JavaMethod('()[Ljava/lang/reflect/Field;')
+    getDeclaredMethod = JavaMethod('(Ljava/lang/String,[Ljava/lang/Class;)Ljava/lang/reflect/Method;')
+    getDeclaredMethods = JavaMethod('()[Ljava/lang/reflect/Method;')
+    getDeclaringClass = JavaMethod('()Ljava/lang/Class;')
+    getField = JavaMethod('(Ljava/lang/String;)Ljava/lang/reflect/Field;')
+    getFields = JavaMethod('()[Ljava/lang/reflect/Field;')
+    getInterfaces = JavaMethod('()[Ljava/lang/Class;')
+    getMethod = JavaMethod('(Ljava/lang/String,[Ljava/lang/Class;)Ljava/lang/reflect/Method;')
+    getMethods = JavaMethod('()[Ljava/lang/reflect/Method;')
+    getModifiers = JavaMethod('()[I')
+    getName = JavaMethod('()Ljava/lang/String;')
+    getPackage = JavaMethod('()Ljava/lang/Package;')
+    getProtectionDomain = JavaMethod('()Ljava/security/ProtectionDomain;')
+    getResource = JavaMethod('(Ljava/lang/String;)Ljava/net/URL;')
+    getResourceAsStream = JavaMethod('(Ljava/lang/String;)Ljava/io/InputStream;')
+    getSigners = JavaMethod('()[Ljava/lang/Object;')
+    getSuperclass = JavaMethod('()Ljava/lang/Class;')
+    isArray = JavaMethod('()Z')
+    isAssignableFrom = JavaMethod('(Ljava/lang/Class;)Z')
+    isInstance = JavaMethod('(Ljava/lang/Object;)Z')
+    isInterface = JavaMethod('()Z')
+    isPrimitive = JavaMethod('()Z')
+    newInstance = JavaMethod('()Ljava/lang/Object;')
+    toString = JavaMethod('()Ljava/lang/String;')
+
+    def __str__(self):
+        return (
+            '%s: [%s]' if self.isArray() else '%s: %s'
+        ) % (
+            'Interface' if self.isInterface() else
+            'Primitive' if self.isPrimitive() else
+            'Class',
+            self.getName()
+        )
+
+    def __repr__(self):
+        return '<%s at 0x%x>' % (self, id(self))
+
+
+class Object(JavaClass, metaclass=MetaJavaClass):
+    __javaclass__ = 'java/lang/Object'
+
+    getClass = JavaMethod('()Ljava/lang/Class;')
+    hashCode = JavaMethod('()I')
+
+
+class Modifier(JavaClass, metaclass=MetaJavaClass):
+    __javaclass__ = 'java/lang/reflect/Modifier'
+
+    isAbstract = JavaStaticMethod('(I)Z')
+    isFinal = JavaStaticMethod('(I)Z')
+    isInterface = JavaStaticMethod('(I)Z')
+    isNative = JavaStaticMethod('(I)Z')
+    isPrivate = JavaStaticMethod('(I)Z')
+    isProtected = JavaStaticMethod('(I)Z')
+    isPublic = JavaStaticMethod('(I)Z')
+    isStatic = JavaStaticMethod('(I)Z')
+    isStrict = JavaStaticMethod('(I)Z')
+    isSynchronized = JavaStaticMethod('(I)Z')
+    isTransient = JavaStaticMethod('(I)Z')
+    isVolatile = JavaStaticMethod('(I)Z')
+
+class Method(JavaClass, metaclass=MetaJavaClass):
+    __javaclass__ = 'java/lang/reflect/Method'
+
+    getName = JavaMethod('()Ljava/lang/String;')
+    toString = JavaMethod('()Ljava/lang/String;')
+    getParameterTypes = JavaMethod('()[Ljava/lang/Class;')
+    getReturnType = JavaMethod('()Ljava/lang/Class;')
+    getModifiers = JavaMethod('()I')
+    isVarArgs = JavaMethod('()Z')
+    isDefault = JavaMethod('()Z')
+
+
+class Field(JavaClass, metaclass=MetaJavaClass):
+    __javaclass__ = 'java/lang/reflect/Field'
+
+    getName = JavaMethod('()Ljava/lang/String;')
+    toString = JavaMethod('()Ljava/lang/String;')
+    getType = JavaMethod('()Ljava/lang/Class;')
+    getModifiers = JavaMethod('()I')
+
+
+class Constructor(JavaClass, metaclass=MetaJavaClass):
+    __javaclass__ = 'java/lang/reflect/Constructor'
+
+    toString = JavaMethod('()Ljava/lang/String;')
+    getParameterTypes = JavaMethod('()[Ljava/lang/Class;')
+    getModifiers = JavaMethod('()I')
+    isVarArgs = JavaMethod('()Z')
+
+
+registers = []
+
+
+def ensureclass(clsname):
+    if clsname in registers:
+        return
+    jniname = clsname.replace('.', '/')
+    if MetaJavaClass.get_javaclass(jniname):
+        return
+    registers.append(clsname)
+    autoclass(clsname)
+
+
+def lower_name(s):
+    return s[:1].lower() + s[1:] if s else ''
+
+
+def bean_getter(s):
+    return (s.startswith('get') and len(s) > 3 and s[3].isupper()) or (s.startswith('is') and len(s) > 2 and s[2].isupper())
+
+
+def log_method(method, name, signature):
+    mods = method.getModifiers()
+    log.debug(
+        '\nmeth: %s\n'
+        '  sig: %s\n'
+        '  Public %s\n'
+        '  Private %s\n'
+        '  Protected %s\n'
+        '  Static %s\n'
+        '  Final %s\n'
+        '  Synchronized %s\n'
+        '  Volatile %s\n'
+        '  Transient %s\n'
+        '  Native %s\n'
+        '  Interface %s\n'
+        '  Abstract %s\n'
+        '  Strict %s\n',
+        name,
+        signature,
+        Modifier.isPublic(mods),
+        Modifier.isPrivate(mods),
+        Modifier.isProtected(mods),
+        Modifier.isStatic(mods),
+        Modifier.isFinal(mods),
+        Modifier.isSynchronized(mods),
+        Modifier.isVolatile(mods),
+        Modifier.isTransient(mods),
+        Modifier.isNative(mods),
+        Modifier.isInterface(mods),
+        Modifier.isAbstract(mods),
+        Modifier.isStrict(mods)
+    )
+
+def identify_hierarchy(cls, level, concrete=True):
+    supercls = cls.getSuperclass()
+    if supercls is not None:
+         for sup, lvl in identify_hierarchy(supercls, level + 1, concrete=concrete):
+             yield sup, lvl # we could use yield from when we drop python2
+    interfaces = cls.getInterfaces()
+    for interface in interfaces or []:
+        for sup, lvl in identify_hierarchy(interface, level + 1, concrete=concrete):
+            yield sup, lvl
+    # all object extends Object, so if this top interface in a hierarchy, yield Object
+    if not concrete and cls.isInterface() and not interfaces:
+        yield find_javaclass('java.lang.Object'), level +1
+    yield cls, level
+
+
+# NOTE: if you change the include_protected or include_private default values,
+# you also must change the classparams default value in MetaJavaClass.__new__
+# and MetaJavaClass.get_javaclass.
+def autoclass(clsname, include_protected=True, include_private=True):
+    jniname = clsname.replace('.', '/')
+    cls = MetaJavaClass.get_javaclass(jniname, classparams=(include_protected, include_private))
+    if cls:
+        return cls
+
+    classDict = {}
+    cls_start_packagename = '.'.join(clsname.split('.')[:-1])
+
+    # c = Class.forName(clsname)
+    c = find_javaclass(clsname)
+    if c is None:
+        raise Exception('Java class {0} not found'.format(c))
+        return None
+
+    classDict['_class'] = c
+
+    constructors = []
+    for constructor in c.getConstructors():
+        sig = '({0})V'.format(
+            ''.join([get_signature(x) for x in constructor.getParameterTypes()]))
+        constructors.append((sig, constructor.isVarArgs()))
+    classDict['__javaconstructor__'] = constructors
+
+    class_hierachy = list(identify_hierarchy(c, 0, not c.isInterface()))
+
+    log.debug("autoclass(%s) intf %r hierarchy is %s" % (clsname,c.isInterface(),str(class_hierachy)))
+    cls_done=set()
+
+    cls_methods = defaultdict(list)
+    cls_fields = {}
+
+    # we now walk the hierarchy, from top of the tree, identifying methods
+    # hopefully we start at java.lang.Object 
+    for cls, level in class_hierachy:
+        # dont analyse a given class more than once.
+        # many interfaces can lead to java.lang.Object
+        if cls in cls_done:
+            continue
+        cls_packagename = '.'.join(cls.getName().split('.')[:-1])
+        cls_done.add(cls)
+        # as we are walking the entire hierarchy, we only need getDeclaredMethods()
+        # to get what is in this class; other parts of the hierarchy will be found
+        # in those respective classes.
+        methods = cls.getDeclaredMethods()
+        methods_name = [x.getName() for x in methods]
+        # collect all methods declared by this class of the hierarchy for later traversal
+        for index, method in enumerate(methods):
+            method_modifier = method.getModifiers()
+            if Modifier.isProtected(method_modifier) and not include_protected:
+                continue
+            if Modifier.isPrivate(method_modifier) and not include_private:
+                continue
+            if not (Modifier.isPublic(method_modifier) or
+                    Modifier.isProtected(method_modifier) or
+                    Modifier.isPrivate(method_modifier)):
+                if cls_start_packagename == cls_packagename and not include_protected:
+                    continue
+                if cls_start_packagename != cls_packagename and not include_private:
+                    continue
+            name = methods_name[index]
+            cls_methods[name].append((cls, method, level))
+    
+        fields = cls.getDeclaredFields()
+        for field in fields:
+            field_name = field.getName()
+            if field_name in cls_fields:
+                if level < cls_fields[field_name][1]:
+                    cls_fields[field_name] = (field, level, cls_packagename)
+            else:
+                cls_fields[field_name] = (field, level, cls_packagename)
+
+    # the fields are analyzed before methods so that if a method and a field
+    # have the same name, the field will take precedence in classDict.
+    for field_name, (field, _, cls_packagename) in cls_fields.items():
+        field_modifier = field.getModifiers()
+        static = Modifier.isStatic(field_modifier)
+        sig = get_signature(field.getType())
+        if Modifier.isProtected(field_modifier) and not include_protected:
+            continue
+        if Modifier.isPrivate(field_modifier) and not include_private:
+            continue
+        if not (Modifier.isPublic(field_modifier) or
+                Modifier.isProtected(field_modifier) or
+                Modifier.isPrivate(field_modifier)):
+            if cls_start_packagename == cls_packagename and not include_protected:
+                continue
+            if cls_start_packagename != cls_packagename and not include_private:
+                continue
+        cls = JavaStaticField if static else JavaField
+        classDict[field_name] = cls(sig)
+
+    # having collated the methods, identify if there are any with the same name
+    for name in cls_methods:
+        if len(cls_methods[name]) == 1:
+            # uniquely named method
+            owningCls, method, level = cls_methods[name][0]
+            static = Modifier.isStatic(method.getModifiers())
+            varargs = method.isVarArgs()
+            sig = '({0}){1}'.format(
+                ''.join([get_signature(x) for x in method.getParameterTypes()]),
+                get_signature(method.getReturnType()))
+            if log.isEnabledFor(logging.DEBUG):
+                log_method(method, name, sig)
+            classDict[name] = (JavaStaticMethod if static else JavaMethod)(sig, varargs=varargs)
+            # methods that fit the characteristics of a JavaBean's methods get turned into properties.
+            # these added properties should not supercede any other methods or fields.
+            if name != 'getClass' and bean_getter(name) and len(method.getParameterTypes()) == 0:
+                lowername = lower_name(name[2 if name.startswith('is') else 3:])
+                if lowername in classDict:
+                    # don't add this to classDict if the property will replace a method or field.
+                    continue
+                classDict[lowername] = (lambda n: property(lambda self: getattr(self, n)()))(name)
+        else:
+            # multiple signatures
+            signatures = []
+            log.debug("method %s has %d multiple signatures in hierarchy of cls %s" % (name, len(cls_methods[name]), c))
+
+            paramsig_to_level=defaultdict(lambda: float('inf'))
+            # we now identify if any have the same signature, as we will call the _lowest_ in the hierarchy,
+            # as reflected in min level
+            for owningCls, method, level in cls_methods[name]:
+                param_sig = ''.join([get_signature(x) for x in method.getParameterTypes()])
+                log.debug("\t owner %s level %d param_sig %s" % (str(owningCls), level, param_sig))
+                if level < paramsig_to_level[param_sig]:
+                    paramsig_to_level[param_sig] = level
+
+            for owningCls, method, level in cls_methods[name]:
+                param_sig = ''.join([get_signature(x) for x in method.getParameterTypes()])
+                # only accept the parameter signature at the deepest level of hierarchy (i.e. min level)
+                if level > paramsig_to_level[param_sig]:
+                    log.debug("discarding %s name from %s at level %d" % (name, str(owningCls), level))
+                    continue
+
+                return_sig = get_signature(method.getReturnType())
+                sig = '({0}){1}'.format(param_sig, return_sig)
+
+                if log.isEnabledFor(logging.DEBUG):
+                    log_method(method, name, sig)
+                signatures.append((sig, Modifier.isStatic(method.getModifiers()), method.isVarArgs()))
+
+            log.debug("method selected %d multiple signatures of %s" % (len(signatures), str(signatures)))
+            classDict[name] = JavaMultipleMethod(signatures)
+
+    # check whether any classes in the hierarchy appear in the protocol_map
+    for cls, _ in class_hierachy:
+        cls_name = cls.getName()
+        if cls_name in protocol_map:
+            for pname, plambda in protocol_map[cls_name].items():
+                classDict[pname] = plambda
+
+    classDict['__javaclass__'] = clsname.replace('.', '/')
+    return MetaJavaClass.__new__(
+        MetaJavaClass,
+        clsname,
+        (JavaClass, ),
+        classDict,
+        classparams=(include_protected, include_private))
+
+
+def _getitem(self, index):
+    ''' dunder method for List '''
+    try:
+        return self.get(index)
+    except JavaException as e:
+        # initialize the subclass before getting the Class.forName
+        # otherwise isInstance does not know of the subclass
+        mock_exception_object = autoclass(e.classname)()
+        if find_javaclass("java.lang.IndexOutOfBoundsException").isInstance(mock_exception_object):
+            # python for...in iteration checks for end of list by waiting for IndexError
+            raise IndexError()
+        else:
+            raise
+
+def _map_getitem(self, k):
+    ''' dunder method for java.util.Map '''
+    rtr = self.get(k)
+    if rtr is None:
+        raise KeyError()
+    return rtr
+
+def _map_entry_getitem(self, i):
+    if i == 0:
+        return self.getKey()
+    if i == 1:
+        return self.getValue()
+    raise IndexError()
+
+def _iterator_next(self):
+    ''' dunder method for java.util.Iterator'''
+    if not self.hasNext():
+        raise StopIteration()
+
+    return self.next()
+
+
+# protocol_map is a user-accessible API for patching class instances with additional methods
+protocol_map = {
+    'java.util.Collection' : {
+        '__len__' : lambda self: self.size(),
+        '__contains__' : lambda self, item: self.contains(item),
+        '__delitem__' : lambda self, item: self.remove(item)
+    },
+    'java.util.List' : {
+        '__getitem__' : _getitem
+    },
+    'java.util.Map' : {
+        '__setitem__' : lambda self, k, v : self.put(k,v),
+        '__getitem__' : _map_getitem,
+        '__delitem__' : lambda self, item: self.remove(item),
+        '__len__' : lambda self: self.size(),
+        '__contains__' : lambda self, item: self.containsKey(item),
+        '__iter__' : lambda self: self.keySet().iterator()
+    },
+    'java.util.Map$Entry' : {
+        '__getitem__' : _map_entry_getitem,
+        '__iter__' : lambda self: iter([self.getKey(), self.getValue()]),
+        '__len__' : lambda self: 2
+    },
+    'java.util.Iterator' : {
+        '__iter__' : lambda self: self,
+        '__next__' : _iterator_next,
+    },
+    'java.lang.Iterable' : {
+        '__iter__' : lambda self: self.iterator(),
+    },
+    # this also addresses java.io.Closeable
+    'java.lang.AutoCloseable' : {
+        '__enter__' : lambda self: self,
+        '__exit__' : lambda self, type, value, traceback: self.close()
+    },
+    'java.lang.Comparable' : {
+        #__cmp__ is for Python 2 support
+        '__cmp__' : lambda self, other: self.compareTo(other),
+        '__eq__' : lambda self, other: self.equals(other),
+        '__ne__' : lambda self, other: not self.equals(other),
+        '__lt__' : lambda self, other: self.compareTo(other) < 0,
+        '__gt__' : lambda self, other: self.compareTo(other) > 0,
+        '__le__' : lambda self, other: self.compareTo(other) <= 0,
+        '__ge__' : lambda self, other: self.compareTo(other) >= 0,
+    }
+}

venv/Lib/site-packages/jnius/signatures.py

@@ -0,0 +1,105 @@
+'''
+signatures.py
+=============
+
+A handy API for writing JNI signatures easily
+
+Author: chrisjrn
+
+This module aims to provide a more human-friendly API for
+wiring up Java proxy methods in PyJnius.
+
+You can use the signature function to produce JNI method
+signautures for methods; passing PyJnius JavaClass classes
+as return or argument types; provided here are annotations
+representing Java's primitive and array times.
+
+Methods can return just a standard primitive type:
+
+>>> signature(jint, ())
+'()I'
+
+>>> s.signature(jvoid, [jint])
+'(I)V'
+
+Or you can use autoclass proxies to specify Java classes
+for return types.
+
+>>> from jnius import autoclass
+>>> String = autoclass("java.lang.String")
+>>> signature(String, ())
+'()Ljava/lang/String;'
+
+'''
+
+__version__ = '0.0.1'
+
+from . import JavaClass
+from . import java_method
+
+
+''' Type specifiers for primitives '''
+
+
+class _JavaSignaturePrimitive(object):
+    _spec = ""
+
+
+def _MakeSignaturePrimitive(name, spec):
+    class __Primitive(_JavaSignaturePrimitive):
+        ''' PyJnius signature for Java %s type ''' % name
+        _name = name
+        _spec = spec
+    __Primitive.__name__ = "j" + name
+
+    return __Primitive
+
+
+jboolean = _MakeSignaturePrimitive("boolean", "Z")
+jbyte    = _MakeSignaturePrimitive("byte", "B")
+jchar    = _MakeSignaturePrimitive("char", "C")
+jdouble  = _MakeSignaturePrimitive("double", "D")
+jfloat   = _MakeSignaturePrimitive("float", "F")
+jint     = _MakeSignaturePrimitive("int", "I")
+jlong    = _MakeSignaturePrimitive("long", "J")
+jshort   = _MakeSignaturePrimitive("short", "S")
+jvoid    = _MakeSignaturePrimitive("void", "V")
+
+
+def JArray(of_type):
+    ''' Signature helper for identifying arrays of a given object or
+    primitive type. '''
+
+    spec = "[" + _jni_type_spec(of_type)
+    return _MakeSignaturePrimitive("array", spec)
+
+
+def with_signature(returns, takes):
+    ''' Alternative version of @java_method that takes JavaClass
+    objects to produce the method signature. '''
+
+    sig = signature(returns, takes)
+    return java_method(sig)
+
+
+def signature(returns, takes):
+    ''' Produces a JNI method signature, taking the provided arguments
+    and returning the given return type. '''
+
+    out_takes = []
+    for arg in takes:
+        out_takes.append(_jni_type_spec(arg))
+
+    return "(" + "".join(out_takes) + ")" + _jni_type_spec(returns)
+
+
+def _jni_type_spec(jclass):
+    ''' Produces a JNI type specification string for the given argument.
+    If the argument is a jnius.JavaClass, it produces the JNI type spec
+    for the class. Signature primitives return their stored type spec.
+    '''
+
+    if issubclass(jclass, JavaClass):
+        return "L" + jclass.__javaclass__ + ";"
+    elif issubclass(jclass, _JavaSignaturePrimitive):
+        return jclass._spec

venv/Lib/site-packages/jnius_config.py

@@ -0,0 +1,112 @@
+__all__ = ('set_options', 'add_options', 'get_options',
+           'set_classpath', 'add_classpath', 'get_classpath',
+           'expand_classpath')
+
+import platform
+if platform.system() == 'Windows':
+    split_char = ';'
+else:
+    split_char = ':'
+
+vm_running = False
+vm_started_at = None
+options = []
+classpath = None
+
+
+def check_vm_running():
+    """Raises a ValueError if the VM is already running."""
+    if vm_running:
+        raise ValueError("VM is already running, can't set classpath/options; VM started at" + vm_started_at)
+
+
+def set_options(*opts):
+    """Sets the list of options to the JVM. Removes any previously set options."""
+    check_vm_running()
+    global options
+    options = list(opts)
+
+
+def add_options(*opts):
+    """Appends options to the list of VM options."""
+    check_vm_running()
+    global options
+    options.extend(opts)
+
+
+def get_options():
+    """Retrieves the current list of VM options."""
+    global options
+    return list(options)
+
+
+def set_classpath(*path):
+    """
+    Sets the classpath for the JVM to use. Replaces any existing classpath, overriding the CLASSPATH environment variable.
+    """
+    check_vm_running()
+    global classpath
+    classpath = list(path)
+
+
+def add_classpath(*path):
+    """
+    Appends items to the classpath for the JVM to use.
+    Replaces any existing classpath, overriding the CLASSPATH environment variable.
+    """
+    check_vm_running()
+    global classpath
+    if classpath is None:
+        classpath = list(path)
+    else:
+        classpath.extend(path)
+
+
+def get_classpath():
+    "Retrieves the classpath the JVM will use."
+    from os import environ
+    from os.path import realpath
+    import sys
+    global classpath
+
+    # add a path to java classes packaged with jnius
+    if sys.version_info >= (3, 9):
+        from contextlib import ExitStack
+        import importlib.resources
+        import atexit
+
+        # see https://importlib-resources.readthedocs.io/en/latest/migration.html#pkg-resources-resource-filename
+        file_manager = ExitStack()
+        atexit.register(file_manager.close)
+        # importlib.resources.files is only available from Python 3.9
+        # use https://github.com/python/importlib_resources/issues/60 not __name__ as jnius_config.py is not a package
+        resource_path = importlib.resources.files('jnius') / 'src'
+        return_classpath = [ str(resource_path) ]
+        file_manager.enter_context(importlib.resources.as_file(resource_path))
+    else:
+        from pkg_resources import resource_filename
+        return_classpath = [realpath(resource_filename(__name__, 'jnius/src'))]
+
+
+    if classpath is not None:
+        return_classpath = classpath + return_classpath
+
+    elif 'CLASSPATH' in environ:
+        return_classpath = environ['CLASSPATH'].split(split_char) + return_classpath
+
+    else:
+        return_classpath = [realpath('.')] + return_classpath
+
+    return return_classpath
+
+
+def expand_classpath():
+    from glob import glob
+    paths = []
+    # deal with wildcards
+    for path in get_classpath():
+        if not path.endswith('*'):
+            paths.append(path)
+        else:
+            paths.extend(glob(path + '.[Jj][Aa][Rr]'))
+    return split_char.join(paths)

venv/Lib/site-packages/keyring/__init__.py

@@ -0,0 +1,17 @@
+from .core import (
+    delete_password,
+    get_credential,
+    get_keyring,
+    get_password,
+    set_keyring,
+    set_password,
+)
+
+__all__ = (
+    'set_keyring',
+    'get_keyring',
+    'set_password',
+    'get_password',
+    'delete_password',
+    'get_credential',
+)

venv/Lib/site-packages/keyring/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from keyring import cli
+
+    cli.main()