amalgam-lang 20.0.2__py3-none-macosx_12_0_arm64.whl → 25.2.5__py3-none-macosx_12_0_arm64.whl

amalgam/api.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from base64 import b64encode
 from ctypes import (
     _Pointer, Array, byref, c_bool, c_char, c_char_p, c_size_t, c_uint64, c_void_p,
-    cast, cdll, POINTER, Structure
+    cast, cdll, POINTER, Structure, string_at
 )
 from datetime import datetime
 import gc
@@ -28,7 +29,9 @@ class _LoadEntityStatus(Structure):
     _fields_ = [
         ("loaded", c_bool),
         ("message", POINTER(c_char)),
-        ("version", POINTER(c_char))
+        ("version", POINTER(c_char)),
+        ("entity_path", POINTER(POINTER(c_char))),
+        ("entity_path_len", c_size_t)
     ]
 
 
@@ -53,10 +56,14 @@ class LoadEntityStatus:
             self.loaded = True
             self.message = ""
             self.version = ""
+            self.entity_path = []
         else:
             self.loaded = bool(c_status.loaded)
             self.message = api.char_p_to_str(c_status.message)
             self.version = api.char_p_to_str(c_status.version)
+            self.entity_path = [api.char_p_to_str(c_status.entity_path[i]) for i in range(c_status.entity_path_len)]
+            api.amlg.DeleteString(cast(c_status.entity_path, c_char_p))
+
 
     def __str__(self) -> str:
         """
@@ -67,7 +74,11 @@ class LoadEntityStatus:
         str
             The human-readable string representation.
         """
-        return f"{self.loaded},\"{self.message}\",\"{self.version}\""
+        ep = ""
+        if self.entity_path:
+            eps = (f'"{step}"' for step in self.entity_path)
+            ep = f",[{','.join(eps)}]"
+        return f"{self.loaded},\"{self.message}\",\"{self.version}\"{ep}"
 
 
 class _ResultWithLog(Structure):
@@ -237,8 +248,7 @@ class Amalgam:
                     )
                     counter += 1
 
-            self.trace = open(self.execution_trace_filepath, 'w+',
-                              encoding='utf-8')
+            self.trace = self.execution_trace_filepath.open("wb+")
             _logger.debug("Opening Amalgam trace file: "
                           f"{self.execution_trace_filepath}")
         else:
@@ -253,7 +263,7 @@ class Amalgam:
             self.set_max_num_threads(max_num_threads)
         self.gc_interval = gc_interval
         self.op_count = 0
-        self.load_command_log_entry = None
+        self.load_command_log_entry: bytes | None = None
 
     @classmethod
     def _get_allowed_postfixes(cls, library_dir: Path) -> list[str]:
@@ -470,7 +480,7 @@ class Amalgam:
             The maximum number of threads that Amalgam is configured to use.
         """
         self.amlg.GetMaxNumThreads.restype = c_size_t
-        self._log_execution("GET_MAX_NUM_THREADS")
+        self._log_execution(b"GET_MAX_NUM_THREADS")
         result = self.amlg.GetMaxNumThreads()
         self._log_reply(result)
 
@@ -492,7 +502,7 @@ class Amalgam:
         self.amlg.SetMaxNumThreads.argtypes = [c_size_t]
         self.amlg.SetMaxNumThreads.restype = c_void_p
 
-        self._log_execution(f"SET_MAX_NUM_THREADS {max_num_threads}")
+        self._log_execution(f"SET_MAX_NUM_THREADS {max_num_threads}".encode())
         result = self.amlg.SetMaxNumThreads(max_num_threads)
         self._log_reply(result)
 
@@ -511,7 +521,7 @@ class Amalgam:
         _logger.debug(f"Execution trace file being reset: "
                       f"{self.execution_trace_filepath} to be closed ...")
         # Write exit command.
-        self.trace.write("EXIT\n")
+        self.trace.write(b"EXIT\n")
         self.trace.close()
         self.execution_trace_filepath = Path(self.execution_trace_dir, file)
 
@@ -523,12 +533,12 @@ class Amalgam:
                     self.execution_trace_dir, f'{file}.{counter}')
                 counter += 1
 
-        self.trace = open(self.execution_trace_filepath, 'w+')
+        self.trace = self.execution_trace_filepath.open("wb+")
         _logger.debug(f"New trace file: {self.execution_trace_filepath} "
                       f"opened.")
         # Write load command used to instantiate the amalgam instance.
         if self.load_command_log_entry is not None:
-            self.trace.write(self.load_command_log_entry + "\n")
+            self.trace.write(self.load_command_log_entry + b"\n")
         self.trace.flush()
 
     def __str__(self) -> str:
@@ -543,7 +553,7 @@ class Amalgam:
             getattr(self, 'trace', None) is not None
         ):
             try:
-                self.trace.write("EXIT\n")
+                self.trace.write(b"EXIT\n")
             except Exception:  # noqa - deliberately broad
                 pass
 
@@ -559,7 +569,7 @@ class Amalgam:
             The raw reply string to log.
         """
         if self.trace:
