rPickle 0.1.0__tar.gz

rpickle-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rainwalker
+
+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.

rpickle-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: rPickle
+Version: 0.1.0
+Summary: A safe and efficient Python serialization library
+Author-email: Rainwalker <lmx1w3r@outlook.com>
+License: MIT
+Keywords: serialization,pickle,binary
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-benchmark; extra == "dev"
+Dynamic: license-file
+
+# rPickle
+
+A safe and efficient Python serialization library.
+
+## Features
+
+  - 🔒 **Safe** - No arbitrary code execution, unlike `pickle`
+  - ⚡ **Fast** - Optimized binary format
+  - 📦 **Compact** - Small serialized size
+  - 🔄 **Circular references** - Handles self-referential structures
+  - 🎨 **Extensible** - Custom type support via extensions
+
+## Requirements
+
+  - Python 3.15+ (preview)
+  - Python 3.10+ (full)
+
+## Installation
+
+```bash
+pip install rPickle
+```
+
+## Quick Start
+```python
+import rPickle
+
+# Serialize
+data = {'name': 'Alice', 'scores': [95, 87, 92]}
+packed = rPickle.dumps(data)
+
+# Deserialize
+restored = rPickle.loads(packed)
+print(restored)  # {'name': 'Alice', 'scores': [95, 87, 92]}
+```
+
+## API
+
+### Core Function
+
+| Function        | Description               |
+| --------------- | ------------------------- |
+| dumps(obj)      | Serialize object to bytes |
+| loads(data)     | Deserialize from bytes    |
+| dump(obj, file) | Serialize to file         |
+| load(file)      | Deserialize from file     |
+
+## Extensions
+
+```python
+from datetime import datetime
+
+data = {'created': datetime.now()}
+packed = rPickle.dumps(data, extensions=rPickle.datetime_ex)
+restored = rPickle.loads(packed, extensions=rPickle.datetime_ex)
+```
+
+### Custom Extensions
+
+Add support for your own types using the `extensions` parameter.
+
+```python
+from datetime import datetime
+
+# 1. Define dump function (type → bytes)
+def dump_datetime(dt: datetime) -> bytes:
+    return dt.timestamp().to_bytes(8, 'little')
+
+# 2. Define load function (bytes → type)
+def load_datetime(data: bytes) -> datetime:
+    timestamp = int.from_bytes(data, 'little')
+    return datetime.fromtimestamp(timestamp)
+
+# 3. Register your extension
+my_extensions = {
+    datetime: (load_datetime, dump_datetime)  # (load, dump)
+}
+
+# 4. Use it
+data = {'created': datetime.now()}
+packed = rPickle.dumps(data, extensions=my_extensions)
+restored = rPickle.loads(packed, extensions=my_extensions)
+```
+
+### Built-in Extensions
+
+rPickle includes some ready-to-use extensions
+
+## Supported Types
+  - `None`, `bool`, `int`, `float`, `complex`, `str`
+  - `bytes`, `bytearray`
+  - `list`, `tuple`, `set`, `frozenset`
+  - `dict`, `frozendict` (Python 3.15+)
+  - `range`, `slice`
+  - `Ellipsis`, `NotImplemented`
+  - Circular references
+
+## License
+
+MIT

rpickle-0.1.0/README.md

