pyulix 1.2.0b2__tar.gz

pyulix-1.2.0b2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oculix-org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyulix-1.2.0b2/NOTICE

@@ -0,0 +1,8 @@
+Pyulix is an independent fork of Operix, maintained by Ajay Rakde.
+It is neither affiliated with nor endorsed by the OculiX project.
+Original work by Julien Mer and the Operix/OculiX contributors.
+Original copyright and MIT license notices are preserved in LICENSE.
+Support for this fork: https://github.com/ajayrakde/Operix/issues
+
+The separately downloaded JVM engine and its bundled dependencies retain
+their own licenses and notices. The Pyulix MIT license does not replace them.

pyulix-1.2.0b2/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: pyulix
+Version: 1.2.0b2
+Summary: Pyulix: independent Python visual automation bridge
+Author: Ajay Rakde
+Maintainer: Ajay Rakde
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ajayrakde/Operix
+Project-URL: Repository, https://github.com/ajayrakde/Operix
+Project-URL: Issues, https://github.com/ajayrakde/Operix/issues
+Keywords: visual-testing,automation,ocr,sikuli,gui-testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+> **Independent fork:** Pyulix is maintained by **Ajay Rakde** and is neither affiliated with nor endorsed by the OculiX project. Original work by Julien Mer and contributors; original copyright and MIT license notices are preserved. [Support](https://github.com/ajayrakde/Operix/issues).
+
+# Pyulix (Python)
+
+![Pyulix](https://raw.githubusercontent.com/ajayrakde/Operix/rebrand/pyulix/docs/branding/pyulix-logo.png)
+
+Python wrapper for [OculiX](https://github.com/oculix-org/Oculix) — visual automation for the real world.
+
+## Install
+
+```bash
+pip install --pre pyulix
+```
+
+Requirements: Python 3.8+, Java 17+ on `PATH` (Eclipse Temurin or Azul Zulu).
+
+The OculiX engine (~200 MB fat JAR) is downloaded on first use into `~/.pyulix/lib/`.
+
+## Quickstart
+
+```python
+from pyulix import Screen, App, VNCScreen
+
+screen = Screen()
+screen.click("login.png")
+screen.type("admin")
+screen.click("submit.png")
+screen.wait("dashboard.png", 10)
+
+# Open a desktop app
+calc = App.open("calc")
+screen.click("button_7.png")
+
+# Drive a remote VNC display
+vnc = VNCScreen.start("10.0.0.42", 5900, "", 1920, 1080)
+vnc.click("logo.png")
+vnc.stop()
+```
+
+## With pytest
+
+```python
+import pytest
+from pyulix import Screen, App
+
+@pytest.fixture
+def calc():
+    a = App.open("calculator")
+    yield a
+    a.close()
+
+def test_addition(calc):
+    s = Screen()
+    s.click("button_7.png")
+    s.click("button_plus.png")
+    s.click("button_3.png")
+    s.click("button_equals.png")
+    assert s.exists("result_10.png")
+```
+
+## License
+
+MIT
+
+## Java API parity
+
+This fork exposes the complete pinned Oculix 4.0.0 public method surface: 211
+public types with named Python methods, constructor/field access and every Java
+overload's arguments. `from pyulix import Screen, OCR, Pattern` uses the new independent namespace.
+Every class is also available through `pyulix.java`; nested classes keep names
+such as `OCR.Options` and `OCR.PSM`.
+
+```python
+from pyulix import Screen, Pattern, Match, OCR, Location, JavaCallback, ObserverCallBack
+
+screen = Screen()
+match = screen.find(Pattern("button.png").similar(0.8))
+assert isinstance(match, Match)
+match.click()
+screen.type("hello", 0)
+
+options = OCR.Options().language("eng").psm(OCR.PSM.SINGLE_LINE)
+text = OCR.readText("button.png", options)
+
+# Ambiguous Java overloads can be selected explicitly.
+options.psm.overload("org.sikuli.script.OCR$PSM")("SINGLE_LINE")
+```
+
+`exists()` returns `Match` or `None`, matching Java; truth checks continue to work.
+Java interface callbacks accept `JavaCallback(interface_name, handler)` and
+observer methods accept a Python function directly. Arrays/collections become
+Python sequences; maps become dictionaries; Java iterators support iteration.
+
+This distribution uses the matching 1.2.0b2 JVM bridge from `ajayrakde/Operix`.
+The Python namespace is `pyulix`; bridge downloads are cached under `~/.pyulix/lib/`.
+Java classes and upstream Maven dependency names are unchanged.
+
+## Migration from oculix-operix
+
+Install `pyulix` with `pip install --pre pyulix`, then change `from oculix ...`
+to `from pyulix ...` (including submodules). No `oculix` compatibility
+package is installed. Remove the old `oculix-operix` distribution if no longer
+needed. Existing published versions are historical and do not acquire this rename.
+
+## Status and attribution
+
+Beta: overload ambiguity, Java `Any` types, and platform-specific desktop/OCR
+behavior still require care. API coverage is not a guarantee that every argument
+combination works. See the repository's `docs/` for validation and limitations.
+
+Original work: Julien Mer and contributors. See LICENSE and NOTICE.
+The separately downloaded JVM engine and native dependencies have their own licenses.

pyulix-1.2.0b2/README.md

@@ -0,0 +1,112 @@
+> **Independent fork:** Pyulix is maintained by **Ajay Rakde** and is neither affiliated with nor endorsed by the OculiX project. Original work by Julien Mer and contributors; original copyright and MIT license notices are preserved. [Support](https://github.com/ajayrakde/Operix/issues).
+
+# Pyulix (Python)
+
+![Pyulix](https://raw.githubusercontent.com/ajayrakde/Operix/rebrand/pyulix/docs/branding/pyulix-logo.png)
+
+Python wrapper for [OculiX](https://github.com/oculix-org/Oculix) — visual automation for the real world.
+
+## Install
+
+```bash
+pip install --pre pyulix
+```
+
+Requirements: Python 3.8+, Java 17+ on `PATH` (Eclipse Temurin or Azul Zulu).
+
+The OculiX engine (~200 MB fat JAR) is downloaded on first use into `~/.pyulix/lib/`.
+
+## Quickstart
+
+```python
+from pyulix import Screen, App, VNCScreen
+
+screen = Screen()
+screen.click("login.png")
+screen.type("admin")
+screen.click("submit.png")
+screen.wait("dashboard.png", 10)
+
+# Open a desktop app
+calc = App.open("calc")
+screen.click("button_7.png")
+
+# Drive a remote VNC display
+vnc = VNCScreen.start("10.0.0.42", 5900, "", 1920, 1080)
+vnc.click("logo.png")
+vnc.stop()
+```
+
+## With pytest
+
+```python
+import pytest
+from pyulix import Screen, App
+
+@pytest.fixture
+def calc():
+    a = App.open("calculator")
+    yield a
+    a.close()
+
+def test_addition(calc):
+    s = Screen()
+    s.click("button_7.png")
+    s.click("button_plus.png")
+    s.click("button_3.png")
+    s.click("button_equals.png")
+    assert s.exists("result_10.png")
+```
+
+## License
+
+MIT
+
+## Java API parity
+
+This fork exposes the complete pinned Oculix 4.0.0 public method surface: 211
+public types with named Python methods, constructor/field access and every Java
+overload's arguments. `from pyulix import Screen, OCR, Pattern` uses the new independent namespace.
+Every class is also available through `pyulix.java`; nested classes keep names
+such as `OCR.Options` and `OCR.PSM`.
+
+```python
+from pyulix import Screen, Pattern, Match, OCR, Location, JavaCallback, ObserverCallBack
+
+screen = Screen()
+match = screen.find(Pattern("button.png").similar(0.8))
+assert isinstance(match, Match)
+match.click()
+screen.type("hello", 0)
+
+options = OCR.Options().language("eng").psm(OCR.PSM.SINGLE_LINE)
+text = OCR.readText("button.png", options)
+
+# Ambiguous Java overloads can be selected explicitly.
+options.psm.overload("org.sikuli.script.OCR$PSM")("SINGLE_LINE")
+```
+
+`exists()` returns `Match` or `None`, matching Java; truth checks continue to work.
+Java interface callbacks accept `JavaCallback(interface_name, handler)` and
+observer methods accept a Python function directly. Arrays/collections become
+Python sequences; maps become dictionaries; Java iterators support iteration.
+
+This distribution uses the matching 1.2.0b2 JVM bridge from `ajayrakde/Operix`.
+The Python namespace is `pyulix`; bridge downloads are cached under `~/.pyulix/lib/`.
+Java classes and upstream Maven dependency names are unchanged.
+
+## Migration from oculix-operix
+
+Install `pyulix` with `pip install --pre pyulix`, then change `from oculix ...`
+to `from pyulix ...` (including submodules). No `oculix` compatibility
+package is installed. Remove the old `oculix-operix` distribution if no longer
+needed. Existing published versions are historical and do not acquire this rename.
+
+## Status and attribution
+
+Beta: overload ambiguity, Java `Any` types, and platform-specific desktop/OCR
+behavior still require care. API coverage is not a guarantee that every argument
+combination works. See the repository's `docs/` for validation and limitations.
+
+Original work: Julien Mer and contributors. See LICENSE and NOTICE.
+The separately downloaded JVM engine and native dependencies have their own licenses.

pyulix-1.2.0b2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyulix"
+version = "1.2.0b2"
+description = "Pyulix: independent Python visual automation bridge"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE", "NOTICE"]
+requires-python = ">=3.8"
+authors = [{name = "Ajay Rakde"}]
+maintainers = [{name = "Ajay Rakde"}]
+keywords = ["visual-testing", "automation", "ocr", "sikuli", "gui-testing"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/ajayrakde/Operix"
+Repository = "https://github.com/ajayrakde/Operix"
+
+Issues = "https://github.com/ajayrakde/Operix/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.setuptools.package-data]
+pyulix = ["_api_schema.json.gz", "py.typed", "*.pyi", "**/*.pyi"]

pyulix-1.2.0b2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyulix-1.2.0b2/src/pyulix/__init__.py

@@ -0,0 +1,12 @@
+"""Complete named Python facade for the pinned Oculix Java API.
+
+Java method names, constructors and overload arguments are preserved.
+Use ``method.overload(*java_type_names)`` for ambiguous null/reference calls.
+"""
+from ._bridge import Bridge, BridgeError, RemoteObject, RemoteWrapper, default_bridge
+from ._api import JavaObject, JavaCallback, java_class
+from .java import *
+from .java import __all__ as _java_names
+
+__version__ = '1.2.0b2'
+__all__ = list(_java_names) + ['Bridge', 'BridgeError', 'JavaObject', 'JavaCallback', 'java_class', 'default_bridge']

pyulix-1.2.0b2/src/pyulix/__init__.pyi

@@ -0,0 +1,4 @@
+from .java import *
+from ._bridge import Bridge, BridgeError, default_bridge
+from ._api import JavaObject, JavaCallback, java_class
+__version__: str

pyulix-1.2.0b2/src/pyulix/_api.py

@@ -0,0 +1,225 @@
+"""Java overload binding, fields and typed facades for the generated API."""
+from __future__ import annotations
+
+import inspect
+import gzip
+import json
+import keyword
+from pathlib import Path
+from typing import Any
+
+from ._bridge import RemoteWrapper, RemoteObject, register_wrapper, _WRAPPER_TYPES
+
+_SCHEMA = json.loads(gzip.decompress(Path(__file__).with_name('_api_schema.json.gz').read_bytes()))
+_TYPES = {}
+
+
+def _default_bridge():
+    import pyulix
+    return pyulix.default_bridge()
+
+
+def _identifier(name):
+    return name + '_' if keyword.iskeyword(name) or name in {'self', 'cls'} else name
+
+
+def _bind(member, args, kwargs):
+    parameters = member['parameters']
+    values = list(args)
+    varargs = member['varargs']
+    fixed = len(parameters) - int(varargs)
+    if not varargs and len(values) > len(parameters): raise TypeError('Too many positional arguments')
+    for i, p in enumerate(parameters):
+        name = _identifier(p['name'])
+        if name in kwargs:
+            if i < len(args): raise TypeError('Multiple values for ' + name)
+            if i != len(values): raise TypeError('Missing preceding argument')
+            values.append(kwargs[name])
+        elif i >= len(values) and i < fixed:
+            raise TypeError('Missing argument ' + name)
+    known = {_identifier(p['name']) for p in parameters}
+    if set(kwargs) - known: raise TypeError('Unknown argument: ' + ', '.join(set(kwargs) - known))
+    if varargs:
+        # Both Java's explicit array form and Python's expanded positional form.
+        final = values[-1] if values else None
+        remote = final._remote if isinstance(final, RemoteWrapper) else final
+        explicit_array = (final is None or isinstance(final, (list, tuple))
+                          or isinstance(final, (bytes, bytearray)) and parameters[-1]['type'] == 'byte[]'
+                          or isinstance(remote, RemoteObject) and remote._class.startswith('['))
+        if len(values) == len(parameters) and explicit_array:
+            pass
+        else: values = values[:fixed] + [values[fixed:]]
+    elif len(values) != len(parameters): raise TypeError('Wrong argument count')
+    return values
+
+
+class BoundJavaMethod:
+    def __init__(self, descriptor, instance, owner):
+        self.descriptor, self.instance, self.owner = descriptor, instance, owner
+        self.__name__ = descriptor.name
+        self.__doc__ = descriptor.__doc__
+        self.overloads = tuple(descriptor.members)
+        member = next((m for m in descriptor.members if m['static'] or instance is not None), descriptor.members[0])
+        params = [inspect.Parameter(_identifier(p['name']), inspect.Parameter.VAR_POSITIONAL
+                  if member['varargs'] and i == len(member['parameters']) - 1 else inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                  for i, p in enumerate(member['parameters'])]
+        self.__signature__ = inspect.Signature(params)
+
+    def overload(self, *parameter_types):
+        """Choose an exact Java overload where Python values cannot disambiguate it."""
+        members = [m for m in self.descriptor.members if tuple(p['type'] for p in m['parameters']) == parameter_types]
+        if not members: raise TypeError('No Java overload with types ' + repr(parameter_types))
+        return BoundJavaMethod(JavaMethod(self.descriptor.name, members), self.instance, self.owner)
+
+    def __call__(self, *args, **kwargs):
+        bridge = self.instance._remote._bridge if self.instance is not None else _default_bridge()
+        candidates = []
+        for member in self.descriptor.members:
+            if self.instance is None and not member['static'] and self.__name__ != '<init>': continue
+            try: values = _bind(member, args, kwargs)
+            except TypeError: continue
+            prepared = []
+            for parameter, value in zip(member['parameters'], values):
+                if callable(value) and not isinstance(value, JavaCallback):
+                    interface = parameter['type']
+                    if interface == 'java.lang.Object': interface = 'org.sikuli.script.ObserverCallBack'
+                    value = JavaCallback(interface, value)
+                prepared.append(value)
+            candidates.append((member, prepared))
+        if not candidates:
+            raise TypeError(f'No matching argument names/count for {self.owner.JAVA_CLASS}.{self.__name__}; see .overloads')
+        # Java owns assignability, interface inheritance, unboxing and conversion.
+        # Python only binds argument names/counts; stubs never gate runtime values.
+        if len(candidates) > 1:
+            index = bridge.resolve_overload(self.owner.JAVA_CLASS, self.__name__, candidates)
+        else: index = 0
+        member, prepared = candidates[index]
+        for parameter, value in zip(member['parameters'], prepared):
+            if value is None and parameter.get('non_null'):
+                raise TypeError(f"{self.owner.JAVA_CLASS}.{self.__name__}: {parameter['name']} "
+                                f"must not be None ({parameter['type']})")
+        types = [p['type'] for p in member['parameters']]
+        if self.__name__ == '<init>': return bridge.create(self.owner.JAVA_CLASS, prepared, parameter_types=types)
+        if member['static']:
+            return bridge.call_static(self.owner.JAVA_CLASS, self.__name__, prepared, parameter_types=types)
+        return bridge.call(self.instance._remote._ref, self.__name__, prepared, parameter_types=types)
+
+
+class JavaMethod:
+    """A declared, finite set of Java overloads; no arbitrary method forwarding."""
+    def __init__(self, name, members):
+        self.name, self.members = name, members
+        self.__doc__ = '\n'.join(m['name'] + '(' + ', '.join(p['type'] + ' ' + p['name'] for p in m['parameters']) + ')' for m in members)
+
+    def __get__(self, instance, owner=None):
+        return BoundJavaMethod(self, instance, owner)
+
+
+class JavaField:
+    def __init__(self, field): self.field = field
+    def __get__(self, instance, owner=None):
+        if instance is None and not self.field['static']: return self
+        bridge = instance._remote._bridge if instance is not None else _default_bridge()
+        req = {'class': owner.JAVA_CLASS, 'field': self.field['name']}
+        if instance is not None and not self.field['static']: req = {'ref': instance._remote._ref, 'field': self.field['name']}
+        from ._bridge import _decode
+        return _decode(bridge, bridge._request(req))
+    def __set__(self, instance, value):
+        self.set(type(instance), instance, value)
+    def set(self, owner, instance, value):
+        if self.field['final']: raise AttributeError('Java field is final: ' + self.field['name'])
+        bridge = instance._remote._bridge if instance is not None else _default_bridge()
+        from ._bridge import _encode
+        req = {'class': owner.JAVA_CLASS, 'field': self.field['name'], 'value': _encode(value, bridge)}
+        if instance is not None and not self.field['static']: req['ref'] = instance._remote._ref
+        bridge._request(req)
+
+
+class JavaMeta(type):
+    def overload(cls, *parameter_types):
+        """Select an exact public constructor, including null reference calls."""
+        members = _SCHEMA.get(cls.JAVA_CLASS, {}).get('constructors', [])
+        return BoundJavaMethod(JavaMethod('<init>', members), None, cls).overload(*parameter_types)
+    def __setattr__(cls, name, value):
+        descriptor = next((p.__dict__[name] for p in cls.__mro__ if name in p.__dict__), None)
+        if isinstance(descriptor, JavaField): descriptor.set(cls, None, value)
+        else: super().__setattr__(name, value)
+
+
+class JavaObject(RemoteWrapper, metaclass=JavaMeta):
+    JAVA_CLASS = 'java.lang.Object'
+    def __init__(self, *args, **kwargs):
+        schema = _SCHEMA.get(self.JAVA_CLASS)
+        if schema is None: result = _default_bridge().create(self.JAVA_CLASS, list(args))
+        else:
+            if not schema['constructors']: raise TypeError(self.JAVA_CLASS + ' has no public constructors')
+            result = BoundJavaMethod(JavaMethod('<init>', schema['constructors']), None, type(self))(*args, **kwargs)
+        self._remote = result._remote if isinstance(result, RemoteWrapper) else result
+        self._remote._bridge._cache[self._remote._ref] = self
+    @property
+    def _ref(self): return self._remote._ref
+    @property
+    def _bridge(self): return self._remote._bridge
+    def __getattr__(self, name):
+        if any(_SCHEMA.get(parent.JAVA_CLASS, {}).get('opaque') for parent in type(self).__mro__
+               if hasattr(parent, 'JAVA_CLASS')):
+            raise AttributeError(f'{self._remote._class} is an opaque Java handle; use the public owner API')
+        if self.JAVA_CLASS in _SCHEMA: raise AttributeError(name)
+        return super().__getattr__(name)
+    def __iter__(self):
+        if self._remote._class.startswith('java.util.'):
+            iterator = self if self._remote._kind == 'iterator' or 'Iterator' in self._remote._class else self._call('iterator')
+            while iterator._call('hasNext'): yield iterator._call('next')
+        else: raise TypeError(self.JAVA_CLASS + ' is not an iterable')
+    def __repr__(self): return f'<{type(self).__name__} {self._remote._class}#{self._remote._ref}>'
+
+
+class JavaCallback:
+    """Python implementation of a Java interface or ObserverCallBack.
+
+    handler may be a function (single method) or an object/dict of method handlers.
+    Keep this object alive while Java may invoke it; the bridge retains it until stop.
+    """
+    def __init__(self, interface, handler):
+        self.interface = interface.JAVA_CLASS if hasattr(interface, 'JAVA_CLASS') else interface
+        self.handler = handler
+    def dispatch(self, method, args):
+        if isinstance(self.handler, dict): function = self.handler[method]
+        elif callable(self.handler): function = self.handler
+        else: function = getattr(self.handler, method)
+        return function(*args)
+
+
+def java_class(name, *, parent=None):
+    if name in _TYPES: return _TYPES[name]
+    cls = JavaMeta(name.rsplit('.', 1)[-1].replace('$', '_'), (parent or JavaObject,), {'JAVA_CLASS': name, '__module__': 'pyulix.java'})
+    _TYPES[name] = cls
+    register_wrapper(name, cls)
+    return cls
+
+
+def load_api(namespace):
+    todo = set(_SCHEMA)
+    while todo:
+        ready = sorted(n for n in todo if _SCHEMA[n]['superclass'] not in todo)
+        for name in ready:
+            row = _SCHEMA[name]
+            base = _TYPES.get(row['superclass'], JavaObject)
+            attrs = {'JAVA_CLASS': name, '__module__': 'pyulix.java', '__doc__': 'Java ' + name}
+            groups = {}
+            for m in row['methods']: groups.setdefault(m['name'], []).append(m)
+            for mname, members in groups.items():
+                descriptor = JavaMethod(mname, members)
+                attrs[_identifier(mname)] = descriptor
+                attrs[mname] = descriptor
+            for f in row['fields']:
+                if _identifier(f['name']) not in attrs: attrs[_identifier(f['name'])] = JavaField(f)
+            cls = JavaMeta(row['python_name'], (base,), attrs)
+            _TYPES[name] = cls
+            register_wrapper(name, cls)
+            namespace[row['python_name']] = cls
+        todo -= set(ready)
+    for name, cls in _TYPES.items():
+        if '$' in name and name.rsplit('$', 1)[0] in _TYPES:
+            setattr(_TYPES[name.rsplit('$', 1)[0]], name.rsplit('$', 1)[1], cls)
+    namespace['__all__'] = sorted(row['python_name'] for row in _SCHEMA.values())

pyulix-1.2.0b2/src/pyulix/_api.pyi

@@ -0,0 +1,20 @@
+"""Typing facade: known Java classes expose their generated declarations only."""
+from typing import Any, ClassVar
+from ._bridge import Bridge
+
+class JavaObject:
+    JAVA_CLASS: ClassVar[str]
+    _ref: str
+    _bridge: Bridge
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def _call(self, method: str, *args: Any) -> Any: ...
+    @classmethod
+    def _wrap(cls, value: Any) -> Any: ...
+
+class JavaCallback:
+    interface: str
+    handler: Any
+    def __init__(self, interface: Any, handler: Any) -> None: ...
+    def dispatch(self, method: str, args: Any) -> Any: ...
+
+def java_class(name: str, *, parent: Any = None) -> Any: ...