-            self.trace.write("# NOTE >" + str(comment) + "\n")
+            self.trace.write(b"# NOTE >" + comment.encode() + b"\n")
             self.trace.flush()
 
     def _log_reply(self, reply: t.Any):
@@ -574,7 +584,13 @@ class Amalgam:
             The raw reply string to log.
         """
         if self.trace:
-            self.trace.write("# RESULT >" + str(reply) + "\n")
+            if isinstance(reply, ResultWithLog):
+                if reply.json:
+                    self.trace.write(b"# RESULT >" + reply.json + b"\n")
+                if reply.log:
+                    self.trace.write(b"# LOG >" + reply.log + b"\n")
+            else:
+                self.trace.write(b"# RESULT >" + str(reply).encode() + b"\n")
             self.trace.flush()
 
     def _log_time(self, label: str):
@@ -588,11 +604,11 @@ class Amalgam:
         """
         if self.trace:
             dt = datetime.now()
-            self.trace.write(f"# TIME {label} {dt:%Y-%m-%d %H:%M:%S},"
-                             f"{f'{dt:%f}'[:3]}\n")
+            time_str = f"{label} {dt:%Y-%m-%d %H:%M:%S},{f'{dt:%f}'[:3]}"
+            self.trace.write(b"# TIME " + time_str.encode() + b"\n")
             self.trace.flush()
 
-    def _log_execution(self, execution_string: str):
+    def _log_execution(self, execution_string: bytes):
         """
         Log an execution string.
 
@@ -601,7 +617,7 @@ class Amalgam:
 
         Parameters
         ----------
-        execution_string : str
+        execution_string : bytes
             A formatted string that can be piped into an amalgam command line
             process for use in debugging.
 
@@ -610,9 +626,35 @@ class Amalgam:
                 string passed is valid.
         """
         if self.trace:
-            self.trace.write(execution_string + "\n")
+            self.trace.write(execution_string + b"\n")
             self.trace.flush()
 