@@ -0,0 +1,100 @@
+# rPickle
+
+A safe and efficient Python serialization library.
+
+## Features
+
+  - 🔒 **Safe** - No arbitrary code execution, unlike `pickle`
+  - ⚡ **Fast** - Optimized binary format
+  - 📦 **Compact** - Small serialized size
+  - 🔄 **Circular references** - Handles self-referential structures
+  - 🎨 **Extensible** - Custom type support via extensions
+
+## Requirements
+
+  - Python 3.15+ (preview)
+  - Python 3.10+ (full)
+
+## Installation
+
+```bash
+pip install rPickle
+```
+
+## Quick Start
+```python
+import rPickle
+
+# Serialize
+data = {'name': 'Alice', 'scores': [95, 87, 92]}
+packed = rPickle.dumps(data)
+
+# Deserialize
+restored = rPickle.loads(packed)
+print(restored)  # {'name': 'Alice', 'scores': [95, 87, 92]}
+```
+
+## API
+
+### Core Function
+
+| Function        | Description               |
+| --------------- | ------------------------- |
+| dumps(obj)      | Serialize object to bytes |
+| loads(data)     | Deserialize from bytes    |
+| dump(obj, file) | Serialize to file         |
+| load(file)      | Deserialize from file     |
+
+## Extensions
+
+```python
+from datetime import datetime
+
+data = {'created': datetime.now()}
+packed = rPickle.dumps(data, extensions=rPickle.datetime_ex)
+restored = rPickle.loads(packed, extensions=rPickle.datetime_ex)
+```
+
+### Custom Extensions
+
+Add support for your own types using the `extensions` parameter.
+
+```python
+from datetime import datetime
+
+# 1. Define dump function (type → bytes)
+def dump_datetime(dt: datetime) -> bytes:
+    return dt.timestamp().to_bytes(8, 'little')
+
+# 2. Define load function (bytes → type)
+def load_datetime(data: bytes) -> datetime:
+    timestamp = int.from_bytes(data, 'little')
+    return datetime.fromtimestamp(timestamp)
+
+# 3. Register your extension
+my_extensions = {
+    datetime: (load_datetime, dump_datetime)  # (load, dump)
+}
+
+# 4. Use it
+data = {'created': datetime.now()}
+packed = rPickle.dumps(data, extensions=my_extensions)
+restored = rPickle.loads(packed, extensions=my_extensions)
+```
+
+### Built-in Extensions
+
+rPickle includes some ready-to-use extensions
+
+## Supported Types
+  - `None`, `bool`, `int`, `float`, `complex`, `str`
+  - `bytes`, `bytearray`
+  - `list`, `tuple`, `set`, `frozenset`
+  - `dict`, `frozendict` (Python 3.15+)
+  - `range`, `slice`
+  - `Ellipsis`, `NotImplemented`
+  - Circular references
+
+## License
+
+MIT

rpickle-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ['setuptools>=61.0', 'wheel']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'rPickle'
+dynamic = ['version']
+description = 'A safe and efficient Python serialization library'
+readme = 'README.md'
+license = {text = 'MIT'}
+authors = [
+    {name = 'Rainwalker', email = 'lmx1w3r@outlook.com'},
+]
+keywords = ['serialization', 'pickle', 'binary']
+classifiers = [
+    'Development Status :: 4 - Beta',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "rPickle.__version__"}
+
+[project.optional-dependencies]
+dev = ['pytest>=7.0', 'pytest-benchmark']
+
+[tool.setuptools.packages.find]
+where = ['src']
+exclude = ['tests*']
+
+[tool.setuptools.package-data]
+rPickle = ['py.typed']

rpickle-0.1.0/setup.cfg

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

rpickle-0.1.0/src/rPickle/__init__.py

@@ -0,0 +1,10 @@
+from .core import *
+from .core import __version__
+from . import ext
+
+__all__ = (
+    *core.__all__,
+    'ext',
+)
+
+del core

rpickle-0.1.0/src/rPickle/core.py

