@scrypted/server 0.0.134 → 0.0.139

package/.venv/lib/python3.9/site-packages/pgi/cffilib/glib/glib.py

@@ -0,0 +1,260 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+import sys
+from contextlib import contextmanager
+
+from .. import _compat
+from ._cdef import GLIB_CDEF
+
+import cffi
+
+
+ffi = cffi.FFI()
+ffi.cdef(GLIB_CDEF)
+if sys.platform == 'win32':
+    lib = ffi.dlopen("libglib-2.0-0.dll")
+else:
+    lib = ffi.dlopen("libglib-2.0.so.0")
+
+
+class GQuark(object):
+
+    def __init__(self, quark):
+        self._ptr = quark
+
+    @classmethod
+    def from_string(cls, string):
+        return GQuark(lib.g_quark_from_string(string))
+
+    def to_string(self):
+        return ffi.string(lib.g_quark_to_string(self._ptr))
+
+    def __repr__(self):
+        return "<%s id='%d' string=%r>" % (
+            type(self).__name__, self._ptr, self.to_string())
+
+    def __int__(self):
+        return self._ptr
+
+
+class GErrorError(Exception):
+    def __init__(self, gerror):
+        super(GErrorError, self).__init__()
+        self.message = gerror.message
+        if _compat.PY3 and self.message is not None:
+            self.message = self.message.decode("utf-8")
+        self.domain = gerror.domain
+        self.code = gerror.code
+
+    def __str__(self):
+        return self.message or ""
+
+
+@contextmanager
+def gerror(type_=GErrorError):
+    error = ffi.new("GError**")
+    yield error
+    gerror = GError(error[0])
+    if gerror:
+        exc = type_(gerror)
+        gerror.free()
+        raise exc
+
+
+@_compat.implements_bool
+class GError(object):
+    def __init__(self, gerror):
+        self._ptr = gerror
+
+    def free(self):
+        lib.g_error_free(self._ptr)
+
+    @classmethod
+    def new(cls, domain, code, format):
+        return GError(lib.g_error_new(domain, int(code), format))
+
+    def copy(self):
+        return GError(lib.g_error_copy(self._ptr))
+
+    @property
+    def domain(self):
+        return GQuark(self._ptr.domain)
+
+    @property
+    def code(self):
+        return self._ptr.code
+
+    @property
+    def message(self):
+        return ffi.string(self._ptr.message)
+
+    def __bool__(self):
+        return bool(self._ptr)
+
+    def __repr__(self):
+        return "<%s domain=%r code='%d', message=%r>" % (
+            type(self).__name__, self.domain, self.code, self.message)
+
+
+class GMappedFile(object):
+    def __init__(self, mapped_file):
+        self._ptr = mapped_file
+
+    @classmethod
+    def new(cls, filename, writeable):
+        error = ffi.new("GError**")
+        res = lib.g_mapped_file_new(filename, writeable, error)
+        gerror = GError(error[0])
+        if gerror:
+            exc = GErrorError(gerror)
+            gerror.free()
+            raise exc
+        return GMappedFile(res)
+
+    def ref(self):
+        lib.g_mapped_file_ref(self._ptr)
+
+    def unref(self):
+        lib.g_mapped_file_unref(self._ptr)
+
+    def get_length(self):
+        return lib.g_mapped_file_get_length(self._ptr)
+
+    def get_contents(self):
+        res = lib.g_mapped_file_get_contents(self._ptr)
+        if res:
+            return ffi.string(res)
+        return
+
+
+class GOptionGroup(object):
+    def __init__(self, group):
+        self._ptr = group
+
+    def free(self):
+        lib.g_option_group_free(self._ptr)
+
+
+class GSList(object):
+    def __init__(self, l):
+        self._ptr = l
+
+    @classmethod
+    def alloc(cls):
+        return GSList(lib.g_slist_alloc())
+
+    @property
+    def data(self):
+        return self._ptr.data
+
+    @property
+    def next(self):
+        n = self._ptr.next
+        if n:
+            return GSList(n)
+        return
+
+    def append(self, data):
+        return GSList(lib.g_slist_append(self._ptr, data))
+
+    def free(self):
+        lib.g_slist_free(self._ptr)
+
+    def foreach(self, func, userdata):
+        ffifunc = ffi.callback("GFunc", func)
+        lib.g_slist_foreach(self._ptr, ffifunc, userdata)
+
+    def __repr__(self):
+        return "<%s data=%r, next=%r>" % (
+            type(self).__name__, self.data, self.next)
+
+
+class GList(object):
+    def __init__(self, l):
+        self.ptr = l
+
+    @property
+    def data(self):
+        return self.ptr.data
+
+    @property
+    def next(self):
+        n = self.ptr.next
+        if n:
+            return GList(n)
+        return
+
+    @property
+    def prev(self):
+        n = self.ptr.prev
+        if n:
+            return GList(n)
+        return
+
+    def free(self):
+        lib.g_slist_free(self.ptr)
+
+    def __repr__(self):
+        return "<%s data=%r, next=%r>" % (
+            type(self).__name__, self.data, self.next)
+
+
+def malloc0(n_bytes):
+    return lib.g_malloc0(n_bytes)
+
+
+def free(mem):
+    return lib.g_free(mem)
+
+
+def try_malloc0(n_bytes):
+    return lib.g_try_malloc0(n_bytes)
+
+
+def strdup(string):
+    return lib.g_strdup(string)
+
+
+def memdup(mem, size):
+    return lib.g_memdup(mem, size)
+
+
+def unpack_glist(glist_ptr, cffi_type, transfer_full=True):
+    """Takes a glist ptr, copies the values casted to type_ in to a list
+    and frees all items and the list.
+
+    If an item is returned all yielded before are invalid.
+    """
+
+    current = glist_ptr
+    while current:
+        yield ffi.cast(cffi_type, current.data)
+        if transfer_full:
+            free(current.data)
+        current = current.next
+    if transfer_full:
+        lib.g_list_free(glist_ptr)
+
+
+def unpack_zeroterm_array(ptr):
+    """Converts a zero terminated array to a list and frees each element
+    and the list itself.
+
+    If an item is returned all yielded before are invalid.
+    """
+
+    assert ptr
+
+    index = 0
+    current = ptr[index]
+    while current:
+        yield current
+        free(ffi.cast("gpointer", current))
+        index += 1
+        current = ptr[index]
+    free(ffi.cast("gpointer", ptr))

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gobject/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from ._ffi import ffi
+from .gobject import GParamFlags, GType, g_type_init, GSignalFlags
+
+GParamFlags
+ffi
+GType
+g_type_init
+GSignalFlags

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gobject/_cdef.py

