@scrypted/server 0.0.134 → 0.0.139

package/.venv/lib/python3.9/site-packages/pgi/codegen/utils.py

@@ -0,0 +1,248 @@
+# 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.
+
+import sys
+import string
+import collections
+
+from pgi import _compat
+
+
+class TypeTagRegistry(dict):
+
+    def register(self, type_tag):
+        def wrap(cls):
+            assert type_tag not in self
+            self[type_tag] = cls
+            return cls
+        return wrap
+
+    def get_type(self, type_):
+        tag_value = type_.tag.value
+        if tag_value in self:
+            return self[tag_value].get_class(type_)
+        raise LookupError("type: %r", type_.tag)
+
+
+class VariableFactory(object):
+    """A callable the produces unique variable names"""
+
+    def __init__(self, blacklist=None):
+        self._count = 0
+        self._blacklist = set()
+        self._obj_cache = {}
+        if blacklist:
+            self.add_blacklist(blacklist)
+
+    def add_blacklist(self, seq):
+        """seq is a sequence of names to reserve"""
+
+        self._blacklist.update(seq)
+
+    def __call__(self, *args):
+        """Get a random new name, pass an obj to get a cached one"""
+
+        if not args:
+            self._count += 1
+            res = "t%d" % self._count
+        else:
+            obj = args[0]
+            try:
+                # use id so this works for non hashable types
+                return self._obj_cache[id(obj)][0]
+            except KeyError:
+                self._count += 1
+                res = "e%d" % self._count
+                # keep obj alive, so id() is unique
+                self._obj_cache[id(obj)] = (res, obj)
+
+        while res in self._blacklist:
+            res += "_"
+        self._blacklist.add(res)
+        return res
+
+    def request_name(self, name):
+        """Request a name, might return the name or a similar one if already
+        used or reserved
+        """
+
+        while name in self._blacklist:
+            name += "_"
+        self._blacklist.add(name)
+        return name
+
+
+class CodeBlock(object):
+    """A piece of code with global dependencies"""
+
+    INDENTATION = 4
+
+    def __init__(self, line=None):
+        super(CodeBlock, self).__init__()
+        self._lines = []
+        self._deps = {}
+        if line:
+            self.write_line(line)
+
+    def get_dependencies(self):
+        return self._deps
+
+    def add_dependency(self, name, obj):
+        """Add a code dependency so it gets inserted into globals"""
+
+        if name in self._deps:
+            if self._deps[name] is obj:
+                return
+            raise ValueError(
+                "There exists a different dep with the same name : %r" % name)
+        self._deps[name] = obj
+
+    def write_into(self, block, level=0):
+        """Append this block to another one, passing all dependencies"""
+
+        for line, l in self._lines:
+            block.write_line(line, level + l)
+
+        for name, obj in _compat.iteritems(self._deps):
+            block.add_dependency(name, obj)
+
+    def write_line(self, line, level=0):
+        """Append a new line"""
+
+        self._lines.append((line, level))
+
+    def write_lines(self, lines, level=0):
+        """Append multiple new lines"""
+
+        for line in lines:
+            self.write_line(line, level)
+
+    def compile(self, **kwargs):
+        """Execute the python code and returns the global dict.
+        kwargs can contain extra dependencies that get only used
+        at compile time.
+        """
+
+        code = compile(str(self), "<string>", "exec")
+        global_dict = dict(self._deps)
+        global_dict.update(kwargs)
+        _compat.exec_(code, global_dict)
+        return global_dict
+
+    def pprint(self, file_=sys.stdout):
+        """Print the code block to stdout.
+        Does syntax highlighting if possible.
+        """
+
+        code = []
+        if self._deps:
+            code.append("# dependencies:")
+        for k, v in _compat.iteritems(self._deps):
+            code.append("#   %s: %r" % (k, v))
+        code.append(str(self))
+        code = "\n".join(code)
+
+        if file_.isatty():
+            try:
+                from pygments import highlight
+                from pygments.lexers import PythonLexer
+                from pygments.formatters import TerminalFormatter
+            except ImportError:
+                pass
+            else:
+                formatter = TerminalFormatter(bg="dark")
+                lexer = PythonLexer()
+                file_.write(highlight(code, lexer, formatter))
+                return
+        file_.write(code + "\n")
+
+    def clear(self):
+        del self._lines[:]
+        self._deps.clear()
+
+    def __str__(self):
+        lines = []
+        for line, level in self._lines:
+            lines.append(" " * self.INDENTATION * level + line)
+        return "\n".join(lines)
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        deps = ",".join(self._deps.keys())
+        return "<%s lines=%d, deps=%r>" % (name, len(self._deps), deps)
+
+
+def parse_code(code, var_factory, **kwargs):
+    """Parse a piece of text and substitude $var by either unique
+    variable names or by the given kwargs mapping. Use $$ to escape $.
+
+    Returns a CodeBlock and the resulting variable mapping.
+
+    parse("$foo = $foo + $bar", bar="1")
+    ("t1 = t1 + 1", {'foo': 't1', 'bar': '1'})
+    """
+
+    block = CodeBlock()
+    defdict = collections.defaultdict(var_factory)
+    defdict.update(kwargs)
+
+    indent = -1
+    code = code.strip()
+    for line in code.splitlines():
+        length = len(line)
+        line = line.lstrip()
+        spaces = length - len(line)
+        if spaces:
+            if indent < 0:
+                indent = spaces
+                level = 1
+            else:
+                level = spaces // indent
+        else:
+            level = 0
+
+        # if there is a single variable and the to be inserted object
+        # is a code block, insert the block with the current indentation level
+        if line.startswith("$") and line.count("$") == 1:
+            name = line[1:]
+            if name in kwargs and isinstance(kwargs[name], CodeBlock):
+                kwargs[name].write_into(block, level)
+                continue
+
+        block.write_line(string.Template(line).substitute(defdict), level)
+    return block, dict(defdict)
+
+
+def parse_with_objects(code, var, **kwargs):
+    """Parse code and include non string/codeblock kwargs as
+    dependencies.
+
+    int/long will be inlined.
+
+    Returns a CodeBlock and the resulting variable mapping.
+    """
+
+    deps = {}
+    for key, value in kwargs.items():
+        if isinstance(value, _compat.integer_types):
+            value = str(value)
+
+        if _compat.PY3:
+            if value is None:
+                value = str(value)
+
+        if not isinstance(value, _compat.string_types) and \
+                not isinstance(value, CodeBlock):
+            new_var = var(value)
+            deps[new_var] = value
+            kwargs[key] = new_var
+
+    block, var = parse_code(code, var, **kwargs)
+    for key, dep in _compat.iteritems(deps):
+        block.add_dependency(key, dep)
+
+    return block, var

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