@@ -0,0 +1,370 @@
+'''
+rPickle - A safe and efficient Python serialization library.
+
+Binary format with:
+  - Circular reference support
+  - Extensible type system
+'''
+
+from typing import BinaryIO as _BinaryIO, Any as _Any, Callable as _Callable
+import struct as _struct
+import builtins as _builtins
+from io import BytesIO as _BytesIO
+from sys import version_info as _ver_info
+import warnings
+
+_version = 1
+_python_version = (3, 15)
+
+__version__ = '0.1.0'
+
+_MAGIC = b'RPkl'
+
+class VersionError(Exception):
+    def __init__(self, text: str = f"Cannot load because Python or rPickle is not the newest version. Need Python {'.'.join(map(str, _python_version))}+ or rPickle {__version__}+"):
+        self.text = text
+        super().__init__(text)
+
+if _ver_info < (3, 15):
+    class frozendict:
+        def __init__(self):
+            raise VersionError()
+
+class _LOAD:
+    __slots__ = ('buf', 'objs_id', 'extensions')
+
+    struct_compile = {
+        'd' : _struct.Struct('<d'),
+        '2d': _struct.Struct('<2d'),
+        'bB': _struct.Struct('<bB'),
+        'h' : _struct.Struct('<h'),
+        'b' : _struct.Struct('<b'),
+        'i' : _struct.Struct('<i'),
+        'f' : _struct.Struct('<f'),
+    }
+
+    def __init__(self, f: _BinaryIO, extensions: dict[type, _Callable[[bytes], _Any]] | None = None):
+        self.buf: _BytesIO = f
+        magic = f.read(4)
+        if magic != _MAGIC: raise ValueError("invalid data")
+        version = int.from_bytes(f.read(2), 'little')
+        if version != _version: warnings.warn('may not be compatible', RuntimeWarning)
+        py_ver_maj, py_ver_min = f.read(2)
+        py_ver = py_ver_maj, py_ver_min
+        if py_ver > _python_version: warnings.warn('may not be compatible', RuntimeWarning)
+        self.objs_id = []
+        self.extensions = {} if extensions is None else {k.__module__ + k.__qualname__: v for k, v in extensions.items()}
+
+    def VALUE(self) -> _Any:
+        now = self.buf.read(1)[0]
+        match now:
+            case 0x0 | 0x1: return bool(now)
+            case 0x2      : return None
+            case 0x3:
+                value, = self.struct_compile['d'].unpack(self.buf.read(8))
+                self.objs_id.append(value)
+                return value
+            
+            case 0x4:
+                idx = len(self.objs_id)
+                self.objs_id.append(None)
+                flag = self.buf.read(1)[0]
+                has_real, has_imag = flag >> 4, flag & 1
+                value = complex(self.VALUE() if has_real else 0, self.VALUE() if has_imag else 0)
+                self.objs_id[idx] = value
+                return value
+            
+            case 0x5:
+                signed, length_of_length = self.struct_compile['bB'].unpack(self.buf.read(2))
+                length = int.from_bytes(self.buf.read(length_of_length), 'little')
+                value = signed * int.from_bytes(self.buf.read(length), 'little')
+                self.objs_id.append(value)
+                return value
+            
+            case 0x6:
+                length_of_length = self.buf.read(1)[0]
+                length = int.from_bytes(self.buf.read(length_of_length), 'little')
+                value = self.buf.read(length).decode()
+                self.objs_id.append(value)
+                return value
+
+            case 0x7:
+                idx = len(self.objs_id)
+                self.objs_id.append(None)
+                value = (*self.LIST([]),) # Using unpacking instead of tuple creator because it's faster.
+                self.objs_id[idx] = value
+                return value
+            
+            case 0x8:
+                value = []
+                self.objs_id.append(value)
+                value = self.LIST(value)
+                return value
+            
+            case 0x9:
+                value = set()
+                self.objs_id.append(value)
+                value = self.SET(value)
+                return value
+            
+            case 0xA:
+                value = {}
+                self.objs_id.append(value)
+                value = self.DICT(value)
+                return value
+            
+            case 0xB | 0xC as code:
+                length_of_length = self.buf.read(1)[0]
+                length = int.from_bytes(self.buf.read(length_of_length), 'little')
+                if code == 0xB:
+                    value = self.buf.read(length)
+                else:
+                    value = bytearray(length)
+                    self.buf.readinto(value)
+                self.objs_id.append(value)
+                return value
+            
+            case 0xD:
+                value, = self.struct_compile['h'].unpack(self.buf.read(2))
+                return value
+            
+            case 0xE:
+                value = (self.buf.read(1)[0] ^ 0x80) - 0x80
+                return value
+            
+            case 0xF:
+                value, = self.struct_compile['i'].unpack(self.buf.read(4))
+                self.objs_id.append(value)
+                return value
+            
+            case 0x10:
+                idx = len(self.objs_id)
+                self.objs_id.append(None)
+                value = frozenset(self.SET(set()))
+                self.objs_id[idx] = value
+                return value
+            
+            case 0x11:
+                length = self.buf.read(1)[0]
+                value = self.buf.read(length).decode()
+                self.objs_id.append(value)
+                return value
+            
+            case 0x12 | 0x13 as code:
+                idx = len(self.objs_id)
+                self.objs_id.append(None)
+                value = (range if code == 0x12 else slice)(self.VALUE(), self.VALUE(), self.VALUE())
+                self.objs_id[idx] = value
+                return value
+            
+            case 0x14: return ...
+            case 0x15: return _builtins.NotImplemented
+            case 0x16:
+                idx = len(self.objs_id)
+                self.objs_id.append(None)
+                value = frozendict(self.DICT(value))
+                self.objs_id[idx] = value
+                return value
+
+            case 0xFE:
+                length = self.buf.read(1)[0]
+                value = int.from_bytes(self.buf.read(length), 'little')
+                return self.objs_id[value]
+            
+            case 0xFF:
+                length = self.buf.read(1)[0]
+                name = self.buf.read(length).decode()
+                if name in self.extensions:
+                    length_of_length = self.buf.read(1)[0]
+                    length = int.from_bytes(self.buf.read(length_of_length), 'little')
+                    content = self.buf.read(length)
+                    value = self.extensions[name][0](content)
+                self.objs_id.append(value)
+                return value
+
+    def LIST(self, value: list) -> list:
+        length_of_length = self.buf.read(1)[0]
+        length = int.from_bytes(self.buf.read(length_of_length), 'little')
+        value += [None] * length
+        for item in range(length): value[item] = self.VALUE()
+        return value
+    
+    def SET(self, value: set) -> set:
+        length_of_length = self.buf.read(1)[0]
+        length = int.from_bytes(self.buf.read(length_of_length), 'little')
+        value_add = value.add
+        for _ in range(length): value_add(self.VALUE())
+        return value
+    
+    def DICT(self, value: dict) -> dict:
+        length_of_length = self.buf.read(1)[0]
+        length = int.from_bytes(self.buf.read(length_of_length), 'little')
+        for _ in range(length): value[self.VALUE()] = self.VALUE()
+            # WARNING: right VALUE() will execute first, then left VALUE()
+            # We know: Python evaluates expressions from left to right.
+            # Notice that while evaluating an assignment, the right-hand side is evaluated before the left-hand side.
+        return value
+    
+
+def load(f: _BinaryIO, extensions: dict[type, _Callable[[bytes], _Any]] | None = None) -> _Any:
+    '''load data from file'''
+    return _LOAD(f, extensions).VALUE()
+
+def loads(source: bytes | bytearray, extensions: dict[type, _Callable[[bytes], _Any]] | None = None) -> _Any:
+    '''load data from byte-like'''
+    return load(_BytesIO(source), extensions)
+            
+def dump(obj: _Any, f: _BinaryIO, extensions: dict[type, _Callable[[_Any], bytes]] | None = None):
+    '''dump data to file'''
+    f.write(_MAGIC)
+    f.write(_version.to_bytes(2, 'little'))
+    f.write(_ver_info.major.to_bytes())
+    f.write(_ver_info.minor.to_bytes())
+    if extensions is None: extensions = {}
+    stack = [obj]
+    obm = {
+        tuple     : b'\x07',
+        list      : b'\x08',
+        set       : b'\x09',
+        frozenset : b'\x10',
+
+        dict      : b'\x0A',
+        frozendict: b'\x16',
+
+        bytes     : b'\x0B',
+        bytearray : b'\x0C',
+
+        range     : b'\x12',
+        slice     : b'\x13',
+    }
+    struct_compile = {
+        'cd' : _struct.Struct('<cd'),
+        'cbB': _struct.Struct('<cbB'),
+        'ch' : _struct.Struct('<ch'),
+        'cb' : _struct.Struct('<cb'),
+        'ci' : _struct.Struct('<ci'),
+        '2c' : _struct.Struct('<2c'),
+        'cB' : _struct.Struct('<cB'),
+    }
+    objs_id: dict[int, int] = {}
+    id_count = 0
+    while stack:
+        obj = stack.pop()
+        obj_id = id(obj)
+        if obj_id in objs_id:
+            f.write(b'\xFE')
+            content = objs_id[obj_id].to_bytes(8, 'little').rstrip(b'\x00')
+            f.write(len(content).to_bytes())
+            f.write(content)
+            continue
+
+        if not (
+                isinstance(obj, bool)
+                or obj is None
+                or obj is ...
+                or obj is _builtins.NotImplemented
+                or (isinstance(obj, int) and -32768 <= obj < 32768)
+            ):
+            objs_id[obj_id] = id_count
+            id_count += 1
+
+        match obj:
+            case bool()   : f.write(bytes((obj,)))
+            case None     : f.write(b'\x02')
+            case float():
+                f.write(struct_compile['cd'].pack(b'\x03', obj))
+
+            case complex():
+                f.write(b'\x04')
+                has_real, has_imag = bool(obj.real), bool(obj.imag)
+                f.write(bytes((has_real << 4 | has_imag,)))
+                stack += (obj.imag, obj.real)[not has_imag : has_real + 1]
+
+            case int():
+                if -128 <= obj < 128: # very short
+                    f.write(struct_compile['cb'].pack(b'\x0E', obj))
+                    continue
+
+                elif -32768 <= obj < 32768: # short
+                    f.write(struct_compile['ch'].pack(b'\x0D', obj))
+                    continue
+
+                elif -2147483648 <= obj < 2147483648 : # int
+                    f.write(struct_compile['ci'].pack(b'\x0F', obj))
+                    continue
+
+                num = abs(obj)
+                digits = num.to_bytes((num.bit_length() + 7) >> 3, 'little')
+                f.write(struct_compile['2c'].pack(b'\x05', b'\xFF' if obj < 0 else b'\x01')) # signed
+                length_of_length = len(digits).to_bytes(8, 'little').rstrip(b'\x00') # length
+                f.write(len(length_of_length).to_bytes()) # length of length
+                f.write(length_of_length)
+                f.write(digits)
+            
+            case str():
+                content = obj.encode()
+                if len(content) < 256:
+                    f.write(struct_compile['cB'].pack(b'\x11', len(content)))
+                    f.write(content)
+                else:
+                    f.write(b'\x06')
+                    length = len(content).to_bytes(8, 'little').rstrip(b'\x00')
+                    f.write(len(length).to_bytes())
+                    f.write(length)
+                    f.write(content)
+
+            case tuple() | list() | set() | frozenset():
+                f.write(obm[type(obj)])
+                length = len(obj).to_bytes(8, 'little').rstrip(b'\x00')
+                f.write(len(length).to_bytes())
+                f.write(length)
+                stack += [None] * len(obj)
+                stack[-1:-1-len(obj):-1] = obj
+
+            case dict() | frozendict():
+                f.write(obm[type(obj)])
+                length = len(obj).to_bytes(8, 'little').rstrip(b'\x00')
+                f.write(len(length).to_bytes())
+                f.write(length)
+                stack += [None] * (len(obj) << 1)
+                stack[-1:-1-(len(obj)<<1):-1] = (item for key, value in obj.items() for item in (value, key))
+                # To maintain order, this genexpr must reverse (key, value) to (value, key)
+                # stack will become [..., k3, v3, k2, v2, k1, v1]
+                # When stack pop, it'll pop v1 first, then pop k1, and so on
+
+            case bytes() | bytearray():
+                f.write(obm[type(obj)])
+                length = len(obj).to_bytes(8, 'little').rstrip(b'\x00')
+                f.write(len(length).to_bytes())
+                f.write(length)
+                f.write(obj)
+
+            case range() | slice():
+                f.write(obm[type(obj)])
+                stack += (obj.step, obj.stop, obj.start)
+
+            case _ if obj is ...: f.write(b'\x14')
+            case _ if obj is _builtins.NotImplemented: f.write(b'\x15')
+            case _:
+                if type(obj) in extensions:
+                    f.write(b'\xFF')
+                    name = (type(obj).__module__ + type(obj).__qualname__).encode()
+                    f.write(len(name).to_bytes())
+                    f.write(name)
+                    value = extensions[type(obj)][1](obj)
+                    length = len(value).to_bytes(8, 'little').rstrip(b'\x00')
+                    f.write(len(length).to_bytes())
+                    f.write(length)
+                    f.write(value)
+                else:
+                    raise TypeError(f"Unsupported type: {type(obj).__name__}")
+
+def dumps(obj: _Any, extensions: dict[type, _Callable[[_Any], bytes]] | None = None) -> bytes:
+    '''dump data to byte-like'''
+    buf = _BytesIO()
+    dump(obj, buf, extensions)
+    return buf.getvalue()
+
+__all__ = (
+    'loads', 'dumps', 'load', 'dump', 'VersionError',
+)