@@ -0,0 +1,45 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from .. import _fixup_cdef_enums
+
+
+GOBJECT_CDEF = """
+typedef enum {
+  G_PARAM_READABLE            = 1 << 0,
+  G_PARAM_WRITABLE            = 1 << 1,
+  G_PARAM_CONSTRUCT           = 1 << 2,
+  G_PARAM_CONSTRUCT_ONLY      = 1 << 3,
+  G_PARAM_LAX_VALIDATION      = 1 << 4,
+  G_PARAM_STATIC_NAME         = 1 << 5,
+  G_PARAM_STATIC_NICK         = 1 << 6,
+  G_PARAM_STATIC_BLURB        = 1 << 7,
+  G_PARAM_DEPRECATED          = 1 << 31
+} GParamFlags;
+
+typedef enum
+{
+  G_SIGNAL_RUN_FIRST	= 1 << 0,
+  G_SIGNAL_RUN_LAST	= 1 << 1,
+  G_SIGNAL_RUN_CLEANUP	= 1 << 2,
+  G_SIGNAL_NO_RECURSE	= 1 << 3,
+  G_SIGNAL_DETAILED	= 1 << 4,
+  G_SIGNAL_ACTION	= 1 << 5,
+  G_SIGNAL_NO_HOOKS	= 1 << 6,
+  G_SIGNAL_MUST_COLLECT = 1 << 7,
+  G_SIGNAL_DEPRECATED   = 1 << 8
+} GSignalFlags;
+
+typedef struct _GValue GValue;
+
+typedef gulong GType;
+
+GType               g_type_from_name                    (const gchar *name);
+void                g_type_init                         (void);
+"""
+
+GOBJECT_CDEF = _fixup_cdef_enums(GOBJECT_CDEF)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gobject/_ffi.py

@@ -0,0 +1,26 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+
+import sys
+import cffi
+
+from .. import glib
+from ._cdef import GOBJECT_CDEF
+
+
+ffi = cffi.FFI()
+ffi.include(glib.ffi)
+ffi.cdef(GOBJECT_CDEF)
+
+if sys.platform == 'win32':
+    lib = ffi.dlopen("libgobject-2.0-0.dll")
+else:
+    lib = ffi.dlopen("libgobject-2.0.so.0")
+
+
+__all__ = ["ffi", "lib"]

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gobject/gobject.py

@@ -0,0 +1,27 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from ._ffi import ffi, lib
+from .._compat import long
+from .. import _create_enum_class
+
+
+GParamFlags = _create_enum_class(ffi, "GParamFlags", "G_PARAM_", flags=True)
+
+
+GSignalFlags = _create_enum_class(ffi, "GSignalFlags", "G_SIGNAL_", flags=True)
+
+
+class GType(long):
+
+    @classmethod
+    def from_name(cls, name):
+        return cls(lib.g_type_from_name(name))
+
+
+def g_type_init():
+    lib.g_type_init()

