@scrypted/server 0.0.135 → 0.0.140

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

@@ -0,0 +1,83 @@
+# 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 .._compat import xrange
+from ..glib import gint, gchar_p
+from .gibaseinfo import GIInfoType, GIBaseInfo
+from .gipropertyinfo import GIPropertyInfo
+from .gicallableinfo import GIFunctionInfo, GISignalInfo, GIVFuncInfo
+from .giconstantinfo import GIConstantInfo
+from .gistructinfo import GIStructInfo
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+@GIBaseInfo._register(GIInfoType.INTERFACE)
+class GIInterfaceInfo(GIRegisteredTypeInfo):
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+    def get_properties(self):
+        for i in xrange(self.n_properties):
+            yield self.get_property(i)
+
+    def get_signals(self):
+        for i in xrange(self.n_signals):
+            yield self.get_signal(i)
+
+    def get_constants(self):
+        for i in xrange(self.n_constants):
+            yield self.get_constant(i)
+
+    def get_vfuncs(self):
+        for i in xrange(self.n_vfuncs):
+            yield self.get_vfunc(i)
+
+    def get_prerequisite(self, i):
+        res = self._get_prerequisite(i)
+        return GIBaseInfo._cast(res)
+
+    def get_prerequisites(self):
+        for i in xrange(self.n_prerequisites):
+            yield self.get_prerequisite(i)
+
+    def _get_repr(self):
+        values = super(GIInterfaceInfo, self)._get_repr()
+        values["n_constants"] = repr(self.n_constants)
+        values["n_signals"] = repr(self.n_signals)
+        values["n_methods"] = repr(self.n_methods)
+        values["n_properties"] = repr(self.n_properties)
+        values["n_prerequisites"] = repr(self.n_prerequisites)
+        return values
+
+_methods = [
+    ("get_n_prerequisites", gint, [GIInterfaceInfo]),
+    ("_get_prerequisite", GIBaseInfo, [GIInterfaceInfo, gint]),
+    ("get_n_properties", gint, [GIInterfaceInfo]),
+    ("get_property", GIPropertyInfo, [GIInterfaceInfo, gint], True),
+    ("get_n_methods", gint, [GIInterfaceInfo]),
+    ("get_method", GIFunctionInfo, [GIInterfaceInfo, gint], True),
+    ("find_method", GIFunctionInfo, [GIInterfaceInfo, gchar_p], True),
+    ("get_n_signals", gint, [GIInterfaceInfo]),
+    ("get_signal", GISignalInfo, [GIInterfaceInfo, gint], True),
+    ("find_signal", GISignalInfo, [GIInterfaceInfo, gchar_p], True),
+    ("get_n_vfuncs", gint, [GIInterfaceInfo]),
+    ("get_vfunc", GIVFuncInfo, [GIInterfaceInfo, gint], True),
+    ("get_n_constants", gint, [GIInterfaceInfo]),
+    ("get_constant", GIConstantInfo, [GIInterfaceInfo, gint], True),
+    ("get_iface_struct", GIStructInfo, [GIInterfaceInfo], True),
+    ("find_vfunc", GIVFuncInfo, [GIInterfaceInfo, gchar_p], True),
+]
+
+wrap_class(_gir, GIInterfaceInfo, GIInterfaceInfo,
+           "g_interface_info_", _methods)
+
+__all__ = ["GIInterfaceInfo"]

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

