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

venv/Lib/site-packages/jaraco/functools/__init__.pyi

@@ -1,123 +0,0 @@
-from collections.abc import Callable, Hashable, Iterator
-from functools import partial
-from operator import methodcaller
-from typing import (
-    Any,
-    Generic,
-    Protocol,
-    TypeVar,
-    overload,
-)
-
-from typing_extensions import Concatenate, ParamSpec, TypeVarTuple, Unpack
-
-_P = ParamSpec('_P')
-_R = TypeVar('_R')
-_T = TypeVar('_T')
-_Ts = TypeVarTuple('_Ts')
-_R1 = TypeVar('_R1')
-_R2 = TypeVar('_R2')
-_V = TypeVar('_V')
-_S = TypeVar('_S')
-_R_co = TypeVar('_R_co', covariant=True)
-
-class _OnceCallable(Protocol[_P, _R]):
-    saved_result: _R
-    reset: Callable[[], None]
-    def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
-
-class _ProxyMethodCacheWrapper(Protocol[_R_co]):
-    cache_clear: Callable[[], None]
-    def __call__(self, *args: Hashable, **kwargs: Hashable) -> _R_co: ...
-
-class _MethodCacheWrapper(Protocol[_R_co]):
-    def cache_clear(self) -> None: ...
-    def __call__(self, *args: Hashable, **kwargs: Hashable) -> _R_co: ...
-
-# `compose()` overloads below will cover most use cases.
-
-@overload
-def compose(
-    __func1: Callable[[_R], _T],
-    __func2: Callable[_P, _R],
-    /,
-) -> Callable[_P, _T]: ...
-@overload
-def compose(
-    __func1: Callable[[_R], _T],
-    __func2: Callable[[_R1], _R],
-    __func3: Callable[_P, _R1],
-    /,
-) -> Callable[_P, _T]: ...
-@overload
-def compose(
-    __func1: Callable[[_R], _T],
-    __func2: Callable[[_R2], _R],
-    __func3: Callable[[_R1], _R2],
-    __func4: Callable[_P, _R1],
-    /,
-) -> Callable[_P, _T]: ...
-def once(func: Callable[_P, _R]) -> _OnceCallable[_P, _R]: ...
-def method_cache(
-    method: Callable[..., _R],
-    cache_wrapper: Callable[[Callable[..., _R]], _MethodCacheWrapper[_R]] = ...,
-) -> _MethodCacheWrapper[_R] | _ProxyMethodCacheWrapper[_R]: ...
-def apply(
-    transform: Callable[[_R], _T],
-) -> Callable[[Callable[_P, _R]], Callable[_P, _T]]: ...
-def result_invoke(
-    action: Callable[[_R], Any],
-) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: ...
-def invoke(
-    f: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs
-) -> Callable[_P, _R]: ...
-
-class Throttler(Generic[_R]):
-    last_called: float
-    func: Callable[..., _R]
-    max_rate: float
-    def __init__(
-        self, func: Callable[..., _R] | Throttler[_R], max_rate: float = ...
-    ) -> None: ...
-    def reset(self) -> None: ...
-    def __call__(self, *args: Any, **kwargs: Any) -> _R: ...
-    def __get__(self, obj: Any, owner: type[Any] | None = ...) -> Callable[..., _R]: ...
-
-def first_invoke(
-    func1: Callable[..., Any], func2: Callable[_P, _R]
-) -> Callable[_P, _R]: ...
-
-method_caller: Callable[..., methodcaller]
-
-def retry_call(
-    func: Callable[..., _R],
-    cleanup: Callable[..., None] = ...,
-    retries: float = ...,
-    trap: type[BaseException] | tuple[type[BaseException], ...] = ...,
-) -> _R: ...
-def retry(
-    cleanup: Callable[..., None] = ...,
-    retries: float = ...,
-    trap: type[BaseException] | tuple[type[BaseException], ...] = ...,
-) -> Callable[[Callable[..., _R]], Callable[..., _R]]: ...
-def print_yielded(func: Callable[_P, Iterator[Any]]) -> Callable[_P, None]: ...
-def pass_none(
-    func: Callable[Concatenate[_T, _P], _R],
-) -> Callable[Concatenate[_T, _P], _R]: ...
-def assign_params(
-    func: Callable[..., _R], namespace: dict[str, Any]
-) -> partial[_R]: ...
-def save_method_args(
-    method: Callable[Concatenate[_S, _P], _R],
-) -> Callable[Concatenate[_S, _P], _R]: ...
-def except_(
-    *exceptions: type[BaseException], replace: Any = ..., use: Any = ...
-) -> Callable[[Callable[_P, Any]], Callable[_P, Any]]: ...
-def identity(x: _T) -> _T: ...
-def bypass_when(
-    check: _V, *, _op: Callable[[_V], Any] = ...
-) -> Callable[[Callable[[_T], _R]], Callable[[_T], _T | _R]]: ...
-def bypass_unless(
-    check: Any,
-) -> Callable[[Callable[[_T], _R]], Callable[[_T], _T | _R]]: ...
-def splat(func: Callable[[Unpack[_Ts]], _R]) -> Callable[[tuple[Unpack[_Ts]]], _R]: ...

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