package/.venv/lib/python3.9/site-packages/pgi/clib/__init__.py

@@ -0,0 +1,11 @@
+# Copyright 2014 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from ._utils import find_library
+
+
+find_library

package/.venv/lib/python3.9/site-packages/pgi/clib/_compat.py

@@ -0,0 +1,20 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = not PY2
+
+
+if PY3:
+    xrange = range
+elif PY2:
+    xrange = xrange
+else:
+    assert 0

package/.venv/lib/python3.9/site-packages/pgi/clib/_utils.py

@@ -0,0 +1,213 @@
+# Copyright 2012,2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+import os
+import sys
+from weakref import proxy
+from ctypes import cdll, c_void_p, c_size_t, c_char_p
+
+from ._compat import PY3
+
+
+class _BaseFinalizer(object):
+
+    # Set used to keep the proxy around.
+    # Deletion automatically removes proxies from the set.
+    _objects = set()
+
+    @classmethod
+    def track(cls, obj, ptr):
+        """
+        Track an object which needs destruction when it is garbage collected.
+        """
+        cls._objects.add(cls(obj, ptr))
+
+    def __init__(self, obj, ptr):
+        self.obj = proxy(obj, self.delete)
+        self.ptr = ptr
+
+    def delete(self, deadweakproxy):
+        type(self)._objects.remove(self)
+        self.destructor(deadweakproxy, self.ptr)
+
+
+# decode a path from glib
+if os.name == "nt":
+    def fsdecode(path):
+        return path.decode("utf-8")
+elif PY3:
+    _FSENC = sys.getfilesystemencoding()
+
+    def fsdecode(path):
+        return path.decode(_FSENC, "surrogateescape")
+else:
+    def fsdecode(path):
+        return path
+
+
+if os.name == "nt":
+    _so_mapping = {
+        "glib-2.0": "libglib-2.0-0.dll",
+        "gobject-2.0": "libgobject-2.0-0.dll",
+        "girepository-1.0": "libgirepository-1.0-1.dll",
+    }
+elif os.uname()[0] == "Darwin":
+    _so_mapping = {
+        "glib-2.0": "libglib-2.0.0.dylib",
+        "gobject-2.0": "libgobject-2.0.0.dylib",
+        "girepository-1.0": "libgirepository-1.0.1.dylib",
+    }
+else:
+    _so_mapping = {
+        "glib-2.0": "libglib-2.0.so.0",
+        "gobject-2.0": "libgobject-2.0.so.0",
+        "girepository-1.0": "libgirepository-1.0.so.1",
+    }
+
+
+if os.name == "nt":
+    stdlib = memcpy = cdll.msvcrt
+elif os.uname()[0] == "Darwin":
+    stdlib = getattr(cdll, "libc.dylib")
+else:
+    stdlib = getattr(cdll, "libc.so.6")
+
+memcpy = stdlib.memcpy
+memcpy.argtypes = [c_void_p, c_void_p, c_size_t]
+memcpy.restype = c_void_p
+
+_internal = {}
+
+
+def find_library(name, cached=True, internal=True):
+    """
+        cached: Return a new instance
+        internal: return a shared instance that's not the ctypes cached one
+    """
+
+    # a new one
+    if not cached:
+        return cdll.LoadLibrary(_so_mapping[name])
+
+    # from the shared internal set or a new one
+    if internal:
+        if name not in _internal:
+            _internal[name] = cdll.LoadLibrary(_so_mapping[name])
+        return _internal[name]
+
+    # a shared one
+    return getattr(cdll, _so_mapping[name])
+
+
+class _CProperty(object):
+    _cache = {}
+
+    def __init__(self, *args):
+        self.args = args
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+
+        lib, name, symbol, ret, args = self.args
+        assert len(args) == 1
+
+        func = self._cache.get((lib, symbol), None)
+        if func is None:
+            self._cache[(lib, symbol)] = func = getattr(lib, symbol)
+            func.argtypes = args
+            func.restype = ret
+
+        value = func(instance)
+
+        if PY3 and issubclass(ret, c_char_p) and value is not None:
+            value = value.decode("utf-8")
+
+        setattr(instance, name, value)
+        return value
+
+
+class _CMethod(object):
+    def __init__(self, *args):
+        self.args = args
+
+    def __get__(self, instance, *args):
+        owner, name, lib, symbol, ret, args, wrap, unref = self.args
+        func = getattr(lib, symbol)
+        func.argtypes = args
+        func.restype = ret
+
+        def unref_func(*x):
+            instance = func(*x)
+            instance._take_ownership()
+            return instance
+
+        if instance is None:
+            instance = owner
+
+        if wrap:
+            if unref:
+                setattr(owner, name, unref_func)
+            else:
+                setattr(owner, name, lambda *x: func(*x))
+            return getattr(instance, name)
+        else:
+            # FIXME: handle unref
+            assert not unref
+            setattr(owner, name, staticmethod(func))
+            return getattr(owner, name)
+
+
+def wrap_class(lib, base, ptr, prefix, methods):
+    for method in methods:
+        unref = False
+        if len(method) == 3:
+            name, ret, args = method
+        else:
+            name, ret, args, unref = method
+
+        # _get_name -> _name
+        # _get_version(*args) -> _get_version(*args)
+
+        attr_name = name
+        if name[:1] == "_":
+            name = name[1:]
+
+        symbol = prefix + name
+        is_method = args and args[0] == ptr
+        if is_method:
+            # Methods that have no arguments and return no pointer type
+            # can be getters and the values can be cached. hurray!
+            try:
+                is_pointer = hasattr(ret, "contents") or ret is c_void_p or \
+                    issubclass(ret, c_void_p)
+            except TypeError:
+                is_pointer = False
+            is_void = ret is None
+            if len(args) == 1 and not is_void and not is_pointer:
+                is_override = attr_name.startswith("_")
+                if name.startswith("get_"):
+                    attr_name = name.split("_", 1)[-1]
+                elif name.startswith("to_"):
+                    attr_name = name.split("_", 1)[-1]
+                if is_override:
+                    attr_name = "_" + attr_name
+                # e.g. conflict with ctypes "contents", "value" attribute
+                while hasattr(ptr, attr_name):
+                    attr_name += "_"
+                prop = _CProperty(lib, attr_name, symbol, ret, args)
+                setattr(ptr, attr_name, prop)
+            else:
+                method = _CMethod(
+                    ptr, attr_name, lib, symbol, ret, args, True, unref)
+                setattr(ptr, attr_name, method)
+        else:
+            if base is None:
+                base = ptr
+            static_method = _CMethod(
+                base, attr_name, lib, symbol, ret, args, False, unref)
+            setattr(base, attr_name, static_method)