@@ -0,0 +1,134 @@
+# 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 c_char_p, CFUNCTYPE, c_void_p
+
+from .._compat import xrange
+from ..glib import gchar_p, gboolean, gint
+from ..gobject import GValuePtr
+from .gibaseinfo import GIInfoType, GIBaseInfo
+from .giinterfaceinfo import GIInterfaceInfo
+from .gifieldinfo import GIFieldInfo
+from .gipropertyinfo import GIPropertyInfo
+from .gicallableinfo import GIFunctionInfo, GISignalInfo, GIVFuncInfo
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .giconstantinfo import GIConstantInfo
+from .gistructinfo import GIStructInfo
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+@GIBaseInfo._register(GIInfoType.OBJECT)
+class GIObjectInfo(GIRegisteredTypeInfo):
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+    def get_interfaces(self):
+        for i in xrange(self.n_interfaces):
+            yield self.get_interface(i)
+
+    def get_properties(self):
+        for i in xrange(self.n_properties):
+            yield self.get_property(i)
+
+    def get_signals(self):
+        for i in xrange(self.n_signals):
+            yield self.get_signal(i)
+
+    def get_vfuncs(self):
+        for i in xrange(self.n_vfuncs):
+            yield self.get_vfunc(i)
+
+    def get_fields(self):
+        for i in xrange(self.n_fields):
+            yield self.get_field(i)
+
+    def get_constants(self):
+        for i in xrange(self.n_constants):
+            yield self.get_constant(i)
+
+    def _get_repr(self):
+        values = super(GIObjectInfo, self)._get_repr()
+        values["type_name"] = repr(self.type_name)
+        values["type_init"] = repr(self.type_init)
+        values["abstract"] = repr(self.abstract)
+        values["fundamental"] = repr(self.fundamental)
+        parent = self.get_parent()
+        if parent:
+            values["parent"] = repr(parent.name)
+        values["n_interfaces"] = repr(self.n_interfaces)
+        values["n_fields"] = repr(self.n_fields)
+        values["n_properties"] = repr(self.n_properties)
+        values["n_methods"] = repr(self.n_methods)
+        values["n_signals"] = repr(self.n_signals)
+        values["n_vfuncs"] = repr(self.n_vfuncs)
+        values["class_struct"] = repr(self.get_class_struct().name)
+        unref_function = self.unref_function
+        if unref_function:
+            values["unref_function"] = repr(unref_function)
+        ref_function = self.ref_function
+        if ref_function:
+            values["ref_function"] = repr(ref_function)
+        set_value_function = self.set_value_function
+        if set_value_function:
+            values["set_value_function"] = repr(set_value_function)
+        get_value_function = self.get_value_function
+        if get_value_function:
+            values["get_value_function"] = repr(get_value_function)
+        return values
+
+
+GIObjectInfoGetValueFunction = CFUNCTYPE(c_void_p, GValuePtr)
+GIObjectInfoRefFunction = CFUNCTYPE(c_void_p, c_void_p)
+GIObjectInfoSetValueFunction = CFUNCTYPE(None, GValuePtr, c_void_p)
+GIObjectInfoUnrefFunction = CFUNCTYPE(None, c_void_p)
+
+_methods = [
+    ("get_type_name", gchar_p, [GIObjectInfo]),
+    ("get_type_init", gchar_p, [GIObjectInfo]),
+    ("get_abstract", gboolean, [GIObjectInfo]),
+    ("get_fundamental", gboolean, [GIObjectInfo]),
+    ("get_parent", GIObjectInfo, [GIObjectInfo], True),
+    ("get_n_interfaces", gint, [GIObjectInfo]),
+    ("get_interface", GIInterfaceInfo, [GIObjectInfo, gint], True),
+    ("get_n_fields", gint, [GIObjectInfo]),
+    ("get_field", GIFieldInfo, [GIObjectInfo, gint], True),
+    ("get_n_properties", gint, [GIObjectInfo]),
+    ("get_property", GIPropertyInfo, [GIObjectInfo, gint], True),
+    ("get_n_methods", gint, [GIObjectInfo]),
+    ("get_method", GIFunctionInfo, [GIObjectInfo, gint], True),
+    ("find_method", GIFunctionInfo, [GIObjectInfo, gchar_p], True),
+    ("get_n_signals", gint, [GIObjectInfo]),
+    ("get_signal", GISignalInfo, [GIObjectInfo, gint], True),
+    ("find_signal", GISignalInfo, [GIObjectInfo, gchar_p], True),
+    ("get_n_vfuncs", gint, [GIObjectInfo]),
+    ("get_vfunc", GIVFuncInfo, [GIObjectInfo, gint], True),
+    ("get_n_constants", gint, [GIObjectInfo]),
+    ("get_constant", GIConstantInfo, [GIObjectInfo, gint], True),
+    ("get_class_struct", GIStructInfo, [GIObjectInfo], True),
+    ("find_vfunc", GIVFuncInfo, [GIObjectInfo, gchar_p], True),
+    ("get_unref_function", c_char_p, [GIObjectInfo]),
+    ("get_unref_function_pointer", GIObjectInfoUnrefFunction,
+        [GIObjectInfo]),
+    ("get_ref_function", c_char_p, [GIObjectInfo]),
+    ("get_ref_function_pointer", GIObjectInfoRefFunction, [GIObjectInfo]),
+    ("get_set_value_function", c_char_p, [GIObjectInfo]),
+    ("get_set_value_function_pointer", GIObjectInfoSetValueFunction,
+        [GIObjectInfo]),
+    ("get_get_value_function", c_char_p, [GIObjectInfo]),
+    ("get_get_value_function_pointer", GIObjectInfoGetValueFunction,
+        [GIObjectInfo]),
+]
+
+wrap_class(_gir, GIObjectInfo, GIObjectInfo, "g_object_info_", _methods)
+
+__all__ = ["GIObjectInfo",
+           "GIObjectInfoGetValueFunction", "GIObjectInfoRefFunction",
+           "GIObjectInfoSetValueFunction", "GIObjectInfoUnrefFunction"]

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

