release 0.8.1a1

Author: hx2A

README.md

@@ -8,7 +8,7 @@
 
 py5 is a new version of [**Processing**][processing] for Python 3.8+. It makes the Java [**Processing**][processing] jars available to the CPython interpreter using [**JPype**][jpype]. It can do just about all of the 2D and 3D drawing [**Processing**][processing] can do, except with Python instead of Java code.
 
-The goal of py5 is to create a new version of Processing that is integrated into the Python ecosystem. Built into the library are thoughtful choices about how to best get py5 to work with other popular Python libraries and tools such as [Jupyter](https://jupyter.org/), [numpy](https://www.numpy.org/), and [Pillow](https://python-pillow.org/).
+The goal of py5 is to create a new version of Processing that is integrated into the Python ecosystem. Built into the library are thoughtful choices about how to best get py5 to work with other popular Python libraries and tools such as [Jupyter][jupyter], [numpy][numpy], and [Pillow][pillow].
 
 ## Simple Example
 
@@ -69,3 +69,7 @@ Have a comment or question? We'd love to hear from you! The best ways to reach o
 [py5_generator_repo]: https://github.com/py5coding/py5generator
 [processing]: https://github.com/processing/processing4
 [jpype]: https://github.com/jpype-project/jpype
+
+[jupyter]: https://jupyter.org/
+[numpy]: https://numpy.org/
+[pillow]: https://python-pillow.org/

py5/__init__.py

@@ -24,14 +24,16 @@
 from typing import Union
 import inspect
 import line_profiler
+import traceback
 
-from jpype import JImplements, JOverride, JString
+from jpype import JClass, JImplements, JOverride, JString
 
 import stackprinter
 
 import py5_tools
 from . import reference
 from . import custom_exceptions
+# from . import java_conversion
 
 # *** stacktrace configuration ***
 # set stackprinter color style. Default is plaintext. Other choices are darkbg,
@@ -50,6 +52,16 @@
     **custom_exceptions.CUSTOM_EXCEPTION_MSGS,
 }
 
+_JAVA_RUNTIMEEXCEPTION = JClass('java.lang.RuntimeException')
+
+
+def check_run_method_callstack():
+    for t in traceback.extract_stack():
+        if t.filename == __file__ and t.name == 'run_method':
+            return True
+    else:
+        return False
+
 
 def _exception_msg(println, exc_type_name, exc_msg, py5info):
     try:
@@ -149,8 +161,8 @@ def _extract_py5_user_function_data(d: dict):
     return functions, function_param_counts
 
 
-@JImplements('py5.core.Py5Methods')
-class Py5Methods:
+@JImplements('py5.core.Py5Bridge')
+class Py5Bridge:
 
     def __init__(self, sketch):
         self._sketch = sketch
@@ -161,6 +173,9 @@ def __init__(self, sketch):
         self._profiler = line_profiler.LineProfiler()
         self._is_terminated = False
 
+        from .java_conversion import convert_to_python_types
+        self._convert_to_python_types = convert_to_python_types
+
     def set_functions(self, functions, function_param_counts):
         self._function_param_counts = dict()
         self._functions = dict()
@@ -232,6 +247,10 @@ def get_function_list(self):
         return [JString(f'{name}:{self._function_param_counts[name]}')
                 for name in self._functions.keys()]
 
+    @JOverride
+    def terminate_sketch(self):
+        self._sketch._terminate_sketch()
+
     @JOverride
     def run_method(self, method_name, params):
         try:
@@ -242,8 +261,8 @@ def run_method(self, method_name, params):
                         hook(self._sketch)
 
                 # now run the actual method
-                from .java_conversion import convert_to_python_types
-                self._functions[method_name](*convert_to_python_types(params))
+                self._functions[method_name](
+                    *self._convert_to_python_types(params))
 
                 # finally, post-hooks
                 if method_name in self._post_hooks:
@@ -252,9 +271,47 @@ def run_method(self, method_name, params):
             return True
         except Exception:
             handle_exception(self._sketch.println, *sys.exc_info())
-            self._sketch._terminate_sketch()
+            self.terminate_sketch()
             return False
 