+    def _log_execution_std(self, command: bytes, *args: str, suffix: str | bytes | None = None) -> None:
+        """
+        Log an execution string in a canonical form.
+
+        This looks like ``COMMAND "arg" "arg" suffix``.
+
+        Parameters
+        ----------
+        command : bytes
+            The trace file command string.
+        args : str
+            Arbitrary parameters to the command, will have double quotes escaped.
+        suffix : bytes, optional
+            Arbitrary binary data to append to the command string unprocessed.
+        """
+        if not self.trace:
+            return
+        words = [b"\"" + self.escape_double_quotes(arg).encode() + b"\"" for arg in args]
+        words.insert(0, command)
+        if isinstance(suffix, str):
+            words.append(suffix.encode())
+        elif isinstance(suffix, bytes):
+            words.append(suffix)
+        self.trace.write(b" ".join(words) + b"\n")
+        self.trace.flush()
+
     def gc(self):
         """Force garbage collection when called if self.force_gc is set."""
         if (
@@ -720,10 +762,7 @@ class Amalgam:
         handle_buf = self.str_to_char_p(handle)
         label_buf = self.str_to_char_p(label)
 
-        self._log_execution((
-            f"GET_JSON_FROM_LABEL \"{self.escape_double_quotes(handle)}\" "
-            f"\"{self.escape_double_quotes(label)}\""
-        ))
+        self._log_execution_std(b"GET_JSON_FROM_LABEL", handle, label)
         result = self.char_p_to_bytes(self.amlg.GetJSONPtrFromLabel(handle_buf, label_buf))
         self._log_reply(result)
 
@@ -757,11 +796,7 @@ class Amalgam:
         label_buf = self.str_to_char_p(label)
         json_buf = self.str_to_char_p(json)
 
-        self._log_execution((
-            f"SET_JSON_TO_LABEL \"{self.escape_double_quotes(handle)}\" "
-            f"\"{self.escape_double_quotes(label)}\" "
-            f"{json}"
-        ))
+        self._log_execution_std(b"SET_JSON_TO_LABEL", handle, label, suffix=json)
         self.amlg.SetJSONToLabel(handle_buf, label_buf, json_buf)
         self._log_reply(None)
 
@@ -779,7 +814,8 @@ class Amalgam:
         persist: bool = False,
         json_file_params: str = "",
         write_log: str = "",
-        print_log: str = ""
+        print_log: str = "",
+        entity_path: list[str] | None = None,
     ) -> LoadEntityStatus:
         """
         Load an entity from an amalgam source file.
@@ -805,6 +841,9 @@ class Amalgam:
         print_log : str, default ""
             Path to the print log. If empty string, the print log is
             not generated.
+        entity_path: list[str], optional
+            If provided and non-empty, load the content into an entity
+            contained within `handle` at this path.
 
         Returns
         -------
@@ -812,7 +851,8 @@ class Amalgam:
             Status of LoadEntity call.
         """
         self.amlg.LoadEntity.argtypes = [
-            c_char_p, c_char_p, c_char_p, c_bool, c_char_p, c_char_p, c_char_p]
+            c_char_p, c_char_p, c_char_p, c_bool, c_char_p, c_char_p, c_char_p, POINTER(c_char_p),
+            c_size_t]
         self.amlg.LoadEntity.restype = _LoadEntityStatus
         handle_buf = self.str_to_char_p(handle)
         file_path_buf = self.str_to_char_p(file_path)
@@ -820,18 +860,26 @@ class Amalgam:
         json_file_params_buf = self.str_to_char_p(json_file_params)
         write_log_buf = self.str_to_char_p(write_log)
         print_log_buf = self.str_to_char_p(print_log)
+        entity_path_p = None
+        entity_path_len = 0
 
-        load_command_log_entry = (
+        if entity_path is not None and len(entity_path) > 0:
+            entity_path_len = len(entity_path)
+            entity_path_p = (c_char_p * entity_path_len)()
+            for i, entry in enumerate(entity_path):
+                entity_path_p[i] = cast(self.str_to_char_p(entry), c_char_p)
+
+        self.load_command_log_entry = (
             f"LOAD_ENTITY \"{self.escape_double_quotes(handle)}\" "
             f"\"{self.escape_double_quotes(file_path)}\" "
             f"\"{self.escape_double_quotes(file_type)}\" {str(persist).lower()} "
             f"{json_lib.dumps(json_file_params)} "
-            f"\"{write_log}\" \"{print_log}\""
-        )
-        self._log_execution(load_command_log_entry)
+            f"\"{write_log}\" \"{print_log}\" \"\" \"{' '.join(entity_path or [])}\""
+        ).encode()
+        self._log_execution(self.load_command_log_entry)
         result = LoadEntityStatus(self, self.amlg.LoadEntity(
             handle_buf, file_path_buf, file_type_buf, persist,
-            json_file_params_buf, write_log_buf, print_log_buf))
+            json_file_params_buf, write_log_buf, print_log_buf, entity_path_p, entity_path_len))
         self._log_reply(result)
 
         del handle_buf
@@ -840,6 +888,98 @@ class Amalgam:
         del json_file_params_buf
         del write_log_buf
         del print_log_buf
