PyPI - opak - Versions diffs - 0.1.0__tar.gz - Mend

@@ -0,0 +1,258 @@
+from __future__ import annotations
+__all__ = ['encode', 'decode', 'json_patch', 'msgpack_patch']
+from base64 import b64decode, b64encode
+from typing import TYPE_CHECKING, Any, Callable
+from numpy import frombuffer, generic, ndarray
+from numpy.lib.format import descr_to_dtype, dtype_to_descr
+import pickle,inspect,sys
+cast = True
+try:
+    from oasm import table
+except:
+    table = None
+if TYPE_CHECKING:  # pragma: no cover
+    from _typeshed import SupportsRead
+def encode(
+    o: Any, *, b64: bool = False, chain: Callable[[Any], dict[str, Any]] | None = None
+) -> dict[str, Any]:
+    """Encodes numpy objects to a dict-serializable dictionary.
+    Args:
+        o (object): The object to encode.
+        chain (Callable[[Any], dict[str, Any]] | None): A fallback encoder function to handle objects that are not numpy objects.
+    Returns:
+        dict[str, Any]: The dict-serializable dictionary representation of the numpy object, or the result of the fallback encoder if present and if the object is not a numpy object.
+    Raises:
+        TypeError: If the object is not dict serializable.
+    """
+    if isinstance(o, (ndarray, generic)):
+        if o.dtype == 'O':
+            data = o.dumps()
+        elif o.flags['C_CONTIGUOUS']:
+            data = o.data
+        else:
+            data = o.tobytes()
+        return {
+            "__numpy__": b64encode(data).decode() if b64 else bytes(data),
+            "dtype": dtype_to_descr(o.dtype),
+            "shape": list(o.shape),
+        }
+    elif isinstance(o, complex):
+        return {'__complex__':o.__repr__()}
+    elif cast and (type(o) is type or type(o).__name__ == 'function'):
+        try:
+            return {'':[o.__name__,inspect.getsource(o)]}|(
+                {} if type(o) is type else o.__dict__)
+        except:
+            pass
+    elif table is not None and isinstance(o, table):
+        return table.to_dict(o)
+    module = getattr(o,'__module__',None)
+    name = getattr(o,'__name__',None)
+    if cast and (module is not None and name is not None):
+        return {'':module+'.'+name}
+    return o if chain is None else chain(o)
+env = globals()
+def decode(dct: dict, b64: bool = False, chain: Callable[[Any], dict[str, Any]] | None = None) -> dict | ndarray | generic:
+    """Custom object hook function for decoding dict objects into numpy arrays.
+    Args:
+        dct (dict): The dictionary to decode.
+    Returns:
+        dict | np.ndarray | np.generic: The decoded numpy object or the original dictionary.
+    """
+    if "__numpy__" in dct:
+        data = dct['__numpy__']
+        if b64:
+            data = b64decode(data)
+        dtype = descr_to_dtype(dct['dtype'])
+        if dtype == 'O':
+            return pickle.loads(data)
+        else:
+            obj = frombuffer(data,dtype)
+            return obj.reshape(shape) if (shape := dct['shape']) else obj[0]
+    elif '__complex__' in dct:
+        return complex(dct['__complex__'])
+    elif cast and ('' in dct):
+        obj = dct['']
+        if type(obj) is str:
+            obj = obj.split('.')
+            module = sys.modules.get('.'.join(obj[:-1]),None)
+            return None if module is None else getattr(module,obj[-1],None)
+        else:
+            obj,src = obj
+        if obj == '<lambda>':
+            obj = eval('lambda '+'lambda'.join(src.split('lambda')[1:]).strip(),env)
+        else:
+            exec(src,env)
+            obj = env[obj]
+        del dct['']
+        if type(obj) is not type:
+            obj.__dict__.update(dct)
+        return obj
+    if table is not None:
+        dct = table.from_dict(dct)
+    return dct if chain is None else chain(dct)
+import json
+_dumps = json.dumps
+_loads = json.loads
+_dump = json.dump
+def _encoder(
+    *args: Any,
+    default: Callable[[Any], Any] | None = None,
+    user_cls: type[json.JSONEncoder] | None = None,
+    **kwargs: Any,
+) -> json.JSONEncoder:
+    """Ensures cooperation with the provided `default` and/or `cls` by manipulating the JSONEncoder."""
+    if user_cls is None:
+        user_cls = json.JSONEncoder
+    elif default is None:
+        encoder = user_cls(*args, **kwargs)
+        encoder.default = lambda obj:encode(obj,b64=True,chain=encoder.default)  # type: ignore[method-assign]
+        return encoder
+    return user_cls(
+        *args, default=lambda obj:encode(obj,b64=True,chain=default), **kwargs
+    )
+def dumps(*args: Any, cls: type[json.JSONEncoder] | None = None, **kwargs: Any) -> str:
+    kwargs["user_cls"] = cls
+    return _dumps(*table.to_dict(args), cls=_encoder, **kwargs)  # type: ignore[arg-type]
+def loads(
+    *args: Any, object_hook: Callable[[dict], Any] | None = None, **kwargs: Any
+) -> Any:
+    return _loads(
+        *args,
+        object_hook=lambda dct:decode(dct,b64=True,chain=object_hook),
+        **kwargs,
+    )
+def dump(*args: Any, cls: type[json.JSONEncoder] | None = None, **kwargs: Any) -> None:
+    kwargs["user_cls"] = cls
+    return _dump(*table.to_dict(args), cls=_encoder, **kwargs)  # type: ignore[arg-type]
+def load(fp: SupportsRead[str | bytes], **kwargs: Any) -> Any:
+    return loads(fp.read(), **kwargs)
+def json_patch() -> None:
+    """Monkey patch json module to support encoding/decoding NumPy arrays/scalars."""
+    json.dumps = dumps
+    json.loads = loads
+    json.dump = dump
+    json.load = load
+try:
+    import msgpack
+    from msgpack import Packer as _Packer, Unpacker as _Unpacker, \
+        unpack as _unpack, unpackb as _unpackb
+except:
+    _Packer = object
+    _Unpacker = object
+class Packer(_Packer):
+    def __init__(self,
+                 default=None,
+                 use_single_float=False,
+                 autoreset=True,
+                 use_bin_type=True,
+                 strict_types=True,
+                 datetime=False,
+                 unicode_errors=None):
+            super(Packer, self).__init__(default=lambda obj:encode(obj,chain=default),
+                                     use_single_float=use_single_float,
+                                     autoreset=autoreset,
+                                     use_bin_type=use_bin_type,
+                                     strict_types=strict_types,
+                                     datetime=datetime,
+                                     unicode_errors=unicode_errors)
+class Unpacker(_Unpacker):
+    def __init__(self,
+                 file_like=None,
+                 read_size=0,
+                 use_list=True,
+                 raw=False,
+                 timestamp=0,
+                 strict_map_key=True,
+                 object_hook=None,
+                 object_pairs_hook=None,
+                 list_hook=None,
+                 unicode_errors=None,
+                 max_buffer_size=100 * 1024 * 1024,
+                 ext_hook=msgpack.ExtType,
+                 max_str_len=-1,
+                 max_bin_len=-1,
+                 max_array_len=-1,
+                 max_map_len=-1,
+                 max_ext_len=-1):
+        super(Unpacker, self).__init__(file_like=file_like,
+                                       read_size=read_size,
+                                       use_list=use_list,
+                                       raw=raw,
+                                       timestamp=timestamp,
+                                       strict_map_key=strict_map_key,
+                                       object_hook=lambda dct:decode(dct,chain=object_hook),
+                                       object_pairs_hook=object_pairs_hook,
+                                       list_hook=list_hook,
+                                       unicode_errors=unicode_errors,
+                                       max_buffer_size=max_buffer_size,
+                                       ext_hook=ext_hook,
+                                       max_str_len=max_str_len,
+                                       max_bin_len=max_bin_len,
+                                       max_array_len=max_array_len,
+                                       max_map_len=max_map_len,
+                                       max_ext_len=max_ext_len)
+def pack(o, stream, **kwargs):
+    """
+    Pack an object and write it to a stream.
+    """
+    packer = Packer(**kwargs)
+    stream.write(packer.pack(o))
+def packb(o, **kwargs):
+    """
+    Pack an object and return the packed bytes.
+    """
+    return Packer(**kwargs).pack(o)
+def unpack(stream, **kwargs):
+    """
+    Unpack a packed object from a stream.
+    """
+    object_hook = kwargs.get('object_hook')
+    kwargs['object_hook'] = lambda dct:decode(dct,chain=object_hook)
+    return _unpack(stream, **kwargs)
+def unpackb(packed, **kwargs):
+    """
+    Unpack a packed object.
+    """
+    object_hook = kwargs.get('object_hook')
+    kwargs['object_hook'] = lambda dct:decode(dct,chain=object_hook)
+    return _unpackb(packed, **kwargs)
+def msgpack_patch():
+    """
+    Monkey patch msgpack module to enable support for serializing numpy types.
+    """
+    setattr(msgpack, 'Packer', Packer)
+    setattr(msgpack, 'Unpacker', Unpacker)
+    setattr(msgpack, 'load', unpack)
+    setattr(msgpack, 'loads', unpackb)
+    setattr(msgpack, 'dump', pack)
+    setattr(msgpack, 'dumps', packb)
+    setattr(msgpack, 'pack', pack)
+    setattr(msgpack, 'packb', packb)
+    setattr(msgpack, 'unpack', unpack)
+    setattr(msgpack, 'unpackb', unpackb)

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: opak
+Version: 0.1.0
+Summary: Open PAcKer
+Author-email: nzturn <nzturn@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+# Open PAcKer

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: opak
+Version: 0.1.0
+Summary: Open PAcKer
+Author-email: nzturn <nzturn@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+# Open PAcKer

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+opak/__init__.py
+opak.egg-info/PKG-INFO
+opak.egg-info/SOURCES.txt
+opak.egg-info/dependency_links.txt
+opak.egg-info/requires.txt
+opak.egg-info/top_level.txt

@@ -0,0 +1,15 @@
+[project]
+name = "opak"
+version = "0.1.0"
+description = "Open PAcKer"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "nzturn", email = "nzturn@gmail.com" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Framework :: Jupyter",
+]
+dependencies = ["numpy"]

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

opak 0.1.0__tar.gz