@@ -0,0 +1,36 @@
+# 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 ..gobject import GParamFlags
+from .gibaseinfo import GIBaseInfo
+from .gitypeinfo import GITypeInfo, GIInfoType
+from .giarginfo import GITransfer
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+@GIBaseInfo._register(GIInfoType.PROPERTY)
+class GIPropertyInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GIPropertyInfo, self)._get_repr()
+        values["flags"] = repr(self.flags)
+        values["type"] = repr(self.get_type())
+        values["ownership_transfer"] = repr(self.ownership_transfer)
+        return values
+
+_methods = [
+    ("get_flags", GParamFlags, [GIPropertyInfo]),
+    ("get_type", GITypeInfo, [GIPropertyInfo], True),
+    ("get_ownership_transfer", GITransfer, [GIPropertyInfo]),
+]
+
+wrap_class(_gir, GIPropertyInfo, GIPropertyInfo,
+           "g_property_info_", _methods)
+
+__all__ = ["GIPropertyInfo"]

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

@@ -0,0 +1,34 @@
+# 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 ..glib import gchar_p
+from ..gobject import GType
+from .gibaseinfo import GIBaseInfo
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+class GIRegisteredTypeInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GIRegisteredTypeInfo, self)._get_repr()
+        values["type_name"] = repr(self.type_name)
+        values["type_init"] = repr(self.type_init)
+        values["g_type"] = repr(self.g_type)
+        return values
+
+_methods = [
+    ("get_type_name", gchar_p, [GIRegisteredTypeInfo]),
+    ("get_type_init", gchar_p, [GIRegisteredTypeInfo]),
+    ("get_g_type", GType, [GIRegisteredTypeInfo]),
+]
+
+wrap_class(_gir, GIRegisteredTypeInfo, GIRegisteredTypeInfo,
+           "g_registered_type_info_", _methods)
+
+__all__ = ["GIRegisteredTypeInfo"]

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