+        if entity_path_p is not None:
+            for i in range(entity_path_len):
+                entry_buf = entity_path_p[i]
+                del entry_buf
+            del entity_path_p
+        self.gc()
+
+        return result
+
+    def load_entity_from_memory(
+        self,
+        handle: str,
+        contents: bytes,
+        *,
+        file_type: str,
+        json_file_params: str = "",
+        write_log: str = "",
+        print_log: str = "",
+        entity_path: list[str] | None = None,
+    ) -> LoadEntityStatus:
+        """
+        Load an entity from an in-memory buffer.
+
+        Parameters
+        ----------
+        handle : str
+            The handle to assign the entity.
+        contents : bytes
+            The content to load.
+        file_type : str
+            The type of file to store, typically ``"amlg"`` for plain-text Amalgam or ``"caml"``
+            for binary compressed Amalgam.
+        json_file_params : str, default ""
+            Either empty string or a string of json specifying a set of key-value pairs
+            which are parameters specific to the file type.  See Amalgam documentation
+            for details of allowed parameters.
+        write_log : str, default ""
+            Path to the write log. If empty string, the write log is
+            not generated.
+        print_log : str, default ""
+            Path to the print log. If empty string, the print log is
+            not generated.
+        entity_path: list[str], optional
+            If provided and non-empty, load the content into an entity
+            contained within `handle` at this path.
+
+        Returns
+        -------
+        LoadEntityStatus
+            Status of LoadEntity call.
+        """
+        self.amlg.LoadEntityFromMemory.argtypes = [
+            c_char_p, c_void_p, c_size_t, c_char_p, c_bool, c_char_p, c_char_p, c_char_p, POINTER(c_char_p),
+            c_size_t]
+        self.amlg.LoadEntityFromMemory.restype = _LoadEntityStatus
+        handle_buf = self.str_to_char_p(handle)
+        file_type_buf = self.str_to_char_p(file_type)
+        json_file_params_buf = self.str_to_char_p(json_file_params)
+        write_log_buf = self.str_to_char_p(write_log)
+        print_log_buf = self.str_to_char_p(print_log)
+        entity_path_p = None
+        entity_path_len = 0
+
+        if entity_path is not None and len(entity_path) > 0:
+            entity_path_len = len(entity_path)
+            entity_path_p = (c_char_p * entity_path_len)()
+            for i, entry in enumerate(entity_path):
+                entity_path_p[i] = cast(self.str_to_char_p(entry), c_char_p)
+
+        self.load_command_log_entry = (
+            f"LOAD_ENTITY_FROM_MEMORY \"{self.escape_double_quotes(handle)}\" "
+            f"\"{b64encode(contents).decode()}\" "
+            f"\"{self.escape_double_quotes(file_type)}\" false "
+            f"{json_lib.dumps(json_file_params)} "
+            f"\"{write_log}\" \"{print_log}\" \"\" \"{' '.join(entity_path or [])}\""
+        ).encode()
+        self._log_execution(self.load_command_log_entry)
+        result = LoadEntityStatus(self, self.amlg.LoadEntityFromMemory(
+            handle_buf, contents, len(contents), file_type_buf, False,
+            json_file_params_buf, write_log_buf, print_log_buf, entity_path_p, entity_path_len))
+        self._log_reply(result)
+
+        del handle_buf
+        del file_type_buf
+        del json_file_params_buf
+        del write_log_buf
+        del print_log_buf
+        if entity_path_p is not None:
+            for i in range(entity_path_len):
+                entry_buf = entity_path_p[i]
+                del entry_buf
+            del entity_path_p
         self.gc()
 
         return result
@@ -865,7 +1005,7 @@ class Amalgam:
         self.amlg.VerifyEntity.restype = _LoadEntityStatus
         file_path_buf = self.str_to_char_p(file_path)
 
-        self._log_execution(f"VERIFY_ENTITY \"{self.escape_double_quotes(file_path)}\"")
+        self._log_execution_std(b"VERIFY_ENTITY", file_path)
         result = LoadEntityStatus(self, self.amlg.VerifyEntity(file_path_buf))
         self._log_reply(result)
 
@@ -895,7 +1035,7 @@ class Amalgam:
         self.amlg.GetEntityPermissions.restype = POINTER(c_char)
         handle_buf = self.str_to_char_p(handle)
 
-        self._log_execution(f"GET_ENTITY_PERMISSIONS \"{self.escape_double_quotes(handle)}\"")
+        self._log_execution_std(b"GET_ENTITY_PERMISSIONS", handle)
         result = self.char_p_to_bytes(self.amlg.GetEntityPermissions(handle_buf))
         self._log_reply(result)
 
