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

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

@@ -1,440 +0,0 @@
-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

@@ -1,105 +0,0 @@
-'''
-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

@@ -1,112 +0,0 @@
-__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

@@ -1,17 +0,0 @@
-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

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