@scrypted/server 0.0.141 → 0.0.142

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

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

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

@@ -1,114 +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.
-
-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

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