@scrypted/server 0.0.138 → 0.0.139

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

@@ -0,0 +1,93 @@
+# Copyright 2012-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 pgi.clib.gir import GITypeTag
+from pgi.clib.glib import GErrorPtr
+from pgi.clib.gobject import GType
+from pgi.gerror import PGError
+from pgi.gtype import PGType
+
+from .utils import BaseType, registry
+
+
+@registry.register(GITypeTag.GTYPE)
+class GType_(BaseType):
+
+    def _check(self, name):
+        gtype_map = {
+            str: "gchararray",
+            int: "gint",
+            float: "gdouble",
+            bool: "gboolean",
+        }
+
+        items = gtype_map.items()
+        gtype_map = dict((k, PGType.from_name(v)) for (k, v) in items)
+
+        var = self.parse("""
+if not $_.isinstance($obj, $PGType):
+    if hasattr($obj, "__gtype__"):
+        $obj = $obj.__gtype__
+    elif $obj in $gtype_map:
+        $obj = $gtype_map[$obj]
+
+if not $_.isinstance($obj, $PGType):
+    raise TypeError("%r not a GType" % $obj)
+""", gtype_map=gtype_map, obj=name, PGType=PGType)
+
+        return var["obj"]
+
+    def pack_in(self, name):
+        checked = self._check(name)
+        var = self.parse("""
+$gtype = $GType($obj._type.value)
+""", obj=checked, GType=GType)
+
+        return var["gtype"]
+
+    pack_out = pack_in
+
+    def unpack_out(self, name):
+        var = self.parse("""
+$pgtype = $PGType($gtype)
+""", gtype=name, PGType=PGType)
+
+        return var["pgtype"]
+
+    unpack_return = unpack_out
+
+    def new(self):
+        var = self.parse("""
+$gtype = $GType()
+""", GType=GType)
+
+        return var["gtype"]
+
+
+@registry.register(GITypeTag.ERROR)
+class Error(BaseType):
+
+    def unpack(self, name, own=False):
+        var = self.parse("""
+if $gerror_ptr:
+    $out = $PGError._from_gerror($gerror_ptr, $own)
+else:
+    $out = $none
+""", gerror_ptr=name, PGError=PGError, none=None, own=own)
+
+        return var["out"]
+
+    def check_raise(self, name):
+        self.parse("""
+if $error:
+    raise $error
+""", error=name)
+
+    def new(self):
+        return self.parse("""
+$ptr = $gerror_ptr()
+""", gerror_ptr=GErrorPtr)["ptr"]

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