package/.venv/lib/python3.9/site-packages/pgi/clib/gir/__init__.py

@@ -0,0 +1,71 @@
+# Copyright 2012 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from .giargument import GIArgument
+from .gibaseinfo import GIInfoType, GIBaseInfo, GIAttributeIter
+from .gicallableinfo import GICallableInfo, GIFunctionInfoFlags, \
+    GInvokeError, GIFunctionInfo, GIVFuncInfoFlags, GIVFuncInfo, \
+    GISignalInfo, GICallbackInfo
+from .giconstantinfo import GIConstantInfo
+from .gienuminfo import GIEnumInfo, GIValueInfo
+from .gifieldinfo import GIFieldInfo, GIFieldInfoFlags
+from .giinterfaceinfo import GIInterfaceInfo
+from .giobjectinfo import GIObjectInfo, GIObjectInfoGetValueFunction, \
+    GIObjectInfoRefFunction, GIObjectInfoSetValueFunction, \
+    GIObjectInfoUnrefFunction
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .girepository import GIRepositoryLoadFlags, GIRepository, \
+    GIRepositoryError
+from .gistructinfo import GIStructInfo
+from .gitypeinfo import GIArrayType, GITypeTag, GITypeInfo
+from .gitypelib import GITypelib
+from .giunioninfo import GIUnionInfo
+from .giarginfo import GITransfer, GIDirection, GIScopeType, GIArgInfo
+from .gipropertyinfo import GIPropertyInfo
+from .error import GIError
+
+
+# pyflakes
+GIArgInfo
+GIArgument
+GIArrayType
+GIAttributeIter
+GIBaseInfo
+GICallableInfo
+GICallbackInfo
+GIConstantInfo
+GIDirection
+GIEnumInfo
+GIError
+GIFieldInfo
+GIFieldInfoFlags
+GIFunctionInfo
+GIFunctionInfoFlags
+GIInfoType
+GIInterfaceInfo
+GInvokeError
+GIObjectInfo
+GIObjectInfoGetValueFunction
+GIObjectInfoRefFunction
+GIObjectInfoSetValueFunction
+GIObjectInfoUnrefFunction
+GIPropertyInfo
+GIRegisteredTypeInfo
+GIRepository
+GIRepositoryError
+GIRepositoryLoadFlags
+GIScopeType
+GISignalInfo
+GIStructInfo
+GITransfer
+GITypeInfo
+GITypelib
+GITypeTag
+GIUnionInfo
+GIValueInfo
+GIVFuncInfo
+GIVFuncInfoFlags

package/.venv/lib/python3.9/site-packages/pgi/clib/gir/error.py

@@ -0,0 +1,13 @@
+# Copyright 2014 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+
+from ..glib import GErrorError
+
+
+class GIError(GErrorError):
+    pass