danielutils 0.9.94__tar.gz → 1.0.0__tar.gz

{danielutils-0.9.94/danielutils.egg-info → danielutils-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 0.9.94
+Version: 1.0.0
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License
@@ -40,7 +40,7 @@ License-File: LICENSE
 [![Python 3.10.11](https://img.shields.io/badge/python-3.10.11-blue.svg)](https://www.python.org/downloads/release/python-31011/)
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
-# danielutils v=0.9.92
+# danielutils v=1.0.0
 A utils library for things that I find useful for my coding workflow.\
 Feel free to use and / or contribute / improve my code :)
 

{danielutils-0.9.94 → danielutils-1.0.0}/README.md

@@ -4,7 +4,7 @@
 [![Python 3.10.11](https://img.shields.io/badge/python-3.10.11-blue.svg)](https://www.python.org/downloads/release/python-31011/)
 [![gitleaks](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/gitleaks.yml)
 [![CodeQL](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/danielnachumdev/danielutils/actions/workflows/github-code-scanning/codeql)
-# danielutils v=0.9.92
+# danielutils v=1.0.0
 A utils library for things that I find useful for my coding workflow.\
 Feel free to use and / or contribute / improve my code :)
 

danielutils-1.0.0/danielutils/Decorators/singleton.py

@@ -0,0 +1,41 @@
+def singleton(og_class):
+    instance = None
+    original_new = getattr(og_class, '__new__')
+    original_init = getattr(og_class, '__init__')
+
+    def __new__(cls, *args, **kwargs):
+        nonlocal instance
+        if instance is None:
+            # index 0 is the current class.
+            # in the minimal case index 1 has 'object' class
+            # otherwise the immediate parent of current class
+            cls_index, og_index = 0, list(cls.__mro__).index(og_class)
+            blacklist = {*cls.__mro__[:og_index + 1]}
+            for candidate in cls.__mro__[og_index + 1:]:
+                if candidate not in blacklist:
+                    try:
+                        instance = candidate.__new__(cls, *args, **kwargs)
+                        break
+                    except:
+                        pass
+            else:
+                instance = object.__new__(cls)
+        return instance
+
+    is_init: bool = False
+
+    def __init__(self, *args, **kwargs) -> None:
+        nonlocal is_init
+        if not is_init:
+            original_init(self, *args, **kwargs)
+            is_init = True
+
+    setattr(og_class, "__new__", __new__)
+    setattr(og_class, "__init__", __init__)
+    setattr(og_class, "instance", lambda: instance)
+    return og_class
+
+
+__all__ = [
+    "singleton"
+]

{danielutils-0.9.94/danielutils/functions → danielutils-1.0.0/danielutils/Functions}/isoftype.py

@@ -1,9 +1,7 @@
-import inspect
 from typing import get_args, get_origin, get_type_hints, Any, Union, TypeVar, \
-    ForwardRef, Literal, Optional, Protocol, Generic, Type, List, Tuple, Set, Dict, Mapping
+    ForwardRef, Literal, Optional, Protocol, Generic, Type, List, Tuple, Set, Dict
 from collections.abc import Callable, Generator, Iterable
 from ..reflection import get_python_version
-from ..versioned_imports import ParamSpec, Concatenate
 
 
 class _tmp(Protocol): ...
@@ -25,9 +23,15 @@ try:
     implicit_union_type = type(int | str)
 except:
     implicit_union_type = Union
-concatenate_t = type(Concatenate[str, ParamSpec("P_")])
+
 ellipsis_ = ...
 
+PARAMSPEC_STRICT: bool = True
+try:
+    from typing import ParamSpec
+except ImportError:
+    PARAMSPEC_STRICT = False
+
 
 def __isoftype_inquire(obj: Any) -> Tuple[Optional[type], Optional[tuple], Optional[dict]]:
     """
@@ -187,18 +191,28 @@ def __handle_callable(params: tuple) -> bool:
         return True
     if len(t_args) == 0:
         return True
-
-    if get_python_version() < (3, 10):
-        if isoftype(t_args[0][0], [ParamSpec, concatenate_t]):
-            return True
-    else:
-        if isoftype(t_args[0], [ParamSpec, concatenate_t]):
-            return True
+    try:
+        from typing import Concatenate, ParamSpec
+        concatenate_t = type(Concatenate[str, ParamSpec("P_")])
+        if get_python_version() < (3, 10):
+            if isoftype(t_args[0][0], [ParamSpec, concatenate_t]):
+                return True
+        else:
+            if isoftype(t_args[0], [ParamSpec, concatenate_t]):
+                return True
+    except ImportError:
+        pass
 
     obj_return_type = obj_hints.get('return')
     obj_param_types = list(obj_hints.values())[:-1] if obj_hints else None
     t_return_type = t_args[1]
 
+    if not PARAMSPEC_STRICT:
+        if t_args[0] == Ellipsis:
+            return True
+        if t_args[0] == [Any]:
+            return True
+
     if isinstance(t_args[0], Iterable):
         t_param_types = list(t_args[0])
         A = obj_param_types + [obj_return_type] if obj_param_types else None
@@ -276,8 +290,8 @@ def __handle_protocol(params: tuple, /, allow_classes: bool = False) -> bool:
         t_origin = T
 
     cls = ClassDeclaration.from_cls(t_origin)
-    declared_funcs: list[FunctionDeclaration] = list(FunctionDeclaration.get_declared_functions(V))
-    required_funcs: list[FunctionDeclaration] = list(FunctionDeclaration.get_declared_functions(t_origin))
+    declared_funcs: List[FunctionDeclaration] = list(FunctionDeclaration.get_declared_functions(V))
+    required_funcs: List[FunctionDeclaration] = list(FunctionDeclaration.get_declared_functions(t_origin))
 
     for i, req_func in enumerate(required_funcs):
         if req_func.has_generics:
@@ -383,26 +397,26 @@ def isoftype(V: Any, T: Any, /, strict: bool = True) -> bool:
         t_origin, t_args, t_hints
     )
 
-    if t_args is not None and Ellipsis in t_args:
+    if t_args is not None and Ellipsis in t_args and PARAMSPEC_STRICT:
         from ..colors import warning  # pylint: disable=cyclic-import
         warning(
             "using an ellipsis (as in '...') with isoftype is ambiguous returning False")
         return False
 
     if T is Union:
-        t_origin = Union
+        t_origin = Union  # type:ignore
     elif T is Protocol or Protocol in getattr(T, "__mro__", []):
-        t_origin = Protocol
+        t_origin = Protocol  # type:ignore
     elif Protocol in getattr(V, "__mro__", []):
-        t_origin = Protocol
+        t_origin = Protocol  # type:ignore
 
     if t_origin is not None:
         if getattr(t_origin, "_is_protocol", False) or isinstance(t_origin, _ProtocolMeta):
-            t_origin = Protocol
+            t_origin = Protocol  # type:ignore
 
         if t_origin in HANDLERS:
             if t_origin in (list, tuple, dict, set, dict, Iterable):
-                if not isinstance(V, t_origin):
+                if not isinstance(V, t_origin):  # type:ignore
                     return False
             return HANDLERS[t_origin](params)  # type:ignore
         # These imports must explicitly be specifically here and not at the top

{danielutils-0.9.94/danielutils/reflection → danielutils-1.0.0/danielutils/Reflection}/__init__.py

@@ -3,7 +3,10 @@ from .file import *
 from .function import *
 from .class_ import *
 from .module import *
-
+from .argument_info import *
+from .decoration_info import *
+from .function_info import *
+from .class_info import *
 # def get_class(module_name: str, class_name: str) -> type:
 #     """dynammically loads the module and returns the class from this file
 

danielutils-1.0.0/danielutils/Reflection/argument_info.py

@@ -0,0 +1,114 @@
+import re
+from dataclasses import dataclass
+from typing import Optional, List
+
+ARGUMENT_INFO_REGEX: re.Pattern = re.compile(
+    r"(?P<kwargs>\*\*\w[\w\d]*)|(?P<args>\*(?:\w[\w\d]*)?)|(?P<kwarg_only>\/)|(?P<pname>\w[\w\d]*)\[(?P<parameters>.+)\]|(?P<name>\w[\w\d]*)(?:(?:\s*:(?P<type>[^\=\n]+))?(?:\s*=(?P<default_value>[\s\S]+))?)?")
+
+
+class ArgumentInfo:
+    def __init__(self,
+                 name: Optional[str],
+                 type: Optional[str],
+                 default: Optional[str],
+                 is_kwargs: bool,
+                 is_args: bool,
+                 is_kwargs_only: bool,
+                 parameters: Optional[List]):
+        self._name = name
+        self._type = type
+        self._default = default
+        self._is_kwargs = is_kwargs
+        self._is_args = is_args
+        self._is_kwargs_only = is_kwargs_only
+        self._parameters = parameters
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def type(self) -> Optional[str]:
+        return self._type
+
+    @property
+    def default(self) -> Optional[str]:
+        return self._default
+
+    @property
+    def is_kwargs(self) -> bool:
+        return self._is_kwargs
+
+    @property
+    def is_args(self) -> bool:
+        return self._is_args
+
+    @property
+    def is_kwargs_only(self) -> bool:
+        return self._is_kwargs_only
+
+    @property
+    def parameters(self) -> Optional[List]:
+        return self._parameters
+
+    @property
+    def is_parameterized(self) -> bool:
+        return self._parameters is not None and len(self.parameters) > 0  # type: ignore
+
+    def __repr__(self) -> str:
+        res = f"{self.__class__.__name__}(name=\"{self.name}\""
+        if self.type is not None:
+            res += f", type={self.type}"
+        if self.default is not None:
+            res += f", default={self.default}"
+        if self.is_parameterized:
+            res+=f", parameters={self.parameters}"
+        return res + ")"
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    @staticmethod
+    def _parse_one(string: str) -> 'ArgumentInfo':
+        m = ARGUMENT_INFO_REGEX.match(string)
+        if m is None:
+            raise ValueError(f"Invalid argument info string: {string}")
+
+        kwargs, args, kwarg_only, pname, parameters, name, type, default_value = m.groups()
+        return ArgumentInfo(
+            name=name or pname,
+            type=type,
+            default=default_value,
+            is_kwargs=kwargs is not None,
+            is_args=args is not None,
+            is_kwargs_only=kwarg_only is not None,
+            parameters=[parameters]
+        )
+
+    @staticmethod
+    def from_str(string: str) -> List['ArgumentInfo']:
+        if string is None:
+            return []
+        string = string.strip()
+        indices = [-1]
+        stack: List[str] = []
+        for i, c in enumerate(string):
+            if c in {'[', ']'}:
+                if c == '[':
+                    stack.append(c)
+                else:
+                    stack.pop()
+            elif len(stack) == 0:
+                if c == ",":
+                    indices.append(i)
+        indices.append(len(string))
+        res = []
+        for start, end in zip(indices[:-1], indices[1:]):
+            substr = string[start + 1:end].strip()
+            res.append(ArgumentInfo._parse_one(substr))
+        return res
+
+
+__all__ = [
+    "ArgumentInfo",
+]

danielutils-1.0.0/danielutils/Reflection/class_info.py

@@ -0,0 +1,104 @@
+import inspect
+import re
+from typing import Optional, List, Iterable, Type
+from .function_info import FunctionInfo
+from .decoration_info import DecorationInfo
+from .argument_info import ArgumentInfo
+
+
+class ClassInfo:
+    CLASS_DEFINITION_REGEX: re.Pattern = re.compile(
+        r"(?P<decorations>[\s\S]*)?^class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)", re.MULTILINE)
+
+    # r"(?P<decorations>[\s\S]*)?^class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)"
+
+    def __init__(self, cls: Type) -> None:
+        if not inspect.isclass(cls):
+            raise TypeError(f"'{cls.__name__}' is not a class")
+        self._cls = cls
+        self._src_code: str = ""
+        self._name: str = ""
+        self._bases: List[ArgumentInfo] = []
+        self._functions: List[FunctionInfo] = []
+        self._decorations: List[DecorationInfo] = []
+        self._parse_src_code()
+
+    def _parse_src_code(self) -> None:
+        self._src_code = inspect.getsource(self._cls)
+        m = ClassInfo.CLASS_DEFINITION_REGEX.match(self._src_code)
+        if m is None:
+            raise SyntaxError()
+        decorators, name, bases, _ = m.groups()
+        self._name = name
+        self._bases = ArgumentInfo.from_str(bases)
+        self._parse_body()
+
+        if decorators is not None:
+            for substr in decorators.strip().splitlines():
+                self._decorations.append(DecorationInfo.from_str(substr.strip()))
+
+    def _parse_body(self) -> None:
+        for attr in dir(self._cls):
+            obj = getattr(self._cls, attr, None)
+            if inspect.isbuiltin(obj): continue
+            try:
+                if inspect.isroutine(obj):
+                    inspect.getsource(obj)
+                elif inspect.isdatadescriptor(obj):
+                    inspect.getsource(obj.fget)  # type:ignore
+                else:
+                    raise 1
+            except:
+                continue
+            self._functions.append(FunctionInfo(obj, self._cls))
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(name=\"{self.name}\", bases={self.bases}, decorations={self.decorations}, static_methods={self.static_methods}, class_methods={self.class_methods}, isntance_methods={self.instance_methods})"
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(name=\"{self.name}\")"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def decorations(self) -> List[DecorationInfo]:
+        return self._decorations
+
+    @property
+    def bases(self) -> List[ArgumentInfo]:
+        return self._bases
+
+    @property
+    def static_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_static_method, self._functions), key=lambda f: f.name)
+
+    @property
+    def class_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_class_method, self._functions), key=lambda f: f.name)
+
+    @property
+    def instance_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_instance_method, self._functions), key=lambda f: f.name)
+
+    @property
+    def functions(self) -> List[FunctionInfo]:
+        return self._functions
+
+    @property
+    def properties(self):
+        pass
+
+    @property
+    def instance_properties(self):
+        pass
+
+    @property
+    def class_properties(self):
+        pass
+
+
+__all__ = [
+    "ClassInfo"
+]

danielutils-1.0.0/danielutils/Reflection/decoration_info.py

@@ -0,0 +1,44 @@
+import re
+from dataclasses import dataclass, Field
+from typing import Optional, List
+
+from .argument_info import ArgumentInfo
+
+
+class DecorationInfo:
+    DECORATOR_INFO_REGEX: re.Pattern = re.compile(r"^@?(?P<name>\w[\w\d]*)(?P<arguments>\(.*\))?")
+
+    def __init__(self, name: str, arguments: List[ArgumentInfo]):
+        self._name = name
+        self._arguments = arguments
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def arguments(self) -> List[ArgumentInfo]:
+        return self._arguments
+
+    @staticmethod
+    def from_str(string: str) -> 'DecorationInfo':
+        m = DecorationInfo.DECORATOR_INFO_REGEX.match(string)
+        if m is None:
+            raise ValueError()
+
+        name, arguments = m.groups()
+        args = ArgumentInfo.from_str(arguments)
+        return DecorationInfo(name, args)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        if self.arguments:
+            return f"{self.__class__.__name__}(name=\"{self.name}\", arguments={self.arguments})"
+        return f"{self.__class__.__name__}(name=\"{self.name}\")"
+
+
+__all__ = [
+    'DecorationInfo',
+]

danielutils-1.0.0/danielutils/Reflection/function_info.py

@@ -0,0 +1,97 @@
+import inspect
+import re
+from typing import Type, Optional, List, Callable
+from .decoration_info import DecorationInfo
+from .argument_info import ArgumentInfo
+
+
+class FunctionInfo:
+    FUNCTION_DEFINITION_REGEX: re.Pattern = re.compile(
+        r"(?P<decorators>[\s\S]+)?\s*def (?P<name>\w[\w\d]*)\s*\((?P<arguments>.+)?\)\s*(?:\s*\-\>\s*(?P<return_type>[\s\S]+?)\s*)?:(?P<body>[\s\S]+)",
+        re.MULTILINE)
+
+    def __init__(self, func: Callable, owner: Type) -> None:
+        try:
+            if inspect.isdatadescriptor(func):
+                inspect.getsource(func.fget)
+                self._is_property = True
+            else:
+                inspect.getsource(func)
+                self._is_property = False
+        except:
+            raise TypeError(f"'{func.__name__}' is not a user defined function")
+        self._func = func
+        self._decorators: List[DecorationInfo] = []
+        self._arguments: List[ArgumentInfo] = []
+        self._return_type: str = ""
+        self._owner = owner
+        self._parse_src_code()
+
+    def _parse_src_code(self) -> None:
+        f = self._func if not self.is_property else self._func.fget  # type:ignore
+        code = inspect.getsource(f).strip()
+        m = FunctionInfo.FUNCTION_DEFINITION_REGEX.match(code)
+        if m is None:
+            raise ValueError("Invalid function source code")
+        decorators, name, arguments, return_type, body = m.groups()
+        if decorators is not None:
+            for substr in decorators.strip().splitlines():
+                self._decorators.append(DecorationInfo.from_str(substr.strip()))
+        self._name = name
+        if arguments is not None:
+            self._arguments = ArgumentInfo.from_str(arguments)
+
+        self._return_type = "None"
+        if return_type is not None:
+            self._return_type = return_type
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(name=\"{self.name}\", decorators={self.decorators}, arguments={self.arguments})"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name=\"{self.name}\")"
+
+    @property
+    def is_inherited(self) -> bool:
+        return self._func in self._owner.__dict__
+
+    @property
+    def is_class_method(self) -> bool:
+        return "classmethod" in set(d.name for d in self.decorators)
+
+    @property
+    def is_static_method(self) -> bool:
+        return "staticmethod" in set(d.name for d in self.decorators)
+
+    @property
+    def is_instance_method(self) -> bool:
+        return not self.is_class_method and not self.is_static_method
+
+    @property
+    def is_abstract(self) -> bool:
+        return getattr(self._func, '__isabstractmethod__', False)
+
+    @property
+    def is_property(self) -> bool:
+        return self._is_property
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def return_type(self) -> str:
+        return self._return_type
+
+    @property
+    def arguments(self) -> List[ArgumentInfo]:
+        return self._arguments
+
+    @property
+    def decorators(self) -> List[DecorationInfo]:
+        return self._decorators
+
+
+__all__ = [
+    "FunctionInfo",
+]

{danielutils-0.9.94/danielutils/university → danielutils-1.0.0/danielutils/University}/computability_and_complexity/languages/sat.py

@@ -1,4 +1,4 @@
-from typing import List, TypeVar
+from typing import List, TypeVar, Optional
 
 from .language import Language
 
@@ -34,14 +34,14 @@ class CNFLiteral:
 
 
 class CNFClause:
-    def __bool__(self, literals: List[CNFLiteral] = None) -> None:
+    def __bool__(self, literals: Optional[List[CNFLiteral]] = None) -> None:
         self.literals = literals or []
 
     def add_literal(self, literal: CNFLiteral):
         self.literals.append(literal)
 
     def evaluate(self, variables: List[CNFVariable]) -> bool:
-        dct = {v.get_id(): v for v in variables}
+        dct: dict = {v.get_id(): v for v in variables}
 
         for literal in self.literals:
             if not literal.get_corresponding_variable_id() in dct.keys():

{danielutils-0.9.94 → danielutils-1.0.0}/danielutils/better_builtins/frange.py

@@ -210,7 +210,7 @@ class brange(frange):
     def __iter__(self):
         itr = super().__iter__()
         try:
-            from tqdm_ import tqdm  # type:ignore  # pylint: disable=import-error
+            from tqdm import tqdm  # type:ignore  # pylint: disable=import-error
             return iter(tqdm(itr, desc=f"{self}", total=len(self)))
         except:
             return itr

{danielutils-0.9.94 → danielutils-1.0.0}/danielutils/custom_types.py

@@ -1,9 +1,5 @@
-from typing import Callable, TypeVar, Generic
-
-try:
-    from typing import TypeAlias
-except ImportError:
-    from typing_extensions import TypeAlias
+from typing import Callable, TypeVar
+from .versioned_imports import TypeAlias
 
 T = TypeVar('T')
 U = TypeVar('U')

{danielutils-0.9.94 → danielutils-1.0.0}/danielutils/data_structures/graph/multinode.py

@@ -1,4 +1,4 @@
-from typing import Optional, Generator, TypeVar, Generic, List as List
+from typing import Optional, Generator, TypeVar, Generic, List as List, Set
 
 from ...reflection import get_python_version
 
@@ -82,7 +82,7 @@ class MultiNode(Generic[T]):
             int
         """
 
-        def helper(cur: MultiNode, seen: Optional[set[MultiNode]] = None) -> int:
+        def helper(cur: MultiNode, seen: Optional[Set[MultiNode]] = None) -> int:
             if not isinstance(cur, MultiNode):
                 return 0
             if seen is None:

danielutils-1.0.0/danielutils/java/__init__.py

@@ -0,0 +1,8 @@
+try:
+    from reflection import get_python_version
+except ImportError:
+    from ..reflection import get_python_version  # type:ignore
+
+if get_python_version() >= (3, 10):
+    from .interfaces import *
+    from .java_interface import *

{danielutils-0.9.94 → danielutils-1.0.0}/danielutils/java/interfaces/comparable.py

@@ -6,7 +6,7 @@ from ..java_interface import JavaInterface
 T = TypeVar('T')
 
 
-class Comparable(JavaInterface, Generic[T]):
+class Comparable(JavaInterface[T]):
     @abstractmethod
     def __lt__(self, other: T) -> bool: ...
 
@@ -14,7 +14,7 @@ class Comparable(JavaInterface, Generic[T]):
     def __gt__(self, other: T) -> bool: ...
 
     @abstractmethod
-    def __eq__(self, other: T) -> bool: ...
+    def __eq__(self, other: T) -> bool: ...  # type:ignore
 
     @abstractmethod
     def __le__(self, other: T) -> bool: ...

danielutils-1.0.0/danielutils/java/java_interface.py

@@ -0,0 +1,33 @@
+
+from abc import abstractmethod, ABC
+from typing import Protocol, runtime_checkable, Any, Callable, ParamSpec, Generic
+from ..reflection import ClassInfo
+
+P = ParamSpec("P")
+
+
+@runtime_checkable
+class JavaInterface(Generic[P], Protocol[P]):
+    @staticmethod
+    def definition(func: Callable) -> Callable:
+        return abstractmethod(func)
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs) -> None:
+        info = ClassInfo(cls)
+        super().__init_subclass__(**kwargs)
+
+    @classmethod
+    def is_implemented_by(interface, cls) -> bool:
+        pass
+
+    @classmethod
+    def implements(cls, interface) -> bool:
+        pass
+
+
+definition = JavaInterface.definition
+__all__ = [
+    "JavaInterface",
+    "definition"
+]