@@ -0,0 +1,168 @@
+# Copyright 2012-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 ctypes
+
+from pgi import _compat
+from pgi.clib import glib
+from pgi.clib.glib import gboolean, gpointer, guint, guint32, GErrorPtr, gint8
+from pgi.clib.glib import GSListPtr, GListPtr, gchar_p, gunichar, gdouble
+from pgi.clib.glib import gfloat, guint64, gint64, gint32, guint16, gint16
+from pgi.clib.glib import guint8
+from pgi.clib.gobject import GType
+from pgi.clib.gir import GITypeTag, GIInfoType
+from pgi.clib.gobject import GCallback
+
+from ..utils import CodeBlock, TypeTagRegistry
+
+
+class BaseType(object):
+    GI_TYPE_TAG = None
+    py_type = None
+
+    def __init__(self, gen, type_, desc, may_be_null, may_return_null):
+        self._gen = gen
+        self.block = CodeBlock()
+        self.type = type_
+        self.may_be_null = may_be_null
+        self.return_null = may_return_null
+        self.desc = desc
+
+    def get_type(self, type_, desc="", may_be_null=False,
+                 may_return_null=False):
+        try:
+            cls = registry.get_type(type_)
+        except LookupError as e:
+            raise NotImplementedError(e)
+        else:
+            return cls(self._gen, type_, desc, may_be_null, may_return_null)
+
+    def var(self):
+        return self._gen.var()
+
+    def __getattribute__(self, name):
+        try:
+            if _compat.PY3:
+                return object.__getattribute__(self, name + "_py3")
+            else:
+                return object.__getattribute__(self, name + "_py2")
+        except AttributeError:
+            return object.__getattribute__(self, name)
+
+    @classmethod
+    def get_class(cls, type_):
+        return cls
+
+    def parse(self, code, **kwargs):
+        assert "DESC" not in kwargs
+        kwargs["DESC"] = self.desc
+
+        block, var = self._gen.parse(code, **kwargs)
+        block.write_into(self.block)
+        return var
+
+    def get_reference(self, value):
+        return self.parse("""
+$ptr = $ctypes.byref($value)
+""", value=value)["ptr"]
+
+    def free(self, name):
+        self.parse("""
+$glib.free($ptr)
+""", ptr=name, glib=glib)
+
+    def pack_pointer(self, name):
+        """Returns a pointer containing the value.
+
+        This only works for int32/uint32/utf-8..
+        """
+
+        return self.parse("""
+raise $_.TypeError('Can\\'t convert %(type_name)s to pointer: %%r' %% $in_)
+""" % {"type_name": type(self).__name__}, in_=name)["in_"]
+
+
+registry = TypeTagRegistry()
+
+
+def register_type(type_tag):
+    return registry.register(type_tag)
+
+
+def typeinfo_to_ctypes(info, return_value=False):
+    """Maps a GITypeInfo() to a ctypes type.
+
+    The ctypes types have to be different in the case of return values
+    since ctypes does 'auto unboxing' in some cases which gives
+    us no chance to free memory if there is a ownership transfer.
+    """
+
+    tag = info.tag.value
+    ptr = info.is_pointer
+
+    mapping = {
+        GITypeTag.BOOLEAN: gboolean,
+        GITypeTag.INT8: gint8,
+        GITypeTag.UINT8: guint8,
+        GITypeTag.INT16: gint16,
+        GITypeTag.UINT16: guint16,
+        GITypeTag.INT32: gint32,
+        GITypeTag.UINT32: guint32,
+        GITypeTag.INT64: gint64,
+        GITypeTag.UINT64: guint64,
+        GITypeTag.FLOAT: gfloat,
+        GITypeTag.DOUBLE: gdouble,
+        GITypeTag.VOID: None,
+        GITypeTag.GTYPE: GType,
+        GITypeTag.UNICHAR: gunichar,
+    }
+
+    if ptr:
+        if tag == GITypeTag.INTERFACE:
+            return gpointer
+        elif tag in (GITypeTag.UTF8, GITypeTag.FILENAME):
+            if return_value:
+                # ctypes does auto conversion to str and gives us no chance
+                # to free the pointer if transfer=everything
+                return gpointer
+            else:
+                return gchar_p
+        elif tag == GITypeTag.ARRAY:
+            return gpointer
+        elif tag == GITypeTag.ERROR:
+            return GErrorPtr
+        elif tag == GITypeTag.GLIST:
+            return GListPtr
+        elif tag == GITypeTag.GSLIST:
+            return GSListPtr
+        else:
+            if tag in mapping:
+                return ctypes.POINTER(mapping[tag])
+    else:
+        if tag == GITypeTag.INTERFACE:
+            iface = info.get_interface()
+            iface_type = iface.type.value
+            if iface_type == GIInfoType.ENUM:
+                return guint32
+            elif iface_type == GIInfoType.OBJECT:
+                return gpointer
+            elif iface_type == GIInfoType.STRUCT:
+                return gpointer
+            elif iface_type == GIInfoType.UNION:
+                return gpointer
+            elif iface_type == GIInfoType.FLAGS:
+                return guint
+            elif iface_type == GIInfoType.CALLBACK:
+                return GCallback
+
+            raise NotImplementedError(
+                "Could not convert interface: %r to ctypes type" % iface.type)
+        else:
+            if tag in mapping:
+                return mapping[tag]
+
+    raise NotImplementedError("Could not convert %r to ctypes type" % info.tag)

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

