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

venv/Lib/site-packages/win32ctypes/core/_winerrors.py

@@ -0,0 +1,9 @@
+#
+# (C) Copyright 2014 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+
+ERROR_NOT_FOUND = 0x490

venv/Lib/site-packages/win32ctypes/core/cffi/__init__.py

@@ -0,0 +1,11 @@
+#
+# (C) Copyright 2014-2023 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+import logging
+
+logger = logging.getLogger(__name__)
+logger.debug('Loaded cffi backend')

venv/Lib/site-packages/win32ctypes/core/cffi/_authentication.py

@@ -0,0 +1,172 @@
+#
+# (C) Copyright 2015 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from weakref import WeakKeyDictionary
+
+from win32ctypes.core.compat import is_text
+from ._util import ffi, check_false, dlls
+from ._nl_support import _GetACP
+from ._common import _PyBytes_FromStringAndSize
+
+
+ffi.cdef("""
+
+typedef struct _FILETIME {
+  DWORD dwLowDateTime;
+  DWORD dwHighDateTime;
+} FILETIME, *PFILETIME;
+
+typedef struct _CREDENTIAL_ATTRIBUTE {
+  LPWSTR Keyword;
+  DWORD  Flags;
+  DWORD  ValueSize;
+  LPBYTE Value;
+} CREDENTIAL_ATTRIBUTE, *PCREDENTIAL_ATTRIBUTE;
+
+typedef struct _CREDENTIAL {
+  DWORD                 Flags;
+  DWORD                 Type;
+  LPWSTR                TargetName;
+  LPWSTR                Comment;
+  FILETIME              LastWritten;
+  DWORD                 CredentialBlobSize;
+  LPBYTE                CredentialBlob;
+  DWORD                 Persist;
+  DWORD                 AttributeCount;
+  PCREDENTIAL_ATTRIBUTE Attributes;
+  LPWSTR                TargetAlias;
+  LPWSTR                UserName;
+} CREDENTIAL, *PCREDENTIAL;
+
+
+BOOL WINAPI CredReadW(
+    LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIAL *Credential);
+BOOL WINAPI CredWriteW(PCREDENTIAL Credential, DWORD);
+VOID WINAPI CredFree(PVOID Buffer);
+BOOL WINAPI CredDeleteW(LPCWSTR TargetName, DWORD Type, DWORD Flags);
+BOOL WINAPI CredEnumerateW(
+    LPCWSTR Filter, DWORD Flags, DWORD *Count, PCREDENTIAL **Credential);
+""")
+
+_keep_alive = WeakKeyDictionary()
+
+
+SUPPORTED_CREDKEYS = set((
+    u'Type', u'TargetName', u'Persist',
+    u'UserName', u'Comment', u'CredentialBlob'))
+
+
+def make_unicode(password):
+    """ Convert the input string to unicode.
+
+    """
+    if is_text(password):
+        return password
+    else:
+        code_page = _GetACP()
+        return password.decode(encoding=str(code_page), errors='strict')
+
+
+class _CREDENTIAL(object):
+
+    def __call__(self):
+        return ffi.new("PCREDENTIAL")[0]
+
+    @classmethod
+    def fromdict(cls, credential, flag=0):
+        unsupported = set(credential.keys()) - SUPPORTED_CREDKEYS
+        if len(unsupported):
+            raise ValueError("Unsupported keys: {0}".format(unsupported))
+        if flag != 0:
+            raise ValueError("flag != 0 not yet supported")
+
+        factory = cls()
+        c_creds = factory()
+        # values to ref and make sure that they will not go away
+        values = []
+        for key, value in credential.items():
+            if key == u'CredentialBlob':
+                blob = make_unicode(value)
+                blob_data = ffi.new('wchar_t[]', blob)
+                # new adds a NULL at the end that we do not want.
+                c_creds.CredentialBlobSize = \
+                    ffi.sizeof(blob_data) - ffi.sizeof('wchar_t')
+                c_creds.CredentialBlob = ffi.cast('LPBYTE', blob_data)
+                values.append(blob_data)
+            elif key in (u'Type', u'Persist'):
+                setattr(c_creds, key, value)
+            elif value is None:
+                setattr(c_creds, key, ffi.NULL)
+            else:
+                blob = make_unicode(value)
+                pblob = ffi.new('wchar_t[]', blob)
+                values.append(pblob)
+                setattr(c_creds, key, ffi.cast('LPTSTR', pblob))
+        # keep values alive until c_creds goes away.
+        _keep_alive[c_creds] = tuple(values)
+        return c_creds
+
+
+CREDENTIAL = _CREDENTIAL()
+
+
+def PCREDENTIAL(value=None):
+    return ffi.new("PCREDENTIAL", ffi.NULL if value is None else value)
+
+
+def PPCREDENTIAL(value=None):
+    return ffi.new("PCREDENTIAL*", ffi.NULL if value is None else value)
+
+
+def PPPCREDENTIAL(value=None):
+    return ffi.new("PCREDENTIAL**", ffi.NULL if value is None else value)
+
+
+def credential2dict(pc_creds):
+    credentials = {}
+    for key in SUPPORTED_CREDKEYS:
+        if key == u'CredentialBlob':
+            data = _PyBytes_FromStringAndSize(
+                pc_creds.CredentialBlob, pc_creds.CredentialBlobSize)
+        elif key in (u'Type', u'Persist'):
+            data = int(getattr(pc_creds, key))
+        else:
+            string_pointer = getattr(pc_creds, key)
+            if string_pointer == ffi.NULL:
+                data = None
+            else:
+                data = ffi.string(string_pointer)
+        credentials[key] = data
+    return credentials
+
+
+def _CredRead(TargetName, Type, Flags, ppCredential):
+    target = make_unicode(TargetName)
+    return check_false(
+        dlls.advapi32.CredReadW(target, Type, Flags, ppCredential),
+        u'CredRead')
+
+
+def _CredWrite(Credential, Flags):
+    return check_false(
+        dlls.advapi32.CredWriteW(Credential, Flags), u'CredWrite')
+
+
+def _CredDelete(TargetName, Type, Flags):
+    return check_false(
+        dlls.advapi32.CredDeleteW(
+            make_unicode(TargetName), Type, Flags), u'CredDelete')
+
+
+def _CredEnumerate(Filter, Flags, Count, pppCredential):
+    filter = make_unicode(Filter) if Filter is not None else ffi.NULL
+    return check_false(
+        dlls.advapi32.CredEnumerateW(filter, Flags, Count, pppCredential),
+        u'CredEnumerate')
+
+
+_CredFree = dlls.advapi32.CredFree