@@ -1,89 +0,0 @@
-'''
-PyJNIus
-=======
-
-Accessing Java classes from Python.
-
-All the documentation is available at: http://pyjnius.readthedocs.org
-'''
-
-__version__ = '1.7.0'
-
-from .env import get_java_setup
-
-import os
-import sys
-if sys.platform == 'win32' and sys.version_info >= (3, 8):
-    path = os.path.dirname(__file__)
-    java = get_java_setup(sys.platform)
-    jdk_home = java.get_javahome()
-    with os.add_dll_directory(path):
-        for suffix in (
-            ('bin', 'client'),
-            ('bin', 'server'),
-            ('bin', 'default'),
-            ('jre', 'bin', 'client'),
-            ('jre', 'bin', 'server'),
-            ('jre', 'bin', 'default'),
-        ):
-            path = os.path.join(jdk_home, *suffix)
-            if not os.path.isdir(path):
-                continue
-
-            with os.add_dll_directory(path):
-                try:
-                    from .jnius import *  # noqa
-                    from .reflect import *  # noqa
-                except Exception as e:
-                    pass
-                else:
-                    break
-        else:
-            raise Exception("Unable to create jni env, no jvm dll found.")
-else:
-    from .jnius import *  # noqa
-    from .reflect import *  # noqa
-
-# XXX monkey patch methods that cannot be in cython.
-# Cython doesn't allow to set new attribute on methods it compiled
-
-HASHCODE_MAX = 2 ** 31 - 1
-
-
-class PythonJavaClass_(PythonJavaClass, metaclass=MetaJavaBase):
-
-    @java_method('()I', name='hashCode')
-    def hashCode(self):
-        return id(self) % HASHCODE_MAX
-
-    @java_method('()Ljava/lang/String;', name='hashCode')
-    def hashCode_(self):
-        return '{}'.format(self.hashCode())
-
-    @java_method('()Ljava/lang/String;', name='toString')
-    def toString(self):
-        return repr(self)
-
-    @java_method('(Ljava/lang/Object;)Z', name='equals')
-    def equals(self, other):
-        return self.hashCode() == other.hashCode()
-
-
-PythonJavaClass = PythonJavaClass_
-
-
-# from https://gist.github.com/tito/09c42fb4767721dc323d
-import os
-if "ANDROID_ARGUMENT" in os.environ:
-    # on android, catch all exception to ensure about a jnius.detach
-    import threading
-    import jnius
-    orig_thread_run = threading.Thread.run
-
-    def jnius_thread_hook(*args, **kwargs):
-        try:
-            return orig_thread_run(*args, **kwargs)
-        finally:
-            jnius.detach()
-
-    threading.Thread.run = jnius_thread_hook

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