@@ -931,11 +1071,7 @@ class Amalgam:
         handle_buf = self.str_to_char_p(handle)
         json_permissions_buf = self.str_to_char_p(json_permissions)
 
-        set_permissions_log_entry = (
-            f"SET_ENTITY_PERMISSIONS \"{self.escape_double_quotes(handle)}\" "
-            f"{json_permissions}"
-        )
-        self._log_execution(set_permissions_log_entry)
+        self._log_execution_std(b"SET_ENTITY_PERMISSIONS", handle, suffix=json_permissions)
         result = self.amlg.SetEntityPermissions(handle_buf, json_permissions_buf)
         self._log_reply(result)
 
@@ -999,15 +1135,13 @@ class Amalgam:
         write_log_buf = self.str_to_char_p(write_log)
         print_log_buf = self.str_to_char_p(print_log)
 
-        clone_command_log_entry = (
-            f'CLONE_ENTITY "{self.escape_double_quotes(handle)}" '
-            f'"{self.escape_double_quotes(clone_handle)}" '
-            f"\"{self.escape_double_quotes(file_path)}\" "
-            f"\"{self.escape_double_quotes(file_type)}\" {str(persist).lower()} "
-            f"{json_lib.dumps(json_file_params)} "
-            f"\"{write_log}\" \"{print_log}\""
+        self._log_execution_std(b"CLONE_ENTITY", handle, clone_handle, file_path, file_type,
+                                suffix=(
+                                    f"{str(persist).lower()} "
+                                    f"{json_lib.dumps(json_file_params)} "
+                                    f"\"{write_log}\" \"{print_log}\""
+                                )
         )
-        self._log_execution(clone_command_log_entry)
         result = self.amlg.CloneEntity(
             handle_buf, clone_handle_buf, file_path_buf, file_type_buf, persist,
             json_file_params_buf, write_log_buf, print_log_buf)
@@ -1032,7 +1166,8 @@ class Amalgam:
         file_type: str = "",
         persist: bool = False,
         json_file_params: str = "",
-    ):
+        entity_path: list[str] | None = None,
+    ) -> bool:
         """
         Store entity to the file type specified within file_path.
 
@@ -1051,30 +1186,122 @@ class Amalgam:
             Either empty string or a string of json specifying a set of key-value pairs
             which are parameters specific to the file type.  See Amalgam documentation
             for details of allowed parameters.
+        entity_path: list[str], optional
+            If provided and non-empty, store the content from an entity
+            contained within `handle` at this path.
+
+        Returns
+        -------
+        bool
+            True if the entity file was saved successfully, False otherwise.
         """
         self.amlg.StoreEntity.argtypes = [
-            c_char_p, c_char_p, c_char_p, c_bool, c_char_p]
+            c_char_p, c_char_p, c_char_p, c_bool, c_char_p, POINTER(c_char_p), c_size_t]
+        self.amlg.StoreEntity.restype = c_bool
         handle_buf = self.str_to_char_p(handle)
         file_path_buf = self.str_to_char_p(file_path)
         file_type_buf = self.str_to_char_p(file_type)
         json_file_params_buf = self.str_to_char_p(json_file_params)
-
-        store_command_log_entry = (
-            f"STORE_ENTITY \"{self.escape_double_quotes(handle)}\" "
-            f"\"{self.escape_double_quotes(file_path)}\" "
-            f"\"{self.escape_double_quotes(file_type)}\" {str(persist).lower()} "
-            f"{json_lib.dumps(json_file_params)} "
-        )
-        self._log_execution(store_command_log_entry)
-        self.amlg.StoreEntity(
-            handle_buf, file_path_buf, file_type_buf, persist, json_file_params_buf)
-        self._log_reply(None)
+        entity_path_p = None
+        entity_path_len = 0
+
+        if entity_path is not None and len(entity_path) > 0:
+            entity_path_len = len(entity_path)
+            entity_path_p = (c_char_p * entity_path_len)()
+            for i, entry in enumerate(entity_path):
+                entity_path_p[i] = self.str_to_char_p(entry)
+
+        self._log_execution_std(b"STORE_ENTITY", handle, file_path, file_type,
+                                suffix=f"{str(persist).lower()} {json_lib.dumps(json_file_params)} \"{' '.join(entity_path or [])}\"")
+        result = self.amlg.StoreEntity(
+            handle_buf, file_path_buf, file_type_buf, persist, json_file_params_buf, entity_path_p, entity_path_len)
+        self._log_reply(result)
 
         del handle_buf
         del file_path_buf
         del file_type_buf
         del json_file_params_buf