@@ -0,0 +1,114 @@
+# 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 traceback
+
+from .fields import get_field_class
+from .backend import list_backends
+from .utils import CodeBlock
+
+
+def _generate_field_setter(info, info_type, backend):
+    backend.var.add_blacklist(["instance", "value", "pointer"])
+
+    cls = get_field_class(info_type)
+    f = cls(info, info_type, backend)
+    f.setup()
+
+    main = CodeBlock()
+    main.write_line("def setter(instance, value):")
+
+    if info.offset:
+        main.write_line("pointer = instance._obj + %d" % info.offset, 1)
+    else:
+        main.write_line("pointer = instance._obj", 1)
+
+    block, ptr = backend.cast_pointer("pointer", info_type)
+    block.write_into(main, 1)
+
+    block, var = f.set(ptr, "value")
+    if block:
+        block.write_into(main, 1)
+
+    block = backend.assign_pointer(ptr, var)
+    block.write_into(main, 1)
+
+    func = main.compile()["setter"]
+    func._code = main
+
+    return func
+
+
+def _generate_field_getter(info, info_type, backend):
+    cls = get_field_class(info_type)
+    f = cls(info, info_type, backend)
+    f.setup()
+
+    main = CodeBlock()
+    main.write_line("def getter(instance):")
+
+    if info.offset:
+        main.write_line("pointer = instance._obj + %d" % info.offset, 1)
+    else:
+        main.write_line("pointer = instance._obj", 1)
+
+    block, var = backend.cast_pointer("pointer", info_type)
+    block.write_into(main, 1)
+    block, var = backend.deref_pointer(var)
+    block.write_into(main, 1)
+
+    block, var = f.get(var)
+    if block:
+        block.write_into(main, 1)
+    main.write_line("return %s" % var, 1)
+    func = main.compile()["getter"]
+    func._code = main
+
+    return func
+
+
+def _generate_field_access(info, setter=True):
+    info_type = info.get_type()
+
+    func = None
+    messages = []
+    for backend in list_backends():
+        instance = backend()
+        try:
+            if setter:
+                func = _generate_field_setter(info, info_type, instance)
+            else:
+                func = _generate_field_getter(info, info_type, instance)
+        except NotImplementedError:
+            messages.append("%s: %s" % (backend.NAME, traceback.format_exc()))
+        else:
+            break
+
+    if func:
+        return func
+
+    raise NotImplementedError("\n".join(messages))
+
+
+def generate_field_getter(info):
+    return _generate_field_access(info, setter=False)
+
+
+def generate_field_setter(info):
+    return _generate_field_access(info, setter=True)
+
+
+def get_field_type(info):
+    """A field python type"""
+
+    type_ = info.get_type()
+
+    cls = get_field_class(type_)
+
+    field = cls(info, type_, None)
+    field.setup()
+    return field.py_type

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