@@ -1,378 +0,0 @@
-'''
-This module determine and expose various information about the java
-environment.
-'''
-
-import sys
-from os.path import join, exists, dirname, realpath
-from os import getenv
-from platform import machine
-from subprocess import Popen, check_output, PIPE
-from shlex import split
-import logging
-from textwrap import dedent
-from shutil import which
-
-log = logging.getLogger('kivy').getChild(__name__)
-
-machine = machine()  # not expected to change at runtime
-
-# This dictionary converts values from platform.machine()
-# to a "cpu" string. It is needed to set the correct lib path,
-# found in the JRE_HOME, e.g.: <JRE_HOME>/lib/<cpu>/.
-MACHINE2CPU = {
-    "i686": "i386",
-    "x86_64": "amd64",
-    "AMD64": "amd64",
-    "armv7l": "arm",
-    "aarch64": "aarch64",
-    "sun4u": "sparcv9",
-    "sun4v": "sparcv9"
-}
-
-DEFAULT_PLATFORM = sys.platform
-
-
-def is_set(string):
-    return string is not None and len(string) > 0
-
-
-def get_java_setup(platform=DEFAULT_PLATFORM):
-    '''
-        Returns an instance of JavaLocation. 
-    '''
-    # prefer Env variables
-    JAVA_HOME = getenv('JAVA_HOME')
-    if not is_set(JAVA_HOME):
-        JAVA_HOME = getenv('JDK_HOME')
-    if not is_set(JAVA_HOME):
-        JAVA_HOME = getenv('JRE_HOME')
-    #TODO encodings
-
-    # Use java_home program on Mac
-    if not is_set(JAVA_HOME) and platform == 'darwin':
-        JAVA_HOME = get_osx_framework()
-        if not is_set(JAVA_HOME):
-            raise Exception('You must install Java for Mac OSX')
-
-    # go hunting for Javac and Java programs, in that order
-    if not is_set(JAVA_HOME):
-        JAVA_HOME = get_jdk_home(platform)
-
-    if not is_set(JAVA_HOME):
-        JAVA_HOME = get_jre_home(platform)
-
-    if JAVA_HOME is None:
-        raise RuntimeError("Could not find your Java installed. Please set the JAVA_HOME env var.")
-
-    if isinstance(JAVA_HOME, bytes):
-        JAVA_HOME = JAVA_HOME.decode('utf-8')
-
-    log.debug("Identified Java at %s" % JAVA_HOME)
-
-    # Remove /bin if it's appended to JAVA_HOME
-    if JAVA_HOME[-3:] == 'bin':
-        JAVA_HOME = JAVA_HOME[:-4]
-
-    if platform == "android":
-        return AndroidJavaLocation(platform, JAVA_HOME)
-    if platform == "win32": #only this?
-        return WindowsJavaLocation(platform, JAVA_HOME)
-    if platform == "darwin": #only this?
-        return MacOsXJavaLocation(platform, JAVA_HOME)    
-    if 'bsd' in platform:
-        return BSDJavaLocation(platform, JAVA_HOME)
-    if platform in ('linux', 'linux2', 'sunos5'): #only this?
-        return UnixJavaLocation(platform, JAVA_HOME)
-    log.warning("warning: unknown platform %s assuming linux or sunOS" % platform)
-    return UnixJavaLocation(platform, JAVA_HOME)
-
-
-class JavaLocation:
-    def __init__(self, platform, home):
-        self.platform = platform
-        self.home = home
-
-    def get_javahome(self):
-        '''
-            Returns the location of the identified JRE or JDK
-        '''
-        return self.home
-
-
-    def is_jdk(self):
-        '''
-            Returns true if the location is a JDK, based on existing of javac
-        '''
-        javac = self.get_javac()
-        return exists(javac)
-
-    def get_javac(self): 
-        '''
-            Returns absolute path of the javac executable
-        '''
-        return join(self.home, "bin", "javac")
-
-    def get_include_dirs(self):
-        '''
-            Returns a list of absolute paths of JDK include directories, for compiling.
-            Calls _get_platform_include_dir() internally.
-        ''' 
-        return [
-            join(self.home, 'include'),
-            self._get_platform_include_dir()
-        ]
-
-    def _get_platform_include_dir(self):
-        '''
-            Returns the platform-specific include directory, for setup.py
-        '''
-        pass
-
-    def get_library_dirs(self): 
-        '''
-            Returns a list of absolute paths of JDK lib directories, for setup.py
-        '''
-        pass
-
-    def get_libraries(self): 
-        '''
-            Returns the names of the libraries for this platform, for setup.py
-        '''
-        pass
-
-    def get_jnius_lib_location(self): 
-        '''
-            Returns the full path of the Java library for runtime binding with.
-            Can be overridden by using JVM_PATH env var to set absolute path of the Java library
-        '''
-        libjvm_override_path = getenv('JVM_PATH')
-        if libjvm_override_path:
-            log.info(
-                dedent("""
-                    Using override env var JVM_PATH (%s) to load libjvm.
-                    Please report your system information (os version, java
-                    version, etc), and the path that works for you, to the
-                    PyJNIus project, at https://github.com/kivy/pyjnius/issues.
-                    so we can improve the automatic discovery.
-                """
-                ),
-                libjvm_override_path
-            )
-            return libjvm_override_path
-
-        platform = self.platform
-        log.debug("looking for libjvm to initiate pyjnius, platform is %s", platform)
-        lib_locations = self._possible_lib_locations()
-        for location in lib_locations:
-            full_lib_location = join(self.home, location)
-            if exists(full_lib_location):
-                log.debug("found libjvm.so at %s", full_lib_location)
-                return full_lib_location
-
-        raise RuntimeError(
-        """
-        Unable to find libjvm.so, (tried %s)
-        you can use the JVM_PATH env variable with the absolute path
-        to libjvm.so to override this lookup, if you know
-        where pyjnius should look for it.
-
-        e.g:
-            export JAVA_HOME=/usr/lib/jvm/java-8-oracle/
-            export JVM_PATH=/usr/lib/jvm/java-8-oracle/jre/lib/amd64/server/libjvm.so
-            # run your program
-        """
-        % [join(self.home, loc) for loc in lib_locations]
-    )
-
-    def _possible_lib_locations(self):
-        '''
-            Returns a list of relative possible locations for the Java library.
-            Used by the default implementation of get_jnius_lib_location()
-        '''
-        pass
-
-
-class WindowsJavaLocation(JavaLocation):
-    def get_javac(self):
-        return super().get_javac() + ".exe"
-
-    def get_libraries(self):
-        return ['jvm']
-
-    def get_library_dirs(self):
-        suffices =  ['lib', join('bin', 'server')]
-        return [join(self.home, suffix) for suffix in suffices]
-
-    def _get_platform_include_dir(self):
-        return join(self.home, 'include', 'win32')
-
-
-class UnixJavaLocation(JavaLocation):
-    def _get_platform_include_dir(self):
-        if self.platform == 'sunos5':
-            return join(self.home, 'include', 'solaris')
-        else:
-            return join(self.home, 'include', 'linux')
-
-    def _possible_lib_locations(self):
-        root = self.home
-        if root.endswith('jre'):
-            root = root[:-3]
-
-        cpu = get_cpu()
-        log.debug(
-            f"Platform {self.platform} may need cpu in path to find libjvm, which is: {cpu}"
-        )
-
-        return [
-            'lib/server/libjvm.so',
-            'jre/lib/{}/default/libjvm.so'.format(cpu),
-            'jre/lib/{}/server/libjvm.so'.format(cpu),
-        ]
-
-
-# NOTE: Build works on FreeBSD. Other BSD flavors may need tuning!
-class BSDJavaLocation(JavaLocation):
-    def _get_platform_include_dir(self):
-        os = self.platform.translate({ord(n): None for n in '0123456789'})
-        return join(self.home, 'include', os)
-
-    def _possible_lib_locations(self):
-        root = self.home
-        if root.endswith('jre'):
-            root = root[:-3]
-
-        cpu = get_cpu()
-        log.debug(
-            f"Platform {self.platform} may need cpu in path to find libjvm, which is: {cpu}"
-        )
-
-        return [
-            'lib/server/libjvm.so',
-            'jre/lib/{}/default/libjvm.so'.format(cpu),
-            'jre/lib/{}/server/libjvm.so'.format(cpu),
-        ]
-
-
-class MacOsXJavaLocation(UnixJavaLocation):
-    def _get_platform_include_dir(self):
-        return join(self.home, 'include', 'darwin')
-
-    def _possible_lib_locations(self):
-        if '1.6' in self.home:
-            return ['../Libraries/libjvm.dylib'] # TODO what should this be resolved to?
-
-        return [
-                'jre/lib/jli/libjli.dylib',
-                # In that case, the Java version >=9.
-                'lib/jli/libjli.dylib',
-                # adoptopenjdk12 doesn't have the jli subfolder either
-                'lib/libjli.dylib',
-        ]
-
-
-
-    # this is overridden due to the specifalities of version 1.6
-    def get_include_dirs(self):
-        framework = self.home
-        if '1.6' in framework:
-            return [join(
-                framework, (
-                    'System/Library/Frameworks/'
-                    'JavaVM.framework/Versions/Current/Headers'
-                )
-            )]
-        return super().get_include_dirs()
-
-
-class AndroidJavaLocation(UnixJavaLocation):
-    def get_libraries(self):
-        return ['SDL2', 'log']
-
-    def get_include_dirs(self):
-        # When cross-compiling for Android, we should not use the include dirs
-        # exposed by the JDK. Instead, we should use the one exposed by the
-        # Android NDK (which are already handled via python-for-android).
-        return []
-
-    def get_library_dirs(self):
-        return []
-
-
-def get_jre_home(platform):
-    jre_home = None
-    if JAVA_HOME and exists(join(JAVA_HOME, 'jre')):
-        jre_home = join(JAVA_HOME, 'jre')
-
-    if platform != 'win32' and not jre_home:
-        try:
-            jre_home = realpath(
-                which('java')
-            ).replace('bin/java', '')
-        except TypeError:
-            raise Exception('Unable to find java')
-
-        if is_set(jre_home):
-            return jre_home
-
-        # didnt find java command on the path, we can
-        # fallback to hunting in some default unix locations
-        for loc in ["/usr/java/latest/", "/usr/java/default/", "/usr/lib/jvm/default-java/"]: 
-            if exists(loc + "bin/java"):
-                jre_home = loc
-                break
-
-    return jre_home
-
-
-def get_jdk_home(platform):
-    jdk_home = getenv('JDK_HOME')
-    if not jdk_home:
-        if platform == 'win32':
-            TMP_JDK_HOME = getenv('JAVA_HOME')
-            if not TMP_JDK_HOME:
-                raise Exception('Unable to find JAVA_HOME')
-
-            # Remove /bin if it's appended to JAVA_HOME
-            if TMP_JDK_HOME[-3:] == 'bin':
-                TMP_JDK_HOME = TMP_JDK_HOME[:-4]
-
-            # Check whether it's JDK
-            if exists(join(TMP_JDK_HOME, 'bin', 'javac.exe')):
-                jdk_home = TMP_JDK_HOME
-
-        else:
-            try:
-                jdk_home = realpath(
-                    which('javac')
-                ).replace('bin/javac', '')
-            except TypeError:
-                raise Exception('Unable to find javac')
-
-    if not jdk_home or not exists(jdk_home):
-        return None
-
-    return jdk_home
-
-
-def get_osx_framework():
-    framework = Popen(
-        '/usr/libexec/java_home',
-        stdout=PIPE, shell=True
-    ).communicate()[0]
-
-    framework = framework.decode('utf-8')
-    return framework.strip()
-
-
-def get_cpu():
-    try:
-        return MACHINE2CPU[machine]
-    except KeyError:
-        print(
-            "WARNING: Not able to assign machine()"
-            " = %s to a cpu value!" % machine
-        )
-        print(f"         Using cpu = '{machine}' instead!")
-        return machine