venv/Lib/site-packages/win32ctypes/core/cffi/_common.py

@@ -0,0 +1,29 @@
+#
+# (C) Copyright 2015 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from weakref import WeakKeyDictionary
+
+from ._util import ffi
+
+_keep_alive = WeakKeyDictionary()
+
+
+def _PyBytes_FromStringAndSize(pointer, size):
+    buffer = ffi.buffer(pointer, size)
+    return buffer[:]
+
+
+def byreference(x):
+    return ffi.new(ffi.getctype(ffi.typeof(x), '*'), x)
+
+
+def dereference(x):
+    return x[0]
+
+
+def PDWORD(value=0):
+    return ffi.new("DWORD *", value)

venv/Lib/site-packages/win32ctypes/core/cffi/_dll.py

@@ -0,0 +1,30 @@
+#
+# (C) Copyright 2018 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from ._util import ffi, check_null, check_false, dlls, HMODULE, PVOID
+
+
+ffi.cdef("""
+
+HMODULE WINAPI LoadLibraryExW(LPCTSTR lpFileName, HANDLE hFile, DWORD dwFlags);
+BOOL WINAPI FreeLibrary(HMODULE hModule);
+
+""")
+
+
+def _LoadLibraryEx(lpFilename, hFile, dwFlags):
+    result = check_null(
+        dlls.kernel32.LoadLibraryExW(
+            str(lpFilename), ffi.NULL, dwFlags),
+        function_name='LoadLibraryEx')
+    return HMODULE(result)
+
+
+def _FreeLibrary(hModule):
+    check_false(
+        dlls.kernel32.FreeLibrary(PVOID(hModule)),
+        function_name='FreeLibrary')