@@ -0,0 +1,9 @@
+# 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.
+
+VERSION = (0, 0, 11, 2)
+PREFIX = ["pgi.repository"]

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

@@ -0,0 +1,32 @@
+# 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 ctypes import byref
+
+from .clib.gir import GIArgument
+
+
+_union_access = [None, "v_boolean", "v_int8", "v_uint8", "v_int16",
+                 "v_uint16", "v_int32", "v_uint32", "v_int64", "v_uint64",
+                 "v_float", "v_double", None, "v_string", "v_string",
+                 None, None, None, None, None, None, None]
+
+
+def ConstantAttribute(info):
+    arg = GIArgument()
+    info.get_value(byref(arg))
+
+    const_type = info.get_type()
+    tag_type = const_type.tag.value
+
+    value_member = _union_access[tag_type]
+    if not value_member:
+        raise NotImplementedError("Not supported const type: %r", tag_type)
+    else:
+        value = getattr(arg, value_member)
+
+    return value

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

@@ -0,0 +1,31 @@
+# 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.
+
+import sys
+
+
+def pprint(obj, file_=None):
+    """Prints debug information for various public objects like methods,
+    functions, constructors etc.
+    """
+
+    if file_ is None:
+        file_ = sys.stdout
+
+    # functions, methods
+    if callable(obj) and hasattr(obj, "_code"):
+        obj._code.pprint(file_)
+        return
+
+    # classes
+    if isinstance(obj, type) and hasattr(obj, "_constructors"):
+        constructors = obj._constructors
+        for names, func in sorted(constructors.items()):
+            func._code.pprint(file_)
+        return
+
+    raise TypeError("unkown type")

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