rpickle-0.1.0/src/rPickle/ext.py

@@ -0,0 +1,44 @@
+"rPickle's built-in extensions"
+
+import struct as _struct
+from .core import dumps, loads
+
+# datetime
+from datetime import datetime as _datetime
+
+def _datetime_d(value: _datetime) -> bytes: return _struct.pack('<d', value.timestamp())
+def _datetime_l(code: bytes) -> _datetime: return _datetime.fromtimestamp(_struct.unpack('<d', code)[0])
+
+datetime_ext = {_datetime: (_datetime_l, _datetime_d)}
+
+# Decimal
+from decimal import Decimal as _Decimal
+
+def _Decimal_d(value: _Decimal) -> bytes: return str(value).encode('ascii')
+def _Decimal_l(code: bytes) -> _Decimal: return _Decimal(code.decode('ascii'))
+
+Decimal_ext = {_Decimal: (_Decimal_l, _Decimal_d)}
+
+# UUID
+from uuid import UUID as _UUID
+
+def _UUID_d(value: _UUID) -> bytes: return value.bytes
+def _UUID_l(code: bytes) -> _UUID: return _UUID(bytes=code)
+
+UUID_ext = {_UUID: (_UUID_l, _UUID_d)}
+
+#Fraction
+from fractions import Fraction as _Fraction
+
+def _Fraction_d(value: _Fraction) -> bytes: return dumps((value.numerator, value.denominator))
+def _Fraction_l(code: bytes) -> _Fraction: return _Fraction(*loads(code))
+
+Fraction_ext = {_Fraction: (_Fraction_l, _Fraction_d)}
+
+# others
+__all__ = (
+    'datetime_ext',
+    'Decimal_ext',
+    'UUID_ext',
+    'Fraction_ext',
+)