venv/Lib/site-packages/win32ctypes/core/cffi/_nl_support.py

@@ -0,0 +1,18 @@
+#
+# (C) Copyright 2015-18 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from ._util import ffi, dlls
+
+ffi.cdef("""
+
+UINT WINAPI GetACP(void);
+
+""")
+
+
+def _GetACP():
+    return dlls.kernel32.GetACP()

venv/Lib/site-packages/win32ctypes/core/cffi/_resource.py

@@ -0,0 +1,132 @@
+#
+# (C) Copyright 2015 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from ._util import (
+    ffi, check_null, check_zero, check_false, HMODULE,
+    PVOID, RESOURCE, resource, dlls)
+
+
+ffi.cdef("""
+
+typedef int WINBOOL;
+typedef WINBOOL (__stdcall *ENUMRESTYPEPROC) (HANDLE, LPTSTR, LONG_PTR);
+typedef WINBOOL (__stdcall *ENUMRESNAMEPROC) (HANDLE, LPCTSTR, LPTSTR, LONG_PTR);
+typedef WINBOOL (__stdcall *ENUMRESLANGPROC) (HANDLE, LPCTSTR, LPCTSTR, WORD, LONG_PTR);
+
+BOOL WINAPI EnumResourceTypesW(
+    HMODULE hModule, ENUMRESTYPEPROC lpEnumFunc, LONG_PTR lParam);
+BOOL WINAPI EnumResourceNamesW(
+    HMODULE hModule, LPCTSTR lpszType,
+    ENUMRESNAMEPROC lpEnumFunc, LONG_PTR lParam);
+BOOL WINAPI EnumResourceLanguagesW(
+    HMODULE hModule, LPCTSTR lpType,
+    LPCTSTR lpName, ENUMRESLANGPROC lpEnumFunc, LONG_PTR lParam);
+HRSRC WINAPI FindResourceExW(
+    HMODULE hModule, LPCTSTR lpType, LPCTSTR lpName, WORD wLanguage);
+DWORD WINAPI SizeofResource(HMODULE hModule, HRSRC hResInfo);
+HGLOBAL WINAPI LoadResource(HMODULE hModule, HRSRC hResInfo);
+LPVOID WINAPI LockResource(HGLOBAL hResData);
+
+HANDLE WINAPI BeginUpdateResourceW(LPCTSTR pFileName, BOOL bDeleteExistingResources);
+BOOL WINAPI EndUpdateResourceW(HANDLE hUpdate, BOOL fDiscard);
+BOOL WINAPI UpdateResourceW(HANDLE hUpdate, LPCTSTR lpType, LPCTSTR lpName, WORD wLanguage, LPVOID lpData, DWORD cbData);
+
+""")  # noqa
+
+
+def ENUMRESTYPEPROC(callback):
+    def wrapped(hModule, lpszType, lParam):
+        return callback(hModule, resource(lpszType), lParam)
+    return wrapped
+
+
+def ENUMRESNAMEPROC(callback):
+    def wrapped(hModule, lpszType, lpszName, lParam):
+        if lpszName == ffi.NULL:
+            return False
+        return callback(
+            hModule, resource(lpszType), resource(lpszName), lParam)
+    return wrapped
+
+
+def ENUMRESLANGPROC(callback):
+    def wrapped(hModule, lpszType, lpszName, wIDLanguage, lParam):
+        return callback(
+            hModule, resource(lpszType), resource(lpszName),
+            wIDLanguage, lParam)
+    return wrapped
+
+
+def _EnumResourceTypes(hModule, lpEnumFunc, lParam):
+    callback = ffi.callback('ENUMRESTYPEPROC', lpEnumFunc)
+    check_false(
+        dlls.kernel32.EnumResourceTypesW(PVOID(hModule), callback, lParam),
+        function_name='EnumResourceTypes')
+
+
+def _EnumResourceNames(hModule, lpszType, lpEnumFunc, lParam):
+    callback = ffi.callback('ENUMRESNAMEPROC', lpEnumFunc)
+    check_false(
+        dlls.kernel32.EnumResourceNamesW(
+            PVOID(hModule), RESOURCE(lpszType), callback, lParam),
+        function_name='EnumResourceNames')
+
+
+def _EnumResourceLanguages(hModule, lpType, lpName, lpEnumFunc, lParam):
+    callback = ffi.callback('ENUMRESLANGPROC', lpEnumFunc)
+    check_false(
+        dlls.kernel32.EnumResourceLanguagesW(
+            PVOID(hModule), RESOURCE(lpType),
+            RESOURCE(lpName), callback, lParam),
+        function_name='EnumResourceLanguages')
+
+
+def _FindResourceEx(hModule, lpType, lpName, wLanguage):
+    return check_null(
+        dlls.kernel32.FindResourceExW(
+            PVOID(hModule), RESOURCE(lpType), RESOURCE(lpName), wLanguage),
+        function_name='FindResourceEx')
+
+
+def _SizeofResource(hModule, hResInfo):
+    return check_zero(
+        dlls.kernel32.SizeofResource(PVOID(hModule), hResInfo),
+        function_name='SizeofResource')
+
+
+def _LoadResource(hModule, hResInfo):
+    return check_null(
+        dlls.kernel32.LoadResource(PVOID(hModule), hResInfo),
+        function_name='LoadResource')
+
+
+def _LockResource(hResData):
+    return check_null(
+        dlls.kernel32.LockResource(hResData),
+        function_name='LockResource')
+
+
+def _BeginUpdateResource(pFileName, bDeleteExistingResources):
+    result = check_null(
+        dlls.kernel32.BeginUpdateResourceW(
+            str(pFileName), bDeleteExistingResources))
+    return HMODULE(result)
+
+
+def _EndUpdateResource(hUpdate, fDiscard):
+    check_false(
+        dlls.kernel32.EndUpdateResourceW(PVOID(hUpdate), fDiscard),
+        function_name='EndUpdateResource')
+
+
+def _UpdateResource(hUpdate, lpType, lpName, wLanguage, cData, cbData):
+    lpData = ffi.from_buffer(cData)
+    check_false(
+        dlls.kernel32.UpdateResourceW(
+            PVOID(hUpdate), RESOURCE(lpType), RESOURCE(lpName),
+            wLanguage, PVOID(lpData), cbData),
+        function_name='UpdateResource')