@@ -0,0 +1,244 @@
+# 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 pgi.clib.gir import GIInfoType, GITypeTag
+from pgi.gtype import PGType
+from pgi.util import import_attribute
+from pgi.gerror import PGError
+
+
+class Field(object):
+    TAG = None
+    py_type = None
+
+    def __init__(self, info, type, backend):
+        self.backend = backend
+        self.info = info
+        self.type = type
+
+    @classmethod
+    def get_class(cls, type_):
+        return cls
+
+    def setup(self):
+        pass
+
+    def get(self, name):
+        raise NotImplementedError("no getter implemented")
+
+    def set(self, name, value_name):
+        raise NotImplementedError("no setter implemented")
+
+    def get_param_type(self, index):
+        """Returns a ReturnValue instance for param type 'index'"""
+
+        assert index in (0, 1)
+
+        type_info = self.type.get_param_type(index)
+        type_cls = get_field_class(type_info)
+        instance = type_cls(self.backend, type_info, None)
+        instance.setup()
+        return instance
+
+
+class InterfaceField(Field):
+    TAG = GITypeTag.INTERFACE
+    py_type = object
+
+    def setup(self):
+        iface = self.type.get_interface()
+        try:
+            self.py_type = import_attribute(iface.namespace, iface.name)
+        except ImportError:
+            # fall back to object
+            pass
+
+    def get(self, name):
+        var = self.backend.get_type(self.type)
+        iface = self.type.get_interface()
+        iface_type = iface.type.value
+
+        if iface_type == GIInfoType.ENUM:
+            out = var.unpack_out(name)
+            return var.block, out
+        elif iface_type == GIInfoType.STRUCT:
+            out = var.unpack_out(name)
+            return var.block, out
+        elif iface_type == GIInfoType.OBJECT:
+            out = var.unpack_out(name)
+            return var.block, out
+        elif iface_type == GIInfoType.FLAGS:
+            out = var.unpack_out(name)
+            return var.block, out
+
+        raise NotImplementedError(
+            "interface type not supported: %r" % iface.type)
+
+
+class ErrorField(Field):
+    TAG = GITypeTag.ERROR
+    py_type = PGError
+
+
+class TypeField(Field):
+    TAG = GITypeTag.GTYPE
+    py_type = PGType
+
+    def get(self, name):
+        var = self.backend.get_type(self.type)
+        out = var.unpack_out(name)
+        return var.block, out
+
+
+class GHashField(Field):
+    TAG = GITypeTag.GHASH
+    py_type = dict
+
+    def setup(self):
+        self.py_type = {
+            self.get_param_type(0).py_type: self.get_param_type(1).py_type}
+
+
+class BasicField(Field):
+
+    def get(self, name):
+        var = self.backend.get_type(self.type)
+        out = var.unpack_out(name)
+        return var.block, out
+
+    def set(self, name, value_name):
+        var = self.backend.get_type(self.type)
+        out = var.pack_out(value_name)
+        return var.block, out
+
+
+class DoubleField(BasicField):
+    TAG = GITypeTag.DOUBLE
+    py_type = float
+
+
+class UInt32Field(BasicField):
+    TAG = GITypeTag.UINT32
+    py_type = int
+
+
+class UInt8Field(BasicField):
+    TAG = GITypeTag.UINT8
+    py_type = int
+
+
+class Int32Field(BasicField):
+    TAG = GITypeTag.INT32
+    py_type = int
+
+
+class Int64Field(BasicField):
+    TAG = GITypeTag.INT64
+    py_type = int
+
+
+class UInt64Field(BasicField):
+    TAG = GITypeTag.UINT64
+    py_type = int
+
+
+class UInt16Field(BasicField):
+    TAG = GITypeTag.UINT16
+    py_type = int
+
+
+class Int8Field(BasicField):
+    TAG = GITypeTag.INT8
+    py_type = int
+
+
+class Int16Field(BasicField):
+    TAG = GITypeTag.INT16
+    py_type = int
+
+
+class FloatField(BasicField):
+    TAG = GITypeTag.FLOAT
+    py_type = float
+
+
+class UniCharField(BasicField):
+    TAG = GITypeTag.UNICHAR
+    py_type = str
+
+
+class BooleanField(BasicField):
+    TAG = GITypeTag.BOOLEAN
+    py_type = bool
+
+
+class ArrayField(Field):
+    TAG = GITypeTag.ARRAY
+    py_type = list
+
+    def setup(self):
+        elm_type = self.get_param_type(0)
+        if isinstance(elm_type, UInt8Field):
+            self.py_type = "bytes"
+        else:
+            self.py_type = [elm_type.py_type]
+
+    def get(self, name):
+        var = self.backend.get_type(self.type)
+        out = var.unpack(name, None)
+        return var.block, out
+
+    def set(self, name, value_name):
+        raise NotImplementedError("Array setters are not implemented")
+
+
+class Utf8Field(BasicField):
+    TAG = GITypeTag.UTF8
+    py_type = str
+
+
+class VoidField(BasicField):
+    TAG = GITypeTag.VOID
+    py_type = object
+
+
+class GSListField(Field):
+    TAG = GITypeTag.GSLIST
+    py_type = list
+
+    def setup(self):
+        self.py_type = [self.get_param_type(0).py_type]
+
+
+class GListField(Field):
+    TAG = GITypeTag.GLIST
+    py_type = list
+
+    def setup(self):
+        self.py_type = [self.get_param_type(0).py_type]
+
+
+_classes = {}
+
+
+def _find_fields():
+    global _classes
+    cls = [a for a in globals().values() if isinstance(a, type)]
+    args = [a for a in cls if issubclass(a, Field) and a is not Field]
+    _classes = dict(((a.TAG, a) for a in args))
+_find_fields()
+
+
+def get_field_class(arg_type):
+    global _classes
+    tag_value = arg_type.tag.value
+    try:
+        cls = _classes[tag_value]
+    except KeyError:
+        raise NotImplementedError("%r not supported" % arg_type.tag)
+    else:
+        return cls.get_class(arg_type)