+        if entity_path_p is not None:
+            for i in range(entity_path_len):
+                entry_buf = entity_path_p[i]
+                del entry_buf
+            del entity_path_p
+        self.gc()
+        return result
+
+    def store_entity_to_memory(
+        self,
+        handle: str,
+        *,
+        file_type: str,
+        json_file_params: str = "",
+        entity_path: list[str] | None = None,
+    ) -> bytes | None:
+        """
+        Store entity to memory as a bytes object.
+
+        Parameters
+        ----------
+        handle : str
+            The handle of the amalgam entity.
+        file_type : str
+            The type of file to store, typically ``"amlg"`` for plain-text Amalgam or ``"caml"``
+            for binary compressed Amalgam.
+        json_file_params : str, default ""
+            Either empty string or a string of json specifying a set of key-value pairs
+            which are parameters specific to the file type.  See Amalgam documentation
+            for details of allowed parameters.
+        entity_path: list[str], optional
+            If provided and non-empty, store the content from an entity
+            contained within `handle` at this path.
+
+        Returns
+        -------
+        bytes | None
+            The serialized entity contents, or None on an error.
+        """
+        self.amlg.StoreEntityToMemory.argtypes = [
+            c_char_p, POINTER(c_void_p), POINTER(c_size_t), c_char_p, c_bool, c_char_p, POINTER(c_char_p), c_size_t]
+        self.amlg.StoreEntityToMemory.restype = c_bool
+        handle_buf = self.str_to_char_p(handle)
+        data_p = c_void_p(None)
+        data_len = c_size_t(0)
+        file_type_buf = self.str_to_char_p(file_type)
+        json_file_params_buf = self.str_to_char_p(json_file_params)
+        entity_path_p = None
+        entity_path_len = 0
+
+        if entity_path is not None and len(entity_path) > 0:
+            entity_path_len = len(entity_path)
+            entity_path_p = (c_char_p * entity_path_len)()
+            for i, entry in enumerate(entity_path):
+                entity_path_p[i] = self.str_to_char_p(entry)
+
+        self._log_execution_std(b"STORE_ENTITY_TO_MEMORY", handle, file_type,
+                                suffix=f"false {json_lib.dumps(json_file_params)} \"{' '.join(entity_path or [])}\"")
+        self.amlg.StoreEntityToMemory(
+            handle_buf, byref(data_p), byref(data_len), file_type_buf, False, json_file_params_buf, entity_path_p, entity_path_len)
+
+        result = None
+        if data_p.value is not None:
+            result = string_at(data_p.value, data_len.value)
+            self.amlg.DeleteString.argtypes = [c_char_p]
+            self.amlg.DeleteString.restype = None
+            self.amlg.DeleteString(cast(data_p, c_char_p))
+            self._log_reply(b64encode(result).decode())
+        else:
+            self._log_reply(None)
+
+        del handle_buf
+        del file_type_buf
+        del json_file_params_buf
+        if entity_path_p is not None:
+            for i in range(entity_path_len):
+                entry_buf = entity_path_p[i]
+                del entry_buf
+            del entity_path_p
         self.gc()