rpickle-0.1.0/src/rPickle/py.typed

@@ -0,0 +1,6 @@
+rPickle's py.typed
+
+Why is it called 'rPickle'?
+Because it has a interesting meaning. The 'r' refers 'Rain' - yeah, which's in 'Rainwalker'.
+And 'Pickle'? You know its meaning, so I don't descript again.
+Happy pickling!

rpickle-0.1.0/src/rPickle.egg-info/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: rPickle
+Version: 0.1.0
+Summary: A safe and efficient Python serialization library
+Author-email: Rainwalker <lmx1w3r@outlook.com>
+License: MIT
+Keywords: serialization,pickle,binary
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-benchmark; extra == "dev"
+Dynamic: license-file
+
+# rPickle
+
+A safe and efficient Python serialization library.
+
+## Features
+
+  - 🔒 **Safe** - No arbitrary code execution, unlike `pickle`
+  - ⚡ **Fast** - Optimized binary format
+  - 📦 **Compact** - Small serialized size
+  - 🔄 **Circular references** - Handles self-referential structures
+  - 🎨 **Extensible** - Custom type support via extensions
+
+## Requirements
+
+  - Python 3.15+ (preview)
+  - Python 3.10+ (full)
+
+## Installation
+
+```bash
+pip install rPickle
+```
+
+## Quick Start
+```python
+import rPickle
+
+# Serialize
+data = {'name': 'Alice', 'scores': [95, 87, 92]}
+packed = rPickle.dumps(data)
+
+# Deserialize
+restored = rPickle.loads(packed)
+print(restored)  # {'name': 'Alice', 'scores': [95, 87, 92]}
+```
+
+## API
+
+### Core Function
+
+| Function        | Description               |
+| --------------- | ------------------------- |
+| dumps(obj)      | Serialize object to bytes |
+| loads(data)     | Deserialize from bytes    |
+| dump(obj, file) | Serialize to file         |
+| load(file)      | Deserialize from file     |
+
+## Extensions
+
+```python
+from datetime import datetime
+
+data = {'created': datetime.now()}
+packed = rPickle.dumps(data, extensions=rPickle.datetime_ex)
+restored = rPickle.loads(packed, extensions=rPickle.datetime_ex)
+```
+
+### Custom Extensions
+
+Add support for your own types using the `extensions` parameter.
+
+```python
+from datetime import datetime
+
+# 1. Define dump function (type → bytes)
+def dump_datetime(dt: datetime) -> bytes:
+    return dt.timestamp().to_bytes(8, 'little')
+
+# 2. Define load function (bytes → type)
+def load_datetime(data: bytes) -> datetime:
+    timestamp = int.from_bytes(data, 'little')
+    return datetime.fromtimestamp(timestamp)
+
+# 3. Register your extension
+my_extensions = {
+    datetime: (load_datetime, dump_datetime)  # (load, dump)
+}
+
+# 4. Use it
+data = {'created': datetime.now()}
+packed = rPickle.dumps(data, extensions=my_extensions)
+restored = rPickle.loads(packed, extensions=my_extensions)
+```
+
+### Built-in Extensions
+
+rPickle includes some ready-to-use extensions
+
+## Supported Types
+  - `None`, `bool`, `int`, `float`, `complex`, `str`
+  - `bytes`, `bytearray`
+  - `list`, `tuple`, `set`, `frozenset`
+  - `dict`, `frozendict` (Python 3.15+)
+  - `range`, `slice`
+  - `Ellipsis`, `NotImplemented`
+  - Circular references
+
+## License
+
+MIT

