tessl/pypi-jsonpickle

Python library for encoding/decoding any Python object to/from JSON

—

Pending

Overview

Eval results

Files

Extension Modules

Name: tessl/pypi-jsonpickle
Author: tessl

Built-in extensions for popular Python libraries including numpy, pandas, GMPY, and YAML integration. These extensions provide specialized handlers for complex data types.

Capabilities

NumPy Extension

Comprehensive support for NumPy arrays, data types, and generic objects with multiple serialization strategies.

from jsonpickle.ext import numpy

def register_handlers():
    """Register all NumPy handlers with jsonpickle"""

def unregister_handlers():
    """Remove all NumPy handlers from jsonpickle"""

def get_byteorder():
    """Get the system byte order for array serialization"""

# Handler classes
class NumpyBaseHandler(BaseHandler):
    """Base handler for NumPy objects"""

class NumpyDTypeHandler(BaseHandler):
    """Handler for NumPy data types"""

class NumpyGenericHandler(BaseHandler):
    """Handler for NumPy generic scalar types"""

class NumpyDatetimeHandler(BaseHandler):
    """Handler for NumPy datetime types"""

class UnpickleableNumpyGenericHandler(BaseHandler):
    """Handler for unpickleable NumPy generic types"""

class NumpyNDArrayHandler(BaseHandler):
    """Handler for NumPy N-dimensional arrays"""

class NumpyNDArrayHandlerBinary(BaseHandler):
    """Binary serialization handler for NumPy arrays"""

class NumpyNDArrayHandlerView(BaseHandler):
    """View-based handler for NumPy arrays"""

NumPy Usage Example:

import numpy as np
import jsonpickle
from jsonpickle.ext import numpy

# Register NumPy handlers
numpy.register_handlers()

# Serialize NumPy arrays
arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
json_str = jsonpickle.encode(arr)
restored_arr = jsonpickle.decode(json_str)

# Serialize NumPy data types
dtype = np.dtype('float64')
json_str = jsonpickle.encode(dtype)
restored_dtype = jsonpickle.decode(json_str)

# Serialize NumPy scalars
scalar = np.float64(3.14159)
json_str = jsonpickle.encode(scalar)
restored_scalar = jsonpickle.decode(json_str)

# Unregister when done (optional)
numpy.unregister_handlers()

Pandas Extension

Support for pandas DataFrames, Series, Index objects, and time-related data types.

from jsonpickle.ext import pandas

def register_handlers():
    """Register all pandas handlers with jsonpickle"""

def unregister_handlers():
    """Remove all pandas handlers from jsonpickle"""

def pd_encode(obj):
    """Encode pandas objects to dictionary format"""

def pd_decode(data):
    """Decode dictionary data back to pandas objects"""

def rle_encode(types):
    """Run-length encode type arrays for efficiency"""

def rle_decode(encoded_types):
    """Decode run-length encoded type arrays"""

def make_read_csv_params(data):
    """Create parameters for CSV reading operations"""

# Handler classes
class PandasProcessor:
    """Process pandas objects for serialization"""

class PandasDfHandler(BaseHandler):
    """Handler for pandas DataFrame objects"""

class PandasSeriesHandler(BaseHandler):
    """Handler for pandas Series objects"""

class PandasIndexHandler(BaseHandler):
    """Handler for pandas Index objects"""

class PandasPeriodIndexHandler(BaseHandler):
    """Handler for pandas PeriodIndex objects"""

class PandasMultiIndexHandler(BaseHandler):
    """Handler for pandas MultiIndex objects"""

class PandasTimestampHandler(BaseHandler):
    """Handler for pandas Timestamp objects"""

class PandasPeriodHandler(BaseHandler):
    """Handler for pandas Period objects"""

class PandasIntervalHandler(BaseHandler):
    """Handler for pandas Interval objects"""

Pandas Usage Example:

import pandas as pd
import jsonpickle
from jsonpickle.ext import pandas

# Register pandas handlers
pandas.register_handlers()

# Serialize DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': ['x', 'y', 'z'],
    'C': pd.date_range('2023-01-01', periods=3)
})
json_str = jsonpickle.encode(df)
restored_df = jsonpickle.decode(json_str)