@@ -0,0 +1,244 @@
+# 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.
+
+import sys
+import ctypes
+
+from .clib.gobject import GEnumClassPtr, GFlagsClassPtr, GType
+from .clib.glib import gint
+from .gtype import PGType
+from .util import cached_property, escape_identifier, decode_return, \
+    decode_return_list
+from .obj import add_method
+from ._compat import integer_types
+
+
+class EnumBase(int):
+    """Base type for all enum types
+
+    :param value:
+    :type value: :obj:`int`
+    """
+
+    _allowed = {}
+
+    def __init__(self, value):
+        super(EnumBase, self).__init__()
+
+    def __new__(cls, value):
+        if not isinstance(value, integer_types):
+            raise TypeError("int expected, got %r instead" % type(value))
+        if value > sys.maxsize:
+            raise OverflowError
+        instance = int.__new__(cls, value)
+        if value in cls._allowed:
+            return instance
+        raise ValueError("invalid enum value: %r", value)
+
+    def __repr__(self):
+        return "<enum %s of type %s>" % (self._allowed[self],
+                                         self.__class__.__name__)
+
+    __str__ = __repr__
+
+
+EnumBase.__name__ = "Enum"
+EnumBase.__module__ = "GLib"
+
+
+class GEnumBase(EnumBase):
+    """Base type for all enum types with a GType
+
+    :param value:
+    :type value: :obj:`int`
+    """
+
+    __gtype__ = PGType.from_name("GEnum")
+
+    def __get_enum_value(self):
+        gtype = self.__gtype__._type
+        klass = ctypes.cast(gtype.class_ref(), GEnumClassPtr)
+        return klass.get_value(self).contents
+
+    @cached_property
+    @decode_return()
+    def value_nick(self):
+        enum_value = self.__get_enum_value()
+        return enum_value.value_nick
+
+    @cached_property
+    @decode_return()
+    def value_name(self):
+        enum_value = self.__get_enum_value()
+        return enum_value.value_name
+
+
+GEnumBase.__name__ = "GEnum"
+GEnumBase.__module__ = "GObject"
+
+
+class FlagsBase(int):
+    """Base type for all flags types
+
+    :param value:
+    :type value: :obj:`int`
+    """
+
+    _flags = []
+
+    def __init__(self, value):
+        super(FlagsBase, self).__init__()
+
+    def __new__(cls, value):
+        if not isinstance(value, integer_types):
+            raise TypeError("int expected, got %r instead" % type(value))
+        if value > sys.maxsize:
+            raise OverflowError
+        return int.__new__(cls, value)
+
+    def __repr__(self):
+        names = []
+        for (num, vname) in self._flags:
+            if not self and not num:
+                names.append(vname)
+                break
+            if self & num:
+                names.append(vname)
+
+        names = " | ".join(names) or "0"
+        return "<flags %s of type %s>" % (names, self.__class__.__name__)
+
+    __str__ = __repr__
+
+    def __or__(self, other):
+        return type(self)(int(self) | other)
+
+    def __and__(self, other):
+        return type(self)(int(self) & other)
+
+
+FlagsBase.__name__ = "Flags"
+FlagsBase.__module__ = "GLib"
+
+
+class GFlagsBase(FlagsBase):
+    """Base type for all flags types with a GType
+
+    :param value:
+    :type value: :obj:`int`
+    """
+
+    __gtype__ = PGType.from_name("GFlags")
+
+    def __get_flags_value(self, value):
+        gtype = self.__gtype__._type
+        klass = ctypes.cast(gtype.class_ref(), GFlagsClassPtr)
+        value_ptr = klass.get_first_value(value)
+        if not value_ptr:
+            return
+        return value_ptr.contents
+
+    def __get_flag_values(self):
+        values = []
+        for (num, vname) in self._flags:
+            masked = self & num
+            if not masked:
+                continue
+            value = self.__get_flags_value(masked)
+            if value:
+                values.append(value)
+        return values
+
+    @cached_property
+    @decode_return_list()
+    def value_nicks(self):
+        return [v.value_nick for v in self.__get_flag_values()]
+
+    @property
+    def first_value_nick(self):
+        return (self.value_nicks and self.value_nicks[0]) or None
+
+    @cached_property
+    @decode_return_list()
+    def value_names(self):
+        return [v.value_name for v in self.__get_flag_values()]
+
+    @property
+    def first_value_name(self):
+        return (self.value_names and self.value_names[0]) or None
+
+GFlagsBase.__name__ = "GFlags"
+GFlagsBase.__module__ = "GObject"
+
+
+def _get_values(enum):
+    values = []
+
+    for value in enum.get_values():
+        num = gint(value.value_).value
+        vname = value.name.upper()
+        values.append((num, vname))
+
+    return values
+
+
+def FlagsAttribute(info):
+    if info.g_type.value != GType.from_name(b"void").value:
+        gtype = PGType(info.g_type)
+        base = GFlagsBase
+    else:
+        gtype = None
+        base = FlagsBase
+
+    cls = type(info.name, (base,), dict())
+    cls.__module__ = info.namespace
+    if gtype is not None:
+        cls.__gtype__ = gtype
+
+    values = _get_values(info)
+    cls._flags = values
+
+    # create instances for all of them and add to the class
+    for num, vname in values:
+        escaped = escape_identifier(vname)
+        obj = cls(num)
+        if escaped != vname:
+            setattr(cls, escaped, obj)
+        setattr(cls, vname, obj)
+
+    return cls
+
+
+def EnumAttribute(info):
+
+    if info.g_type.value != GType.from_name(b"void").value:
+        gtype = PGType(info.g_type)
+        base = GEnumBase
+    else:
+        gtype = None
+        base = EnumBase
+
+    cls = type(info.name, (base,), dict())
+    cls.__module__ = info.namespace
+
+    values = _get_values(info)
+    cls._allowed = dict(values)
+    if gtype is not None:
+        cls.__gtype__ = gtype
+
+    for method in info.get_methods():
+        add_method(method, cls)
+
+    # create instances for all of them and add to the class
+    for num, vname in values:
+        escaped = escape_identifier(vname)
+        obj = cls(num)
+        if escaped != vname:
+            setattr(cls, escaped, obj)
+        setattr(cls, vname, obj)
+
+    return cls

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