+        return result
 
     def destroy_entity(
         self,
@@ -1091,7 +1318,7 @@ class Amalgam:
         self.amlg.DestroyEntity.argtypes = [c_char_p]
         handle_buf = self.str_to_char_p(handle)
 
-        self._log_execution(f"DESTROY_ENTITY \"{self.escape_double_quotes(handle)}\"")
+        self._log_execution_std(b"DESTROY_ENTITY", handle)
         self.amlg.DestroyEntity(handle_buf)
         self._log_reply(None)
 
@@ -1124,8 +1351,7 @@ class Amalgam:
         handle_buf = self.str_to_char_p(handle)
         rand_seed_buf = self.str_to_char_p(rand_seed)
 
-        self._log_execution(f'SET_RANDOM_SEED "{self.escape_double_quotes(handle)}" '
-                            f'"{self.escape_double_quotes(rand_seed)}"')
+        self._log_execution_std(b"SET_RANDOM_SEED", handle, rand_seed)
         result = self.amlg.SetRandomSeed(handle_buf, rand_seed_buf)
         self._log_reply(None)
 
@@ -1186,12 +1412,7 @@ class Amalgam:
         json_buf = self.str_to_char_p(json)
 
         self._log_time("EXECUTION START")
-        self._log_execution((
-            "EXECUTE_ENTITY_JSON "
-            f"\"{self.escape_double_quotes(handle)}\" "
-            f"\"{self.escape_double_quotes(label)}\" "
-            f"{json}"
-        ))
+        self._log_execution_std(b"EXECUTE_ENTITY_JSON", handle, label, suffix=json)
         result = self.char_p_to_bytes(self.amlg.ExecuteEntityJsonPtr(
             handle_buf, label_buf, json_buf))
         self._log_time("EXECUTION STOP")
@@ -1236,12 +1457,7 @@ class Amalgam:
         json_buf = self.str_to_char_p(json)
 
         self._log_time("EXECUTION START")
-        self._log_execution((
-            "EXECUTE_ENTITY_JSON_LOGGED "
-            f"\"{self.escape_double_quotes(handle)}\" "
-            f"\"{self.escape_double_quotes(label)}\" "
-            f"{json}"
-        ))
+        self._log_execution_std(b"EXECUTE_ENTITY_JSON_LOGGED", handle, label, suffix=json)
         result = ResultWithLog.from_c_result(self, self.amlg.ExecuteEntityJsonPtrLogged(
             handle_buf, label_buf, json_buf))
         self._log_time("EXECUTION STOP")
@@ -1256,7 +1472,7 @@ class Amalgam:
     def eval_on_entity(
         self,
         handle: str,
-        amlg: str
+        amlg: str | bytes
     ) -> bytes:
         """
         Execute arbitrary Amalgam code against an entity.
@@ -1265,7 +1481,7 @@ class Amalgam:
         ----------
         handle : str
             The handle of the amalgam entity.
-        amlg : str
+        amlg : str | bytes
             The code to execute.
 
         Returns
@@ -1281,11 +1497,7 @@ class Amalgam:
         amlg_buf = self.str_to_char_p(amlg)
 
         self._log_time("EXECUTION START")
-        self._log_execution((
-            "EVAL_ON_ENTITY "
-            f"\"{self.escape_double_quotes(handle)}\" "
-            f"\"{self.escape_double_quotes(amlg)}\""
-        ))
+        self._log_execution_std(b"EVAL_ON_ENTITY", handle, str(amlg))
         result = self.char_p_to_bytes(self.amlg.EvalOnEntity(
             handle_buf, amlg_buf))
         self._log_time("EXECUTION STOP")

amalgam/lib/darwin/arm64/docs/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "63.0.2"
+  "version": "71.0.0"
 }

amalgam/lib/version.json

@@ -1,8 +1,8 @@
 {
   "version": {
-    "amalgam": "63.0.2",
-    "amalgam_sha": "ef44c8dc3bccad4141cec35f32852a35ebe667da",
-    "amalgam_url": "https://github.com/howsoai/amalgam/releases/tag/63.0.2",
+    "amalgam": "71.0.0",
+    "amalgam_sha": "9a65d4226a5166e9e3968057a603287096fa7005",
+    "amalgam_url": "https://github.com/howsoai/amalgam/releases/tag/71.0.0",
     "amalgam_build_date": "",
     "amalgam_display_title": ""
   }

{amalgam_lang-20.0.2.dist-info → amalgam_lang-25.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amalgam-lang
-Version: 20.0.2
+Version: 25.2.5
 Summary: A direct interface with Amalgam compiled DLL, dylib, or so.
 Author: Howso Incorporated
 Author-email: support@howso.com
@@ -675,7 +675,6 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -686,7 +685,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Microsoft :: Windows :: Windows 10
 Classifier: Operating System :: Microsoft :: Windows :: Windows 11
 Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Provides-Extra: dev
@@ -714,7 +713,7 @@ Coding in [Amalgam](https://github.com/howsoai/amalgam) can be done natively as
 
 ## Supported Platforms
 
-Compatible with Python versions: 3.9, 3.10, 3.11, 3.12, and 3.13.
+Compatible with Python versions: 3.10, 3.11, 3.12, and 3.13.
 
 #### Operating Systems
 

amalgam_lang-25.2.5.dist-info/RECORD

@@ -0,0 +1,12 @@
+amalgam/__init__.py,sha256=oHu7Zr4eGDUqj93pLwz8t7gLa8lpAx6Q-xbGiJ3nJx0,18
+amalgam/api.py,sha256=2LeiTkl6FLdd-MDDHjkWAl7vLOnI3eUXF1FeV9fEkGQ,53792
+amalgam/lib/version.json,sha256=KLIEcoEJPWvPnfdbzhK0grsTolOYwMz_29lG2g-qcas,250
+amalgam/lib/darwin/arm64/amalgam-mt.dylib,sha256=8XphNYzG6P31ZviKFc_8NEudhf1T3B-7vmuinM77lh4,3362896
+amalgam/lib/darwin/arm64/amalgam-omp.dylib,sha256=La4iFFCNoyplm64Ps5EEiVt8fnEmOYDA-emB2RVQsBk,3700560
+amalgam/lib/darwin/arm64/amalgam-st.dylib,sha256=Hsu5IeZBCnk-8b6ozrkMUXkeW-VNVEDQ4UO8b8tnvI0,3144768
+amalgam/lib/darwin/arm64/docs/version.json,sha256=DGQGMrgbSvJpyyK_YIzD8RF4xP8dAjQgiIsJ3sWHv3w,25
+amalgam_lang-25.2.5.dist-info/licenses/LICENSE.txt,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+amalgam_lang-25.2.5.dist-info/METADATA,sha256=0V6bApR_dTvfvRdqJleSkpeEeUrLxNdXSE2jzDoqwRQ,43832
+amalgam_lang-25.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amalgam_lang-25.2.5.dist-info/top_level.txt,sha256=rmPHU144SyaB25u5-FAQyECAQnJ39NvuJEcKXMRcdBo,8
+amalgam_lang-25.2.5.dist-info/RECORD,,

amalgam_lang-20.0.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-amalgam/__init__.py,sha256=oHu7Zr4eGDUqj93pLwz8t7gLa8lpAx6Q-xbGiJ3nJx0,18
-amalgam/api.py,sha256=zS2h1oKrNmXNERicQt6dcpjrOQ9XVm5PTf37AIDlMTI,44799
-amalgam/lib/version.json,sha256=W2qXXdNREbzHXVO0UKN4ajwB-IFPwD5DNKlzgGpmGK0,250
-amalgam/lib/darwin/arm64/amalgam-mt.dylib,sha256=9qVrSakUqC11nGbfSR3SuZVArDKfz3PaGmpHIcYLK0w,2951696
-amalgam/lib/darwin/arm64/amalgam-omp.dylib,sha256=eRAzV9wSZCrTgwV1j1e1DPFN5675RMwGJx397HZH-qE,3313728
-amalgam/lib/darwin/arm64/amalgam-st.dylib,sha256=y-mcPzMjfBCaQmeeNYL59dc5YDL15r5S5LcEp9Ab-GU,2783280
-amalgam/lib/darwin/arm64/docs/version.json,sha256=Yg7pfVbtDLaoqfdzh_PyMWGT90q46seEaJ3NSDe-4QU,25
-amalgam_lang-20.0.2.dist-info/licenses/LICENSE.txt,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
-amalgam_lang-20.0.2.dist-info/METADATA,sha256=jML8rmgRW4YKfGGdxONHp1nqsPSr3GNiDGGZeYN7S00,43886
-amalgam_lang-20.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-amalgam_lang-20.0.2.dist-info/top_level.txt,sha256=rmPHU144SyaB25u5-FAQyECAQnJ39NvuJEcKXMRcdBo,8
-amalgam_lang-20.0.2.dist-info/RECORD,,