rpickle-0.1.0/src/rPickle.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/rPickle/__init__.py
+src/rPickle/core.py
+src/rPickle/ext.py
+src/rPickle/py.typed
+src/rPickle.egg-info/PKG-INFO
+src/rPickle.egg-info/SOURCES.txt
+src/rPickle.egg-info/dependency_links.txt
+src/rPickle.egg-info/requires.txt
+src/rPickle.egg-info/top_level.txt
+tests/test_basic.py
+tests/test_containers.py
+tests/test_errors.py
+tests/test_extensions.py

rpickle-0.1.0/src/rPickle.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rpickle-0.1.0/src/rPickle.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[dev]
+pytest>=7.0
+pytest-benchmark

rpickle-0.1.0/src/rPickle.egg-info/top_level.txt

@@ -0,0 +1 @@
+rPickle

rpickle-0.1.0/tests/test_basic.py

@@ -0,0 +1,41 @@
+import rPickle
+
+class TestBasicTypes:
+    def test_none(self):
+        assert rPickle.loads(rPickle.dumps(None)) is None
+    
+    def test_bool(self):
+        assert rPickle.loads(rPickle.dumps(True)) is True
+        assert rPickle.loads(rPickle.dumps(False)) is False
+    
+    def test_int(self):
+        for n in [-1, 0, 1, 127, 128, 32767, 32768, 2**31-1, 2**31]:
+            assert rPickle.loads(rPickle.dumps(n)) == n
+    
+    def test_float(self):
+        for f in [0.0, 1.5, -3.14, float('inf'), float('-inf')]:
+            assert rPickle.loads(rPickle.dumps(f)) == f
+    
+    def test_complex(self):
+        for c in [1+2j, 3.5-4j, complex(0, 1)]:
+            assert rPickle.loads(rPickle.dumps(c)) == c
+    
+    def test_str(self):
+        s = "Hello 世界 \n\t\r \"' \\"
+        assert rPickle.loads(rPickle.dumps(s)) == s
+    
+    def test_bytes(self):
+        b = b"\x00\x01\x02\xFF"
+        assert rPickle.loads(rPickle.dumps(b)) == b
+    
+    def test_bytearray(self):
+        ba = bytearray(b"\x00\x01\x02\xFF")
+        result = rPickle.loads(rPickle.dumps(ba))
+        assert result == ba
+        assert isinstance(result, bytearray)
+    
+    def test_ellipsis(self):
+        assert rPickle.loads(rPickle.dumps(...)) is ...
+    
+    def test_notimplemented(self):
+        assert rPickle.loads(rPickle.dumps(NotImplemented)) is NotImplemented