@@ -0,0 +1,200 @@
+# 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 POINTER, c_char_p, c_void_p
+
+from ..glib import guint, gchar_p, GErrorPtr, gboolean, gint, unpack_glist
+from ..glib import GSListPtr, GOptionGroupPtr, GListPtr, gerror
+from ..glib import unpack_nullterm_array
+from ..gobject import GType
+from .gibaseinfo import GIBaseInfo
+from .gitypelib import GITypelib
+from .error import GIError
+from .._utils import find_library, wrap_class, fsdecode
+from .._compat import PY3, xrange
+
+_gir = find_library("girepository-1.0")
+
+
+class GIRepositoryError(guint):
+    TYPELIB_NOT_FOUND = 0
+    NAMESPACE_MISMATCH = 1
+    NAMESPACE_VERSION_CONFLICT = 2
+    LIBRARY_NOT_FOUND = 3
+
+
+class GIRepositoryLoadFlags(guint):
+    LAZY = 1
+
+
+class GIRepository(c_void_p):
+
+    def get_infos(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+        for index in xrange(self._get_n_infos(namespace)):
+            res = self._get_info(namespace, index)
+            yield GIBaseInfo._cast(res)
+
+    def get_info(self, namespace, index):
+        if PY3:
+            namespace = namespace.encode("ascii")
+        res = self._get_info(namespace, index)
+        return GIBaseInfo._cast(res)
+
+    def get_n_infos(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+        return self._get_n_infos(namespace)
+
+    def find_by_gtype(self, gtype):
+        res = self._find_by_gtype(gtype)
+        if not res:
+            return None
+        return GIBaseInfo._cast(res)
+
+    def find_by_name(self, namespace, name):
+        if PY3:
+            namespace = namespace.encode("ascii")
+            name = name.encode("ascii")
+        res = self._find_by_name(namespace, name)
+        if not res:
+            return None
+        return GIBaseInfo._cast(res)
+
+    def require(self, namespace, version, flags):
+        if PY3:
+            namespace = namespace.encode("ascii")
+            if version is not None:
+                version = version.encode("ascii")
+        with gerror(GIError) as error:
+            return self._require(namespace, version, flags, error)
+
+    def require_private(self, typelib_dir, namespace, version, flags):
+        if PY3:
+            namespace = namespace.encode("ascii")
+            if version is not None:
+                version = version.encode("ascii")
+        with gerror(GIError) as error:
+            return self._require_private(
+                typelib_dir, namespace, version, flags, error)
+
+    def enumerate_versions(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+        glist = self._enumerate_versions(namespace)
+        res = unpack_glist(glist, c_char_p)
+        if PY3:
+            res = [b.decode("ascii") for b in res]
+        return res
+
+    def get_loaded_namespaces(self):
+        res = self._get_loaded_namespaces()
+        res = unpack_nullterm_array(res)
+        if PY3:
+            res = [b.decode("ascii") for b in res]
+        return res
+
+    def get_immediate_dependencies(self, namespace):
+        try:
+            # https://bugzilla.gnome.org/show_bug.cgi?id=743782
+            immediate_dependencies = self._get_immediate_dependencies
+        except AttributeError:
+            immediate_dependencies = self._get_dependencies
+
+        if PY3:
+            namespace = namespace.encode("ascii")
+        res = immediate_dependencies(namespace)
+        if not res:
+            return []
+        res = unpack_nullterm_array(res)
+        if PY3:
+            res = [p.decode("ascii") for p in res]
+        return res
+
+    def get_search_path(self):
+        res = self._get_search_path()
+        paths = unpack_glist(res, c_char_p, transfer_full=False)
+        return [fsdecode(p) for p in paths]
+
+    def get_shared_library(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+            lib = self._get_shared_library(namespace)
+            return lib.decode("ascii") if lib else lib
+        return self._get_shared_library(namespace)
+
+    def get_typelib_path(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+        path = self._get_typelib_path(namespace)
+        if path is not None:
+            return fsdecode(path)
+
+    def get_version(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+            return self._get_version(namespace).decode("ascii")
+        return self._get_version(namespace)
+
+    def is_registered(self, namespace, version=None):
+        if PY3:
+            namespace = namespace.encode("ascii")
+            if version is not None:
+                version = version.encode("ascii")
+        return self._is_registered(namespace, version)
+
+    def get_c_prefix(self, namespace):
+        if PY3:
+            namespace = namespace.encode("ascii")
+        res = self._get_c_prefix(namespace)
+        if PY3:
+            res = res.decode("ascii")
+        return res
+
+    def load_typelib(self, typelib, flags):
+        with gerror(GIError) as error:
+            res = self._load_typelib(typelib, flags, error)
+        if PY3:
+            res = res.decode("ascii")
+        return res
+
+_methods = [
+    ("get_default", GIRepository, []),
+    ("_require", GITypelib, [GIRepository, gchar_p, gchar_p,
+                            GIRepositoryLoadFlags,
+                            POINTER(GErrorPtr)]),
+    ("_find_by_name", GIBaseInfo,
+     [GIRepository, gchar_p, gchar_p], False),
+    ("prepend_search_path", None, [c_char_p]),
+    ("prepend_library_path", None, [c_char_p]),
+    ("_get_search_path", GSListPtr, []),
+    ("_load_typelib", c_char_p,
+        [GIRepository, GITypelib, GIRepositoryLoadFlags,
+         POINTER(GErrorPtr)]),
+    ("_is_registered", gboolean, [GIRepository, gchar_p, gchar_p]),
+    ("_require_private",
+        GITypelib, [GIRepository, gchar_p, gchar_p, gchar_p,
+                    GIRepositoryLoadFlags, POINTER(GErrorPtr)]),
+    ("_get_dependencies", POINTER(gchar_p), [GIRepository, gchar_p]),
+    ("_get_immediate_dependencies", POINTER(gchar_p), [GIRepository, gchar_p]),
+    ("_get_loaded_namespaces", POINTER(gchar_p), [GIRepository]),
+    ("_find_by_gtype", GIBaseInfo, [GIRepository, GType], False),
+    ("_get_n_infos", gint, [GIRepository, gchar_p]),
+    ("_get_info", GIBaseInfo, [GIRepository, gchar_p, gint], False),
+    ("_get_typelib_path", gchar_p, [GIRepository, gchar_p]),
+    ("_get_shared_library", gchar_p, [GIRepository, gchar_p]),
+    ("_get_version", gchar_p, [GIRepository, gchar_p]),
+    ("get_option_group", GOptionGroupPtr, [], True),
+    ("_get_c_prefix", gchar_p, [GIRepository, gchar_p]),
+    ("_enumerate_versions", GListPtr, [GIRepository, gchar_p]),
+]
+
+wrap_class(_gir, None, GIRepository, "g_irepository_", _methods)
+
+
+__all__ = ["GIRepositoryLoadFlags", "GIRepository", "GIRepositoryError"]

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

@@ -0,0 +1,55 @@
+# 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 .._compat import xrange
+from ..glib import gint, gchar_p, gsize, gboolean
+from .gibaseinfo import GIInfoType, GIBaseInfo
+from .gifieldinfo import GIFieldInfo
+from .gicallableinfo import GIFunctionInfo
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+@GIBaseInfo._register(GIInfoType.STRUCT)
+class GIStructInfo(GIRegisteredTypeInfo):
+
+    def _get_repr(self):
+        values = super(GIStructInfo, self)._get_repr()
+        values = {}
+        values["size"] = repr(self.size)
+        values["alignment"] = repr(self.alignment)
+        values["is_gtype_struct"] = repr(self.is_gtype_struct)
+        values["is_foreign"] = repr(self.is_foreign)
+        values["methods"] = repr(self.get_methods())
+        values["fields"] = repr(self.get_fields())
+        return values
+
+    def get_fields(self):
+        for i in xrange(self.n_fields):
+            yield self.get_field(i)
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+_methods = [
+    ("get_n_fields", gint, [GIStructInfo]),
+    ("get_field", GIFieldInfo, [GIStructInfo, gint], True),
+    ("get_n_methods", gint, [GIStructInfo]),
+    ("get_method", GIFunctionInfo, [GIStructInfo, gint], True),
+    ("find_method", GIFunctionInfo, [GIStructInfo, gchar_p], True),
+    ("get_size", gsize, [GIStructInfo]),
+    ("get_alignment", gsize, [GIStructInfo]),
+    ("is_gtype_struct", gboolean, [GIStructInfo]),
+    ("is_foreign", gboolean, [GIStructInfo]),
+]
+
+wrap_class(_gir, GIStructInfo, GIStructInfo, "g_struct_info_", _methods)
+
+__all__ = ["GIStructInfo"]

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

@@ -0,0 +1,97 @@
+# 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 ..glib import Enum, gchar_p, gboolean, gint
+from .gibaseinfo import GIInfoType, GIBaseInfo
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+class GIArrayType(Enum):
+    C, ARRAY, PTR_ARRAY, BYTE_ARRAY = range(4)
+
+
+class GITypeTag(Enum):
+    VOID = 0
+    BOOLEAN = 1
+    INT8 = 2
+    UINT8 = 3
+    INT16 = 4
+    UINT16 = 5
+    INT32 = 6
+    UINT32 = 7
+    INT64 = 8
+    UINT64 = 9
+    FLOAT = 10
+    DOUBLE = 11
+    GTYPE = 12
+    UTF8 = 13
+    FILENAME = 14
+    ARRAY = 15
+    INTERFACE = 16
+    GLIST = 17
+    GSLIST = 18
+    GHASH = 19
+    ERROR = 20
+    UNICHAR = 21
+
+    @property
+    def is_basic(self):
+        return (self.value < self.ARRAY or self.value == self.UNICHAR)
+
+_methods = [
+    ("to_string", gchar_p, [GITypeTag]),
+]
+
+wrap_class(_gir, GITypeTag, None, "g_type_tag_", _methods)
+
+
+@GIBaseInfo._register(GIInfoType.TYPE)
+class GITypeInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GITypeInfo, self)._get_repr()
+        values["is_pointer"] = repr(self.is_pointer)
+        tag = self.tag
+        values["tag"] = repr(tag)
+        if tag.value == GITypeTag.INTERFACE:
+            values["interface"] = repr(self.get_interface())
+        elif tag.value == GITypeTag.ARRAY:
+            if self.array_length != -1:
+                values["array_length"] = repr(self.array_length)
+            if self.array_fixed_size != -1:
+                values["array_fixed_size"] = repr(self.array_fixed_size)
+            values["zero_terminated"] = repr(self.is_zero_terminated)
+            values["array_type"] = repr(self.array_type)
+            values["param_type"] = repr(self.get_param_type(0))
+        elif tag.value == GITypeTag.GHASH:
+            values["key_type"] = repr(self.get_param_type(0))
+            values["value_type"] = repr(self.get_param_type(1))
+
+        return values
+
+    def get_interface(self, *args):
+        res = self._get_interface(*args)
+        if res:
+            return GIBaseInfo._cast(res)
+
+
+_methods = [
+    ("is_pointer", gboolean, [GITypeInfo]),
+    ("get_tag", GITypeTag, [GITypeInfo]),
+    ("get_param_type", GITypeInfo, [GITypeInfo, gint], True),
+    ("_get_interface", GIBaseInfo, [GITypeInfo], False),
+    ("get_array_length", gint, [GITypeInfo]),
+    ("get_array_fixed_size", gint, [GITypeInfo]),
+    ("is_zero_terminated", gboolean, [GITypeInfo]),
+    ("get_array_type", GIArrayType, [GITypeInfo]),
+]
+
+wrap_class(_gir, None, GITypeInfo, "g_type_info_", _methods)
+
+__all__ = ["GIArrayType", "GITypeTag", "GITypeInfo"]