venv/Lib/site-packages/win32ctypes/core/cffi/_system_information.py

@@ -0,0 +1,32 @@
+#
+# (C) Copyright 2018 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from ._util import ffi, dlls
+
+# TODO: retrieve this value using ffi
+MAX_PATH = 260
+MAX_PATH_BUF = u'wchar_t[{0}]'.format(MAX_PATH)
+
+ffi.cdef("""
+
+BOOL WINAPI Beep(DWORD dwFreq, DWORD dwDuration);
+UINT WINAPI GetWindowsDirectoryW(LPTSTR lpBuffer, UINT uSize);
+UINT WINAPI GetSystemDirectoryW(LPTSTR lpBuffer, UINT uSize);
+
+""")
+
+
+def _GetWindowsDirectory():
+    buffer = ffi.new(MAX_PATH_BUF)
+    directory = dlls.kernel32.GetWindowsDirectoryW(buffer, MAX_PATH)
+    return ffi.unpack(buffer, directory)
+
+
+def _GetSystemDirectory():
+    buffer = ffi.new(MAX_PATH_BUF)
+    directory = dlls.kernel32.GetSystemDirectoryW(buffer, MAX_PATH)
+    return ffi.unpack(buffer, directory)

venv/Lib/site-packages/win32ctypes/core/cffi/_time.py

