@scrypted/server 0.0.140 → 0.0.144

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

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

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

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

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

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

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

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

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

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