rpickle-0.1.0/tests/test_containers.py

@@ -0,0 +1,45 @@
+import rPickle
+
+class TestContainers:
+    def test_list(self):
+        data = [1, 2, 3, "a", None]
+        assert rPickle.loads(rPickle.dumps(data)) == data
+    
+    def test_tuple(self):
+        data = (1, 2, 3, "a", None)
+        assert rPickle.loads(rPickle.dumps(data)) == data
+    
+    def test_dict(self):
+        data = {"a": 1, "b": [2, 3], "c": None}
+        assert rPickle.loads(rPickle.dumps(data)) == data
+    
+    def test_set(self):
+        data = {1, 2, 3}
+        assert rPickle.loads(rPickle.dumps(data)) == data
+    
+    def test_frozenset(self):
+        data = frozenset([1, 2, 3])
+        assert rPickle.loads(rPickle.dumps(data)) == data
+    
+    def test_nested(self):
+        data = [{"a": (1, 2)}, {b"key": {3, 4}}]
+        assert rPickle.loads(rPickle.dumps(data)) == data
+
+class TestCircularReferences:
+    def test_self_list(self):
+        a = []
+        a.append(a)
+        b = rPickle.loads(rPickle.dumps(a))
+        assert b[0] is b
+    
+    def test_self_dict(self):
+        d = {}
+        d["self"] = d
+        e = rPickle.loads(rPickle.dumps(d))
+        assert e["self"] is e
+    
+    def test_shared_reference(self):
+        inner = [1, 2]
+        outer = [inner, inner]
+        result = rPickle.loads(rPickle.dumps(outer))
+        assert result[0] is result[1]