+    @JOverride
+    def call_function(self, key, params):
+        d = py5_tools.config._PY5_PROCESSING_MODE_KEYS
+        try:
+            *str_hierarchy, c = str(key).split('.')
+
+            for s in str_hierarchy:
+                if s in d:
+                    subd = d[s]
+                    if isinstance(subd, dict):
+                        d = subd
+                    elif hasattr(subd, '__dict__'):
+                        d = subd.__dict__
+                    else:
+                        return _JAVA_RUNTIMEEXCEPTION(
+                            f'{s} in key {key} does map to dict or object with __dict__ attribute')
+                else:
+                    return _JAVA_RUNTIMEEXCEPTION(
+                        f'{s} not found with key {key}')
+
+            if c not in d or not callable(func := d[c]):
+                return _JAVA_RUNTIMEEXCEPTION(
+                    f'callable {c} not found with key {key}')
+
+            try:
+                retval = func(*self._convert_to_python_types(params))
+                if key in py5_tools.config._PY5_PROCESSING_MODE_CALLBACK_ONCE:
+                    py5_tools.config._PY5_PROCESSING_MODE_CALLBACK_ONCE.remove(
+                        key)
+                    if key in py5_tools.config._PY5_PROCESSING_MODE_KEYS:
+                        py5_tools.config._PY5_PROCESSING_MODE_KEYS.pop(key)
+                return retval
+            except Exception as e:
+                handle_exception(self._sketch.println, *sys.exc_info())
+                return _JAVA_RUNTIMEEXCEPTION(str(e))
+        except Exception as e:
+            return _JAVA_RUNTIMEEXCEPTION(str(e))
+
     @JOverride
     def py5_println(self, text, stderr):
         self._sketch.println(text, stderr=stderr)

py5/methods.py renamed to py5/bridge.py

@@ -24,8 +24,10 @@
 from jpype.types import JString, JInt
 
 
-HEX_COLOR_REGEX = re.compile(r'#[0-9A-F]{6}' + chr(36))
 HEX_3DIGIT_COLOR_REGEX = re.compile(r'#[0-9A-F]{3}' + chr(36))
+HEX_4DIGIT_COLOR_REGEX = re.compile(r'#[0-9A-F]{4}' + chr(36))
+HEX_6DIGIT_COLOR_REGEX = re.compile(r'#[0-9A-F]{6}' + chr(36))
+HEX_8DIGIT_COLOR_REGEX = re.compile(r'#[0-9A-F]{8}' + chr(36))
 
 
 def _text_fix_str(f):
@@ -50,12 +52,27 @@ def decorated(self_, *args):
 
 
 def _hex_converter(arg):
-    if isinstance(arg, str) and HEX_COLOR_REGEX.match(arg.upper()):
-        return JInt(int("0xFF" + arg[1:], base=16))
-    elif isinstance(arg, str) and HEX_3DIGIT_COLOR_REGEX.match(arg.upper()):
-        return JInt(int("0xFF" + ''.join([c + c for c in arg[1:]]), base=16))
+    if isinstance(arg, str):
+        if arg.startswith('#'):
+            if HEX_3DIGIT_COLOR_REGEX.match(arg.upper()):
+                return JInt(
+                    int("0xFF" + ''.join([c + c for c in arg[1:]]), base=16))
+            elif HEX_4DIGIT_COLOR_REGEX.match(arg.upper()):
+                return JInt(
+                    int("0x" + ''.join([arg[i] + arg[i] for i in [4, 1, 2, 3]]), base=16))
+            elif HEX_6DIGIT_COLOR_REGEX.match(arg.upper()):
+                return JInt(int("0xFF" + arg[1:], base=16))
+            elif HEX_8DIGIT_COLOR_REGEX.match(arg.upper()):
+                return JInt(int("0x" + arg[7:] + arg[1:7], base=16))
+        else:
+            try:
+                import matplotlib.colors as mcolors
+                return JInt(int("0xFF" + mcolors.to_hex(arg)[1:], base=16))
+            except BaseException:
+                return None
     elif isinstance(arg, (int, np.integer)) and 0x7FFFFFFF < arg <= 0xFFFFFFFF:
         return JInt(arg)
+
     return None
 
 

py5/decorators.py

@@ -21,6 +21,7 @@
 
 import functools
 from typing import overload  # noqa
+import weakref
 
 import jpype
 from jpype import JException, JArray, JString  # noqa
@@ -82,12 +83,20 @@ class Py5Font:
     To create a new font dynamically, use the ``create_font()`` function. Do not use
     the syntax ``Py5Font()``.
     """
-
     _cls = jpype.JClass('processing.core.PFont')
     CHARSET = _cls.CHARSET
 
-    def __init__(self, pfont):
-        self._instance = pfont
+    _py5_object_cache = weakref.WeakSet()
+
+    def __new__(cls, pfont):
+        for o in cls._py5_object_cache:
+            if pfont == o._instance:
+                return o
+        else:
+            o = object.__new__(Py5Font)
+            o._instance = pfont
+            cls._py5_object_cache.add(o)
+            return o
 
     def ascent(self) -> float:
         """Get the ascent of this font from the baseline.