# Serialize Series
series = pd.Series([1, 2, 3, 4], name='numbers')
json_str = jsonpickle.encode(series)
restored_series = jsonpickle.decode(json_str)

# Serialize Index objects
index = pd.date_range('2023-01-01', periods=10, freq='D')
json_str = jsonpickle.encode(index)
restored_index = jsonpickle.decode(json_str)

# Serialize MultiIndex
multi_index = pd.MultiIndex.from_tuples([
    ('A', 1), ('A', 2), ('B', 1), ('B', 2)
], names=['letter', 'number'])
json_str = jsonpickle.encode(multi_index)
restored_multi = jsonpickle.decode(json_str)

# Unregister when done (optional)
pandas.unregister_handlers()

GMPY Extension

Support for GMPY (GNU Multiple Precision Arithmetic) high-precision integer types.

from jsonpickle.ext import gmpy

def register_handlers():
    """Register GMPY handlers with jsonpickle"""

def unregister_handlers():
    """Remove GMPY handlers from jsonpickle"""

# Handler classes
class GmpyMPZHandler(BaseHandler):
    """Handler for GMPY MPZ (arbitrary precision integer) objects"""

GMPY Usage Example:

import gmpy2
import jsonpickle
from jsonpickle.ext import gmpy

# Register GMPY handlers
gmpy.register_handlers()

# Serialize high-precision integers
big_int = gmpy2.mpz(2**1000)  # Very large integer
json_str = jsonpickle.encode(big_int)
restored_int = jsonpickle.decode(json_str)

assert big_int == restored_int

# Unregister when done (optional)
gmpy.unregister_handlers()

YAML Extension

Integration with YAML backends for YAML serialization support.

from jsonpickle.ext import yaml

def register(backend=None):
    """Register YAML as a backend for jsonpickle"""

YAML Usage Example:

import jsonpickle
from jsonpickle.ext import yaml

# Register YAML backend
yaml.register()

# Set YAML as preferred backend
jsonpickle.set_preferred_backend('yaml')

# Now jsonpickle will output YAML instead of JSON
obj = {'name': 'Alice', 'data': [1, 2, 3]}
yaml_str = jsonpickle.encode(obj)  # Outputs YAML format
restored_obj = jsonpickle.decode(yaml_str)

Extension Usage Patterns

Automatic Registration at Import

# Register extension handlers automatically
import jsonpickle
from jsonpickle.ext import numpy, pandas

# Extensions auto-register on import
numpy.register_handlers()
pandas.register_handlers()

# Now all numpy/pandas objects are supported
data = {
    'array': np.array([1, 2, 3]),
    'dataframe': pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
}
json_str = jsonpickle.encode(data)

Conditional Extension Loading

import jsonpickle

# Only load extensions if libraries are available
try:
    import numpy as np
    from jsonpickle.ext import numpy
    numpy.register_handlers()
    HAS_NUMPY = True
except ImportError:
    HAS_NUMPY = False

try:
    import pandas as pd
    from jsonpickle.ext import pandas
    pandas.register_handlers()
    HAS_PANDAS = True
except ImportError:
    HAS_PANDAS = False

Selective Handler Registration

from jsonpickle.ext import numpy
import jsonpickle.handlers

# Register only specific NumPy handlers
registry = jsonpickle.handlers.registry
registry.register(np.ndarray, numpy.NumpyNDArrayHandler())
registry.register(np.dtype, numpy.NumpyDTypeHandler())

Performance Considerations

NumPy: Binary handlers provide better performance for large arrays
Pandas: Consider using unpicklable=False for simpler data export
Extension Overhead: Only register extensions you actually need
Memory Usage: Large arrays and DataFrames consume significant memory during serialization

Compatibility Notes

NumPy: Supports NumPy 1.10+ with automatic dtype preservation
Pandas: Supports pandas 0.20+ with full Index hierarchy support
GMPY: Requires gmpy2 library for high-precision arithmetic
YAML: Requires PyYAML library for YAML backend functionality

These extensions integrate seamlessly with jsonpickle's core functionality and can be mixed with custom handlers for comprehensive serialization support.

Install with Tessl CLI