rpickle-0.1.0/tests/test_errors.py

@@ -0,0 +1,28 @@
+import pytest
+import rPickle
+
+class TestErrors:
+    def test_invalid_data(self):
+        with pytest.raises(ValueError, match="invalid data"):
+            rPickle.loads(b'not rpickle data')
+    
+    def test_unsupported_type(self):
+        class Custom:
+            pass
+        
+        with pytest.raises(TypeError, match="Unsupported type: Custom"):
+            rPickle.dumps(Custom())
+    
+    def test_extension_without_load(self):
+        """测试扩展格式错误时应该报错"""
+        class MyType:
+            pass
+        
+        # 创建错误的扩展（dump 函数缺失）
+        bad_ext = {MyType: (None, None)}  # load 和 dump 都是 None
+        
+        obj = MyType()
+        
+        # dumps 时应该抛出 TypeError
+        with pytest.raises(TypeError):
+            rPickle.dumps(obj, extensions=bad_ext)

rpickle-0.1.0/tests/test_extensions.py

@@ -0,0 +1,45 @@
+import rPickle
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+from fractions import Fraction
+
+class TestBuiltinExtensions:
+    def test_datetime(self):
+        dt = datetime(2026, 6, 12, 12, 0, 0)
+        packed = rPickle.dumps(dt, extensions=rPickle.ext.datetime_ext)
+        restored = rPickle.loads(packed, extensions=rPickle.ext.datetime_ext)
+        assert restored == dt
+    
+    def test_decimal(self):
+        d = Decimal('3.14159')
+        packed = rPickle.dumps(d, extensions=rPickle.ext.Decimal_ext)
+        restored = rPickle.loads(packed, extensions=rPickle.ext.Decimal_ext)
+        assert restored == d
+    
+    def test_uuid(self):
+        u = uuid4()
+        packed = rPickle.dumps(u, extensions=rPickle.ext.UUID_ext)
+        restored = rPickle.loads(packed, extensions=rPickle.ext.UUID_ext)
+        assert restored == u
+    
+    def test_fraction(self):
+        f = Fraction(3, 4)
+        packed = rPickle.dumps(f, extensions=rPickle.ext.Fraction_ext)
+        restored = rPickle.loads(packed, extensions=rPickle.ext.Fraction_ext)
+        assert restored == f
+    
+    def test_multiple_extensions(self):
+        data = {
+            'dt': datetime(2026, 6, 12, 12, 0, 0),
+            'dec': Decimal('3.14'),
+            'frac': Fraction(2, 3),
+        }
+        ext = (rPickle.ext.datetime_ext | 
+               rPickle.ext.Decimal_ext | 
+               rPickle.ext.Fraction_ext)
+        packed = rPickle.dumps(data, extensions=ext)
+        restored = rPickle.loads(packed, extensions=ext)
+        assert restored['dt'] == data['dt']
+        assert restored['dec'] == data['dec']
+        assert restored['frac'] == data['frac']