@@ -0,0 +1,58 @@
+# 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 .codegen import generate_field_getter, generate_field_setter
+from .codegen import get_field_type
+from .clib.gir import GIFieldInfoFlags
+from .util import cached_property
+
+
+class FieldAttribute(object):
+    _getter = None
+    _setter = None
+
+    def __init__(self, name, info):
+        self._info = info
+        self.name = name
+
+    @cached_property
+    def writeable(self):
+        return self._info.flags.value & GIFieldInfoFlags.IS_WRITABLE
+
+    @cached_property
+    def readable(self):
+        return self._info.flags.value & GIFieldInfoFlags.IS_READABLE
+
+    @cached_property
+    def py_type(self):
+        return get_field_type(self._info)
+
+    def __get__(self, instance, owner):
+        # make sure we support the type, raises NotImplementedError otherwise
+        self.py_type
+
+        if not instance:
+            return self
+
+        if not self.readable:
+            raise AttributeError("Field %r not readable" % self.name)
+
+        if not self._getter:
+            self._getter = generate_field_getter(self._info)
+
+        if instance:
+            return self._getter(instance)
+        return self
+
+    def __set__(self, instance, value):
+        if not self.writeable:
+            raise AttributeError("Field %r not writeable" % self.name)
+
+        if not self._setter:
+            self._setter = generate_field_setter(self._info)
+
+        self._setter(instance, value)

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

@@ -0,0 +1,3 @@
+from .clib._utils import _BaseFinalizer
+
+_BaseFinalizer

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

@@ -0,0 +1,71 @@
+# 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.
+
+"""Foreign structs make it possible for gi to interact with other python
+libraries. For example it allows functions to take cairo structs created
+with cairocffi.
+"""
+
+import importlib
+
+from ._base import ForeignStruct, ForeignError
+
+
+_MODULES = {}
+
+
+def get_foreign_module(namespace):
+    """Returns the module or raises ForeignError"""
+
+    if namespace not in _MODULES:
+        try:
+            module = importlib.import_module("." + namespace, __package__)
+        except ImportError:
+            module = None
+        _MODULES[namespace] = module
+
+    module = _MODULES.get(namespace)
+    if module is None:
+        raise ForeignError("Foreign %r structs not supported" % namespace)
+    return module
+
+
+def get_foreign_struct(namespace, name):
+    """Returns a ForeignStruct implementation or raises ForeignError"""
+
+    get_foreign_module(namespace)
+
+    try:
+        return ForeignStruct.get(namespace, name)
+    except KeyError:
+        raise ForeignError("Foreign %s.%s not supported" % (namespace, name))
+
+
+def require_foreign(namespace, symbol=None):
+    """Raises ImportError if the specified foreign module isn't supported or
+    the needed dependencies aren't installed.
+
+    e.g.: check_foreign('cairo', 'Context')
+    """
+
+    
+    try:
+        if symbol is None:
+            get_foreign_module(namespace)
+        else:
+            get_foreign_struct(namespace, symbol)
+    except ForeignError as e:
+        raise ImportError(e)
+
+
+def get_foreign(namespace, name):
+    """Returns a ForeignStruct instance or None"""
+
+    try:
+        return get_foreign_struct(namespace, name)
+    except ForeignError:
+        return None