@@ -0,0 +1,18 @@
+#
+# (C) Copyright 2015-18 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+from ._util import ffi, dlls
+
+ffi.cdef("""
+
+DWORD WINAPI GetTickCount(void);
+
+""")
+
+
+def _GetTickCount():
+    return dlls.kernel32.GetTickCount()

venv/Lib/site-packages/win32ctypes/core/cffi/_util.py

@@ -0,0 +1,105 @@
+#
+# (C) Copyright 2015 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+""" Utility functions to help with cffi wrapping.
+"""
+from win32ctypes.core.compat import is_bytes, is_integer
+from cffi import FFI
+
+ffi = FFI()
+ffi.set_unicode(True)
+
+
+def HMODULE(cdata):
+    return int(ffi.cast("intptr_t", cdata))
+
+
+def PVOID(x):
+    return ffi.cast("void *", x)
+
+
+def IS_INTRESOURCE(x):
+    """ Check if x is an index into the id list.
+
+    """
+    return int(ffi.cast("uintptr_t", x)) >> 16 == 0
+
+
+def RESOURCE(resource):
+    """ Convert a resource into a compatible input for cffi.
+
+    """
+    if is_integer(resource):
+        resource = ffi.cast('wchar_t *', resource)
+    elif is_bytes(resource):
+        resource = str(resource)
+    return resource
+
+
+def resource(lpRESOURCEID):
+    """ Convert the windows RESOURCE into a python friendly object.
+    """
+    if IS_INTRESOURCE(lpRESOURCEID):
+        resource = int(ffi.cast("uintptr_t", lpRESOURCEID))
+    else:
+        resource = ffi.string(lpRESOURCEID)
+    return resource
+
+
+class ErrorWhen(object):
+    """ Callable factory for raising errors when calling cffi functions.
+
+    """
+
+    def __init__(self, check, raise_on_zero=True):
+        """ Constructor
+
+        Parameters
+        ----------
+        check :
+            The return value that designates that an error has taken place.
+
+        raise_on_zero : bool
+            When set any error will be raised. When false the winerror
+            is checked and only non-zero win errors are raised. Currently
+            this parameters is used to workaround issues with the win32
+            implementation in ``wine``.
+
+        """
+        self._check = check
+        self._raise_on_zero = raise_on_zero
+
+    def __call__(self, value, function_name=''):
+        if value == self._check:
+            self._raise_error(function_name)
+        else:
+            return value
+
+    def _raise_error(self, function_name=''):
+        code, message = ffi.getwinerror()
+        exception = WindowsError()
+        exception.errno = ffi.errno
+        exception.winerror = code
+        exception.strerror = message
+        exception.function = function_name
+        raise exception
+
+
+check_null = ErrorWhen(ffi.NULL)
+check_zero = ErrorWhen(0)
+check_false = ErrorWhen(False)
+
+
+class Libraries(object):
+
+    def __getattr__(self, name):
+        library = ffi.dlopen('{}.dll'.format(name))
+        self.__dict__[name] = library
+        return library
+
+
+dlls = Libraries()

venv/Lib/site-packages/win32ctypes/core/compat.py

@@ -0,0 +1,10 @@
+def is_bytes(b):
+    return isinstance(b, bytes)
+
+
+def is_text(s):
+    return isinstance(s, str)
+
+
+def is_integer(i):
+    return isinstance(i, int)

venv/Lib/site-packages/win32ctypes/core/ctypes/__init__.py

@@ -0,0 +1,11 @@
+#
+# (C) Copyright 2014-2023 Enthought, Inc., Austin, TX
+# All right reserved.
+#
+# This file is open source software distributed according to the terms in
+# LICENSE.txt
+#
+import logging
+
+logger = logging.getLogger(__name__)
+logger.debug('Loaded ctypes backend')