mscs 2.2.0__py3-none-any.whl

mscs/__init__.py

@@ -0,0 +1,50 @@
+"""
+MSCS — Safe serialization for Python. A secure, fast replacement for pickle.
+
+Usage:
+    import mscs
+
+    data = mscs.dumps(obj)
+    obj = mscs.loads(data)
+
+    mscs.register(MyClass)  # allow deserialization of custom classes
+"""
+from mscs._core import (
+    # Version
+    __version__,
+    # Public API
+    dump,
+    load,
+    dumps,
+    loads,
+    dump_compressed,
+    load_compressed,
+    register,
+    register_alias,
+    register_module,
+    inspect,
+    benchmark,
+    copy,
+    # Exceptions
+    MSCError,
+    MSCEncodeError,
+    MSCDecodeError,
+    MSCSecurityError,
+    # Constants (for advanced users)
+    MAGIC,
+    VERSION,
+    MAX_DEPTH,
+    MAX_SIZE,
+    MAX_COMPRESSED,
+    MAX_COLLECTION,
+    MAX_STRING,
+)
+
+__all__ = [
+    "__version__",
+    "dump", "load", "dumps", "loads",
+    "dump_compressed", "load_compressed",
+    "register", "register_alias", "register_module",
+    "inspect", "benchmark", "copy",
+    "MSCError", "MSCEncodeError", "MSCDecodeError", "MSCSecurityError",
+]

mscs/_core.py

@@ -0,0 +1,1031 @@
+"""
+MSC Serial v2.2
+===============
+Reemplazo personal y seguro de pickle.
+
+Soporta: dict, list, tuple, set, frozenset, str, int, float, complex,
+         bool, None, bytes, bytearray, datetime, date, time, timedelta,
+         Decimal, UUID, Path, Enum, numpy arrays, torch.Tensor,
+         dataclasses, objetos con __slots__, objetos custom registrados,
+         referencias circulares.
+
+API compatible con pickle:
+  msc.dump(obj, file)
+  msc.load(file)
+  msc.dumps(obj) -> bytes
+  msc.loads(data) -> obj
+  msc.dump_compressed(obj, file)
+  msc.load_compressed(file)
+
+Extras:
+  msc.register(cls)           # registrar clase segura para deserialización
+  msc.register_alias(old, c)  # alias para clases renombradas (backward compat)
+  msc.register_module(mod)    # registrar todas las clases de un módulo
+  msc.inspect(data) -> dict   # metadata sin deserializar
+  msc.benchmark(obj) -> dict  # medir rendimiento
+  msc.copy(obj) -> obj        # deep copy via round-trip
+
+Seguridad:
+  - No ejecuta código arbitrario al deserializar
+  - Solo reconstruye objetos de clases explícitamente registradas
+  - Límites de profundidad y tamaño configurables
+  - Formato auditable con magic bytes + versión
+  - Sin importlib dinámico en deserialización
+  - Validación de numpy dtypes contra whitelist
+  - Protección anti zip-bomb en load_compressed
+  - NOTA: la seguridad del registry depende de que solo se registren
+    clases confiables. __setstate__ de clases registradas SE EJECUTA.
+  - NOTA: ref tracking usa id(obj); como el encoder mantiene refs a
+    todos los objetos serializados, los IDs no se reutilizan durante
+    una sola llamada a encode().
+
+Changelog v2.2:
+  - FIX: timedelta usa tag dedicado _TIMEDELTA2 (0x19) — elimina la
+         ambiguedad heuristica entre formatos v2.0 y v2.1
+  - FIX: _encode_str ahora valida longitud contra MAX_STRING
+  - FIX: load_compressed protegido contra zip bombs (valida tamaño
+         comprimido Y descomprimido)
+  - ADD: soporte nativo torch.Tensor (tag 0x18) — serializa dtype,
+         shape, requires_grad sin conversión manual a numpy
+  - ADD: register_alias(old_path, cls) para backward-compat con
+         checkpoints de clases renombradas/movidas
+  - Retrocompatible con payloads v2.1, v2.0 y v1.0
+
+Changelog v2.1:
+  - FIX: timedelta ahora codifica days/seconds/microseconds por separado
+         (v2.0 perdía precisión al usar total_seconds() como float)
+  - FIX: validación de numpy dtype contra whitelist de tipos seguros
+  - ADD: soporte UUID nativo
+  - ADD: soporte pathlib.Path nativo
+  - ADD: register_module() para registro masivo de clases
+  - ADD: copy() — deep copy vía serialización round-trip
+  - ADD: inspect() ahora muestra nombre del tag raíz
+  - ADD: contexto de ruta en errores de decode (breadcrumbs)
+  - Retrocompatible con payloads v2.0 y v1.0
+
+Changelog v2.0:
+  - Registry de clases seguras (elimina importlib dinámico)
+  - Soporte: complex, frozenset, datetime/date/time/timedelta, Decimal, Enum
+  - Detección y manejo de referencias circulares
+  - Límites de profundidad y tamaño máximo
+  - Streaming encode/decode para objetos grandes
+  - Mejor manejo de errores con excepciones tipadas
+  - Soporte bytearray nativo
+  - Benchmark integrado
+  - Validación de integridad con CRC32 opcional
+"""
+
+import struct
+import io
+import zlib
+import inspect as _inspect_mod
+import dataclasses
+from datetime import datetime, date, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from uuid import UUID
+from typing import Any, Type, Dict, Optional, Set, List
+
+__version__ = "2.2"
+__all__ = [
+    "dump", "load", "dumps", "loads",
+    "dump_compressed", "load_compressed",
+    "register", "register_alias", "register_module",
+    "inspect", "benchmark", "copy",
+    "MSCError", "MSCEncodeError", "MSCDecodeError", "MSCSecurityError",
+]
+
+# ─────────────────────── EXCEPTIONS ───────────────────────────────
+
+class MSCError(Exception):
+    """Base para errores de MSC Serial."""
+
+class MSCEncodeError(MSCError):
+    """Error durante serialización."""
+
+class MSCDecodeError(MSCError):
+    """Error durante deserialización."""
+
+class MSCSecurityError(MSCError):
+    """Intento de deserializar clase no registrada."""
+
+# ─────────────────────── TYPE TAGS ────────────────────────────────
+
+_NONE       = b'\x00'
+_BOOL       = b'\x01'
+_INT        = b'\x02'
+_FLOAT      = b'\x03'
+_STR        = b'\x04'
+_BYTES      = b'\x05'
+_LIST       = b'\x06'
+_TUPLE      = b'\x07'
+_DICT       = b'\x08'
+_SET        = b'\x09'
+_NDARRAY    = b'\x0A'
+_OBJ        = b'\x0B'
+_COMPLEX    = b'\x0C'
+_FROZENSET  = b'\x0D'
+_DATETIME   = b'\x0E'
+_DATE       = b'\x0F'
+_TIME       = b'\x10'
+_TIMEDELTA  = b'\x11'
+_DECIMAL    = b'\x12'
+_ENUM       = b'\x13'
+_BYTEARRAY  = b'\x14'
+_REF        = b'\x15'
+_UUID       = b'\x16'
+_PATH       = b'\x17'
+_TENSOR     = b'\x18'
+_TIMEDELTA2 = b'\x19'  # v2.2: timedelta sin ambiguedad
+
+_TAG_NAMES: Dict[int, str] = {
+    0x00: 'None',    0x01: 'bool',      0x02: 'int',       0x03: 'float',
+    0x04: 'str',     0x05: 'bytes',     0x06: 'list',      0x07: 'tuple',
+    0x08: 'dict',    0x09: 'set',       0x0A: 'ndarray',   0x0B: 'object',
+    0x0C: 'complex', 0x0D: 'frozenset', 0x0E: 'datetime',  0x0F: 'date',
+    0x10: 'time',    0x11: 'timedelta', 0x12: 'Decimal',   0x13: 'Enum',
+    0x14: 'bytearray', 0x15: 'ref',    0x16: 'UUID',      0x17: 'Path',
+    0x18: 'tensor',  0x19: 'timedelta2',
+}
+
+MAGIC   = b'MSCS'
+VERSION = b'\x02'  # formato binario sigue siendo v2; cambios son aditivos
+
+# ─────────────────────── LIMITS ───────────────────────────────────
+
+MAX_DEPTH       = 256
+MAX_SIZE        = 512 * 1024 * 1024  # 512 MB
+MAX_COMPRESSED  = 512 * 1024 * 1024  # 512 MB (compressed input limit, anti zip-bomb)
+MAX_COLLECTION  = 10_000_000
+MAX_STRING      = 100 * 1024 * 1024  # 100 MB
+
+# ─────────────────── NUMPY DTYPE WHITELIST ────────────────────────
+
+_SAFE_NUMPY_DTYPES: Set[str] = {
+    # Enteros
+    'int8', 'int16', 'int32', 'int64',
+    'uint8', 'uint16', 'uint32', 'uint64',
+    # Flotantes
+    'float16', 'float32', 'float64', 'float128',
+    # Complejos
+    'complex64', 'complex128', 'complex256',
+    # Bool y bytes
+    'bool', 'bool_',
+    # Strings fijos
+    # (aceptamos S<n> y U<n> por regex abajo)
+}
+
+
+import re as _re
+_RE_DTYPE_SHORT = _re.compile(r'[fiubcUSV]\d+')
+_RE_DTYPE_LONG  = _re.compile(r'(int|uint|float|complex|bool)\d*_?')
+
+
+def _is_safe_dtype(dtype_str: str) -> bool:
+    """Valida que un dtype string sea seguro (no structured/object/void)."""
+    clean = dtype_str.strip().lower()
+    # Rechazar explícitamente tipos peligrosos
+    if clean in ('object', 'O', 'void', 'V'):
+        return False
+    # Tipos simples directos
+    if clean in _SAFE_NUMPY_DTYPES:
+        return True
+    # Con prefijo de byteorder: <f4, >i8, =f8, |b1, etc.
+    if len(clean) > 1 and clean[0] in '<>=|!':
+        clean = clean[1:]
+    # Numpy shorthand: f4, f8, i4, i8, u2, b1, c8, c16, etc.
+    if _RE_DTYPE_SHORT.fullmatch(clean):
+        # Rechazar V (void) — ya cubierto arriba
+        if clean[0] == 'V':
+            return False
+        return True
+    # Nombre completo con bitsize: float32, int64, etc.
+    if _RE_DTYPE_LONG.fullmatch(clean):
+        return True
+    return False
+
+
+# ─────────────────────── REGISTRY ─────────────────────────────────
+
+_registry: Dict[str, Type] = {}
+
+
+def _class_key(cls: Type) -> str:
+    return f"{cls.__module__}.{cls.__qualname__}"
+
+
+def register(cls: Type) -> Type:
+    """
+    Registra una clase como segura para deserialización.
+    Puede usarse como decorador:
+
+        @msc.register
+        @dataclass
+        class MiObjeto:
+            x: float
+            y: float
+    """
+    key = _class_key(cls)
+    _registry[key] = cls
+    return cls
+
+
+def register_module(module) -> List[Type]:
+    """
+    Registra todas las clases definidas en un módulo.
+    Retorna lista de clases registradas.
+
+        import my_models
+        msc.register_module(my_models)
+    """
+    registered = []
+    for name, obj in _inspect_mod.getmembers(module, _inspect_mod.isclass):
+        # Solo clases definidas EN el módulo (no importadas de stdlib, etc.)
+        if obj.__module__ == module.__name__:
+            register(obj)
+            registered.append(obj)
+    return registered
+
+
+def register_alias(alias: str, cls: Type) -> None:
+    """
+    Registra un alias para una clase (backward-compat con checkpoints viejos).
+
+        # La clase se renombro de OldName a NewName
+        msc.register_alias("my_module.OldName", NewName)
+    """
+    _registry[alias] = cls
+
+
+def _is_registered(class_path: str) -> bool:
+    return class_path in _registry
+
+
+def _get_registered(class_path: str) -> Type:
+    if class_path not in _registry:
+        raise MSCSecurityError(
+            f"Clase no registrada: {class_path!r}. "
+            f"Usa msc.register({class_path.rsplit('.', 1)[-1]}) antes de deserializar."
+        )
+    return _registry[class_path]
+
+
+# ──────────────────────── ENCODER ─────────────────────────────────
+
+class _Encoder:
+    __slots__ = ('buf', 'depth', 'refs', 'ref_counter', 'use_refs')
+
+    def __init__(self, buf: io.BytesIO, *, use_refs: bool = True):
+        self.buf = buf
+        self.depth = 0
+        self.refs: Dict[int, int] = {}   # id(obj) -> ref_id
+        self.ref_counter = 0
+        self.use_refs = use_refs
+
+    def encode(self, obj: Any):
+        self.depth += 1
+        if self.depth > MAX_DEPTH:
+            raise MSCEncodeError(
+                f"Profundidad máxima excedida ({MAX_DEPTH}). "
+                f"¿Referencia circular no detectada?"
+            )
+        try:
+            self._encode(obj)
+        finally:
+            self.depth -= 1
+
+    def _assign_ref(self, obj: Any) -> bool:
+        """Retorna True si el objeto ya fue serializado (escribe REF)."""
+        if not self.use_refs:
+            return False
+        oid = id(obj)
+        if oid in self.refs:
+            self.buf.write(_REF)
+            self.buf.write(struct.pack('<I', self.refs[oid]))
+            return True
+        self.refs[oid] = self.ref_counter
+        self.ref_counter += 1
+        return False
+
+    def _write_length(self, n: int, max_val: int = MAX_COLLECTION, label: str = "colección"):
+        if n > max_val:
+            raise MSCEncodeError(f"Tamaño de {label} excede límite: {n:,} > {max_val:,}")
+        self.buf.write(struct.pack('<I', n))
+
+    def _encode(self, obj: Any):
+        buf = self.buf
+
+        # ── Singletons y primitivos inmutables (sin ref tracking) ──
+
+        if obj is None:
+            buf.write(_NONE)
+            return
+
+        if isinstance(obj, bool):  # antes de int
+            buf.write(_BOOL)
+            buf.write(b'\x01' if obj else b'\x00')
+            return
+
+        if isinstance(obj, int):
+            buf.write(_INT)
+            if obj == 0:
+                buf.write(struct.pack('<H', 1))
+                buf.write(b'\x00')
+            else:
+                n_bytes = (obj.bit_length() + 8) // 8
+                raw = obj.to_bytes(n_bytes, 'little', signed=True)
+                buf.write(struct.pack('<H', len(raw)))
+                buf.write(raw)
+            return
+
+        if isinstance(obj, float):
+            buf.write(_FLOAT)
+            buf.write(struct.pack('<d', obj))
+            return
+
+        if isinstance(obj, complex):
+            buf.write(_COMPLEX)
+            buf.write(struct.pack('<dd', obj.real, obj.imag))
+            return
+
+        # ── Strings y bytes (ref tracking para grandes) ──
+
+        if isinstance(obj, str):
+            if self._assign_ref(obj):
+                return
+            buf.write(_STR)
+            raw = obj.encode('utf-8')
+            self._write_length(len(raw), MAX_STRING, "string")
+            buf.write(raw)
+            return
+
+        if isinstance(obj, bytearray):
+            if self._assign_ref(obj):
+                return
+            buf.write(_BYTEARRAY)
+            self._write_length(len(obj), MAX_STRING, "bytearray")
+            buf.write(bytes(obj))
+            return
+
+        if isinstance(obj, bytes):
+            if self._assign_ref(obj):
+                return
+            buf.write(_BYTES)
+            self._write_length(len(obj), MAX_STRING, "bytes")
+            buf.write(obj)
+            return
+
+        # ── UUID ──
+
+        if isinstance(obj, UUID):
+            buf.write(_UUID)
+            buf.write(obj.bytes)  # siempre 16 bytes
+            return
+
+        # ── Path ──
+
+        if isinstance(obj, Path):
+            buf.write(_PATH)
+            raw = str(obj).encode('utf-8')
+            self._write_length(len(raw), MAX_STRING, "path")
+            buf.write(raw)
+            return
+
+        # ── Tipos temporales ──
+
+        if isinstance(obj, datetime):
+            buf.write(_DATETIME)
+            ts = obj.isoformat()
+            raw = ts.encode('utf-8')
+            buf.write(struct.pack('<H', len(raw)))
+            buf.write(raw)
+            return
+
+        if isinstance(obj, date):
+            buf.write(_DATE)
+            buf.write(struct.pack('<HBB', obj.year, obj.month, obj.day))
+            return
+
+        if isinstance(obj, time):
+            buf.write(_TIME)
+            ts = obj.isoformat()
+            raw = ts.encode('utf-8')
+            buf.write(struct.pack('<H', len(raw)))
+            buf.write(raw)
+            return
+
+        if isinstance(obj, timedelta):
+            # v2.2: tag dedicado sin ambiguedad con v2.0
+            buf.write(_TIMEDELTA2)
+            buf.write(struct.pack('<iiI', obj.days, obj.seconds, obj.microseconds))
+            return
+
+        if isinstance(obj, Decimal):
+            buf.write(_DECIMAL)
+            raw = str(obj).encode('utf-8')
+            buf.write(struct.pack('<H', len(raw)))
+            buf.write(raw)
+            return
+
+        # ── Enum ──
+
+        if isinstance(obj, Enum):
+            buf.write(_ENUM)
+            cls_path = _class_key(type(obj))
+            self._encode_str(cls_path)
+            self.encode(obj.value)
+            return
+
+        # ── Colecciones (con ref tracking) ──
+
+        if isinstance(obj, list):
+            if self._assign_ref(obj):
+                return
+            buf.write(_LIST)
+            self._write_length(len(obj))
+            for item in obj:
+                self.encode(item)
+            return
+
+        if isinstance(obj, tuple):
+            if self._assign_ref(obj):
+                return
+            buf.write(_TUPLE)
+            self._write_length(len(obj))
+            for item in obj:
+                self.encode(item)
+            return
+
+        if isinstance(obj, frozenset):
+            if self._assign_ref(obj):
+                return
+            buf.write(_FROZENSET)
+            items = sorted(obj, key=repr)
+            self._write_length(len(items))
+            for item in items:
+                self.encode(item)
+            return
+
+        if isinstance(obj, set):
+            if self._assign_ref(obj):
+                return
+            buf.write(_SET)
+            items = sorted(obj, key=repr)
+            self._write_length(len(items))
+            for item in items:
+                self.encode(item)
+            return
+
+        if isinstance(obj, dict):
+            if self._assign_ref(obj):
+                return
+            buf.write(_DICT)
+            self._write_length(len(obj))
+            for k, v in obj.items():
+                self.encode(k)
+                self.encode(v)
+            return
+
+        # ── Numpy ──
+
+        try:
+            import numpy as np
+            if isinstance(obj, np.ndarray):
+                if self._assign_ref(obj):
+                    return
+                dtype_s = str(obj.dtype)
+                if not _is_safe_dtype(dtype_s):
+                    raise MSCEncodeError(
+                        f"numpy dtype no permitido: {dtype_s!r}. "
+                        f"Solo se permiten dtypes numéricos simples."
+                    )
+                buf.write(_NDARRAY)
+                shape_s = 'x'.join(map(str, obj.shape)) if obj.shape else ''
+                meta = f"{dtype_s}|{shape_s}"
+                self._encode_str(meta)
+                raw = obj.tobytes()
+                self._write_length(len(raw), MAX_SIZE, "ndarray data")
+                buf.write(raw)
+                return
+        except ImportError:
+            pass
+
+        # ── PyTorch Tensor ──
+
+        try:
+            import torch
+            if isinstance(obj, torch.Tensor):
+                if self._assign_ref(obj):
+                    return
+                # Mover a CPU y hacer contiguous para serializar
+                t = obj.detach().cpu().contiguous()
+                import numpy as np  # noqa: reusa np si ya importado por ndarray path
+                # Convertir a numpy para reutilizar la validación de dtype
+                arr = t.numpy()
+                dtype_s = str(arr.dtype)
+                if not _is_safe_dtype(dtype_s):
+                    raise MSCEncodeError(
+                        f"torch dtype no permitido: {obj.dtype} (numpy: {dtype_s!r})"
+                    )
+                buf.write(_TENSOR)
+                shape_s = 'x'.join(map(str, arr.shape)) if arr.shape else ''
+                requires_grad = '1' if obj.requires_grad else '0'
+                meta = f"{dtype_s}|{shape_s}|{requires_grad}"
+                self._encode_str(meta)
+                raw = arr.tobytes()
+                self._write_length(len(raw), MAX_SIZE, "tensor data")
+                buf.write(raw)
+                return
+        except ImportError:
+            pass
+
+        # ── Objeto registrado ──
+
+        if self._assign_ref(obj):
+            return
+
+        buf.write(_OBJ)
+        cls_path = _class_key(type(obj))
+        self._encode_str(cls_path)
+
+        if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
+            state = {f.name: getattr(obj, f.name) for f in dataclasses.fields(obj)}
+        elif hasattr(obj, '__slots__') and not hasattr(obj, '__dict__'):
+            # __slots__ sin __dict__ → extraer slots del MRO completo.
+            # Priorizado sobre __getstate__ porque Python 3.11+ añade un
+            # __getstate__ por defecto que retorna (None, slots_dict) — un
+            # formato que complica la deserialización innecesariamente.
+            state = {}
+            for cls in type(obj).__mro__:
+                for s in getattr(cls, '__slots__', ()):
+                    if hasattr(obj, s) and s not in state:
+                        state[s] = getattr(obj, s)
+        elif '__getstate__' in type(obj).__dict__ or any(
+            '__getstate__' in c.__dict__ for c in type(obj).__mro__[:-1]
+            if c is not object
+        ):
+            # Solo usar __getstate__ si fue definido explícitamente por el
+            # usuario, no el default de object.
+            state = obj.__getstate__()
+        elif hasattr(obj, '__dict__'):
+            state = obj.__dict__
+        else:
+            raise MSCEncodeError(f"No se puede serializar: {type(obj)!r}")
+
+        self.encode(state)
+
+    def _encode_str(self, s: str):
+        """Encode string directamente sin ref tracking (para metadata interna)."""
+        self.buf.write(_STR)
+        raw = s.encode('utf-8')
+        if len(raw) > MAX_STRING:
+            raise MSCEncodeError(f"Metadata string excede limite: {len(raw):,} > {MAX_STRING:,}")
+        self.buf.write(struct.pack('<I', len(raw)))
+        self.buf.write(raw)
+
+
+# ──────────────────────── DECODER ─────────────────────────────────
+
+class _Decoder:
+    __slots__ = ('buf', 'depth', 'refs', 'strict', 'path')
+
+    def __init__(self, buf: io.BytesIO, *, strict: bool = True):
+        self.buf = buf
+        self.depth = 0
+        self.refs: Dict[int, Any] = {}
+        self.strict = strict
+        self.path: List[str] = []  # breadcrumbs para errores
+
+    def decode(self) -> Any:
+        self.depth += 1
+        if self.depth > MAX_DEPTH:
+            raise MSCDecodeError(
+                f"Profundidad máxima excedida ({MAX_DEPTH}) en {self._path_str()}"
+            )
+        try:
+            return self._decode()
+        except (MSCDecodeError, MSCSecurityError):
+            raise
+        except Exception as e:
+            raise MSCDecodeError(
+                f"Error en {self._path_str()}: {e}"
+            ) from e
+        finally:
+            self.depth -= 1
+
+    def _path_str(self) -> str:
+        return ' → '.join(self.path) if self.path else '<root>'
+
+    def _read(self, n: int) -> bytes:
+        data = self.buf.read(n)
+        if len(data) < n:
+            raise MSCDecodeError(
+                f"Fin inesperado en {self._path_str()}: "
+                f"esperaba {n} bytes, obtuvo {len(data)}"
+            )
+        return data
+
+    def _read_length(self, max_val: int = MAX_COLLECTION) -> int:
+        n = struct.unpack('<I', self._read(4))[0]
+        if n > max_val:
+            raise MSCDecodeError(
+                f"Tamaño excede límite en {self._path_str()}: {n:,} > {max_val:,}"
+            )
+        return n
+
+    def _store_ref(self, obj: Any) -> Any:
+        self.refs[len(self.refs)] = obj
+        return obj
+
+    def _decode(self) -> Any:
+        tag = self._read(1)
+
+        if tag == _NONE:
+            return None
+
+        if tag == _BOOL:
+            return self._read(1) == b'\x01'
+
+        if tag == _INT:
+            n = struct.unpack('<H', self._read(2))[0]
+            return int.from_bytes(self._read(n), 'little', signed=True)
+
+        if tag == _FLOAT:
+            return struct.unpack('<d', self._read(8))[0]
+
+        if tag == _COMPLEX:
+            r, i = struct.unpack('<dd', self._read(16))
+            return complex(r, i)
+
+        if tag == _REF:
+            ref_id = struct.unpack('<I', self._read(4))[0]
+            if ref_id not in self.refs:
+                raise MSCDecodeError(
+                    f"Referencia inválida: {ref_id} en {self._path_str()}"
+                )
+            return self.refs[ref_id]
+
+        if tag == _STR:
+            n = self._read_length(MAX_STRING)
+            s = self._read(n).decode('utf-8')
+            return self._store_ref(s)
+
+        if tag == _BYTES:
+            n = self._read_length(MAX_STRING)
+            b = self._read(n)
+            return self._store_ref(b)
+
+        if tag == _BYTEARRAY:
+            n = self._read_length(MAX_STRING)
+            ba = bytearray(self._read(n))
+            return self._store_ref(ba)
+
+        if tag == _UUID:
+            raw = self._read(16)
+            return UUID(bytes=raw)
+
+        if tag == _PATH:
+            n = self._read_length(MAX_STRING)
+            s = self._read(n).decode('utf-8')
+            return Path(s)
+
+        if tag == _DATETIME:
+            n = struct.unpack('<H', self._read(2))[0]
+            s = self._read(n).decode('utf-8')
+            return datetime.fromisoformat(s)
+
+        if tag == _DATE:
+            y, m, d = struct.unpack('<HBB', self._read(4))
+            return date(y, m, d)
+
+        if tag == _TIME:
+            n = struct.unpack('<H', self._read(2))[0]
+            s = self._read(n).decode('utf-8')
+            return time.fromisoformat(s)
+
+        if tag == _TIMEDELTA2:
+            # v2.2: tag dedicado, sin ambiguedad
+            days, secs, us = struct.unpack('<iiI', self._read(12))
+            return timedelta(days=days, seconds=secs, microseconds=us)
+
+        if tag == _TIMEDELTA:
+            # Legacy: payloads v2.0/v2.1 usaban el mismo tag para 2 formatos.
+            # Heuristica: v2.1 = (days:i4, seconds:i4, microseconds:U4)
+            #             v2.0 = (days:i4, total_seconds:f8)
+            raw12 = self._read(12)
+            days_21, secs_21, us_21 = struct.unpack('<iiI', raw12)
+            if 0 <= secs_21 < 86400 and us_21 < 1_000_000:
+                return timedelta(days=days_21, seconds=secs_21, microseconds=us_21)
+            # Fallback v2.0
+            _days_20, total_20 = struct.unpack('<id', raw12)
+            return timedelta(seconds=total_20)
+
+        if tag == _DECIMAL:
+            n = struct.unpack('<H', self._read(2))[0]
+            s = self._read(n).decode('utf-8')
+            return Decimal(s)
+
+        if tag == _ENUM:
+            class_path = self._decode_str()
+            self.path.append(f'Enum({class_path})')
+            value = self.decode()
+            self.path.pop()
+            if self.strict:
+                cls = _get_registered(class_path)
+                return cls(value)
+            else:
+                return {'__enum__': class_path, '__value__': value}
+
+        if tag == _LIST:
+            n = self._read_length()
+            result = []
+            self._store_ref(result)
+            for i in range(n):
+                self.path.append(f'[{i}]')
+                result.append(self.decode())
+                self.path.pop()
+            return result
+
+        if tag == _TUPLE:
+            n = self._read_length()
+            items = []
+            for i in range(n):
+                self.path.append(f'({i})')
+                items.append(self.decode())
+                self.path.pop()
+            t = tuple(items)
+            return self._store_ref(t)
+
+        if tag == _FROZENSET:
+            n = self._read_length()
+            items = frozenset(self.decode() for _ in range(n))
+            return self._store_ref(items)
+
+        if tag == _SET:
+            n = self._read_length()
+            result = set()
+            self._store_ref(result)
+            result.update(self.decode() for _ in range(n))
+            return result
+
+        if tag == _DICT:
+            n = self._read_length()
+            result = {}
+            self._store_ref(result)
+            for _ in range(n):
+                k = self.decode()
+                self.path.append(f'.{k!r}' if isinstance(k, str) else f'[{k!r}]')
+                v = self.decode()
+                self.path.pop()
+                result[k] = v
+            return result
+
+        if tag == _NDARRAY:
+            try:
+                import numpy as np
+            except ImportError:
+                raise MSCDecodeError("numpy requerido para deserializar arrays")
+            meta = self._decode_str()
+            dtype_str, shape_str = meta.split('|')
+            if not _is_safe_dtype(dtype_str):
+                raise MSCSecurityError(
+                    f"numpy dtype no permitido en deserialización: {dtype_str!r}"
+                )
+            shape = tuple(int(x) for x in shape_str.split('x')) if shape_str else ()
+            n = self._read_length(MAX_SIZE)
+            raw = self._read(n)
+            arr = np.frombuffer(raw, dtype=np.dtype(dtype_str)).copy().reshape(shape)
+            return self._store_ref(arr)
+
+        if tag == _TENSOR:
+            try:
+                import torch
+                import numpy as np
+            except ImportError:
+                raise MSCDecodeError("torch y numpy requeridos para deserializar tensores")
+            meta = self._decode_str()
+            parts = meta.split('|')
+            dtype_str, shape_str = parts[0], parts[1]
+            requires_grad = parts[2] == '1' if len(parts) > 2 else False
+            if not _is_safe_dtype(dtype_str):
+                raise MSCSecurityError(
+                    f"tensor dtype no permitido: {dtype_str!r}"
+                )
+            shape = tuple(int(x) for x in shape_str.split('x')) if shape_str else ()
+            n = self._read_length(MAX_SIZE)
+            raw = self._read(n)
+            arr = np.frombuffer(raw, dtype=np.dtype(dtype_str)).copy().reshape(shape)
+            t = torch.from_numpy(arr)
+            if requires_grad:
+                t = t.requires_grad_(True)
+            return self._store_ref(t)
+
+        if tag == _OBJ:
+            class_path = self._decode_str()
+            self.path.append(class_path.rsplit('.', 1)[-1])
+            state = self.decode()
+            self.path.pop()
+
+            if self.strict:
+                cls = _get_registered(class_path)
+            elif _is_registered(class_path):
+                cls = _registry[class_path]
+            else:
+                return {'__class__': class_path, '__state__': state}
+
+            obj = cls.__new__(cls)
+            if dataclasses.is_dataclass(cls):
+                for k, v in state.items():
+                    setattr(obj, k, v)
+            elif hasattr(obj, '__slots__') and not hasattr(obj, '__dict__'):
+                for k, v in state.items():
+                    setattr(obj, k, v)
+            elif '__setstate__' in type(obj).__dict__ or any(
+                '__setstate__' in c.__dict__ for c in type(obj).__mro__[:-1]
+                if c is not object
+            ):
+                obj.__setstate__(state)
+            elif hasattr(obj, '__dict__'):
+                obj.__dict__.update(state)
+            else:
+                # Fallback: intentar setattr (cubre slots con __dict__ mixto)
+                for k, v in state.items():
+                    setattr(obj, k, v)
+            return obj
+
+        raise MSCDecodeError(
+            f"Tag desconocido: {tag!r} en {self._path_str()}"
+        )
+
+    def _decode_str(self) -> str:
+        """Decode string sin afectar ref counter (para metadata interna)."""
+        tag = self._read(1)
+        if tag != _STR:
+            raise MSCDecodeError(
+                f"Esperaba STR tag, obtuvo {tag!r} en {self._path_str()}"
+            )
+        n = self._read_length(MAX_STRING)
+        return self._read(n).decode('utf-8')
+
+
+# ──────────────────────── PUBLIC API ──────────────────────────────
+
+def dumps(obj: Any, *, with_crc: bool = False) -> bytes:
+    """Serializa obj a bytes."""
+    buf = io.BytesIO()
+    buf.write(MAGIC + VERSION)
+    flags = 0x01 if with_crc else 0x00
+    buf.write(struct.pack('B', flags))
+    enc = _Encoder(buf)
+    enc.encode(obj)
+    data = buf.getvalue()
+    if with_crc:
+        crc = zlib.crc32(data) & 0xFFFFFFFF
+        data += struct.pack('<I', crc)
+    return data
+
+
+def loads(data: bytes, *, strict: bool = True) -> Any:
+    """
+    Deserializa bytes a objeto.
+    strict=True: solo reconstruye clases registradas (lanza MSCSecurityError).
+    strict=False: clases no registradas retornan dict fallback.
+    """
+    if len(data) < 6:
+        raise MSCDecodeError("Datos demasiado cortos para ser MSC Serial")
+    buf = io.BytesIO(data)
+    magic = buf.read(4)
+    if magic != MAGIC:
+        raise MSCDecodeError(f"Magic bytes inválidos: {magic!r}")
+    ver = buf.read(1)
+    if ver == b'\x01':
+        # Retrocompatibilidad con v1.0 (sin flags)
+        dec = _Decoder(buf, strict=False)
+        return dec.decode()
+    if ver != VERSION:
+        raise MSCDecodeError(f"Versión no soportada: {ver!r}")
+    flags = struct.unpack('B', buf.read(1))[0]
+    has_crc = bool(flags & 0x01)
+    if has_crc:
+        payload = data[:-4]
+        stored_crc = struct.unpack('<I', data[-4:])[0]
+        computed_crc = zlib.crc32(payload) & 0xFFFFFFFF
+        if stored_crc != computed_crc:
+            raise MSCDecodeError(
+                f"CRC32 no coincide: almacenado={stored_crc:#010x}, "
+                f"calculado={computed_crc:#010x}"
+            )
+    dec = _Decoder(buf, strict=strict)
+    return dec.decode()
+
+
+def dump(obj: Any, file, **kwargs) -> None:
+    """Serializa obj al archivo (modo binario)."""
+    file.write(dumps(obj, **kwargs))
+
+
+def load(file, **kwargs) -> Any:
+    """Deserializa desde archivo (modo binario)."""
+    return loads(file.read(), **kwargs)
+
+
+def dump_compressed(obj: Any, file, level: int = 6, **kwargs) -> None:
+    """Serializa con compresión zlib."""
+    raw = dumps(obj, **kwargs)
+    compressed = zlib.compress(raw, level)
+    file.write(struct.pack('<I', len(raw)))
+    file.write(compressed)
+
+
+def load_compressed(file, **kwargs) -> Any:
+    """Deserializa desde archivo comprimido."""
+    orig_size = struct.unpack('<I', file.read(4))[0]
+    if orig_size > MAX_SIZE:
+        raise MSCDecodeError(f"Tamaño original excede límite: {orig_size:,}")
+    compressed = file.read()
+    if len(compressed) > MAX_COMPRESSED:
+        raise MSCDecodeError(
+            f"Datos comprimidos exceden límite: {len(compressed):,} > {MAX_COMPRESSED:,}"
+        )
+    raw = zlib.decompress(compressed, bufsize=orig_size)
+    if len(raw) > MAX_SIZE:
+        raise MSCDecodeError(
+            f"Datos descomprimidos exceden límite: {len(raw):,} > {MAX_SIZE:,}"
+        )
+    return loads(raw, **kwargs)
+
+
+def copy(obj: Any) -> Any:
+    """Deep copy vía serialización round-trip. Más seguro que copy.deepcopy."""
+    return loads(dumps(obj), strict=False)
+
+
+# ────────────────────── UTILIDADES ────────────────────────────────
+
+def inspect(data: bytes) -> dict:
+    """Retorna metadata del payload sin deserializar el objeto."""
+    if len(data) < 5 or data[:4] != MAGIC:
+        return {'valid': False, 'error': 'Magic bytes inválidos'}
+
+    ver = data[4]
+    info = {
+        'valid': True,
+        'version': ver,
+        'size_bytes': len(data),
+    }
+
+    root_tag = None
+    if ver == 1:
+        root_tag = data[5] if len(data) > 5 else None
+    elif ver == 2:
+        if len(data) > 6:
+            flags = data[5]
+            info['has_crc'] = bool(flags & 0x01)
+            root_tag = data[6]
+        else:
+            root_tag = None
+    else:
+        info['valid'] = False
+        info['error'] = f'Versión desconocida: {ver}'
+        return info
+
+    if root_tag is not None:
+        info['root_tag'] = hex(root_tag)
+        info['root_type'] = _TAG_NAMES.get(root_tag, 'unknown')
+
+    return info
+
+
+def benchmark(obj: Any, rounds: int = 100) -> dict:
+    """Mide rendimiento de serialización/deserialización."""
+    import time as _time
+
+    # Encode
+    t0 = _time.perf_counter()
+    for _ in range(rounds):
+        data = dumps(obj)
+    encode_time = (_time.perf_counter() - t0) / rounds
+
+    # Decode
+    t0 = _time.perf_counter()
+    for _ in range(rounds):
+        loads(data, strict=False)
+    decode_time = (_time.perf_counter() - t0) / rounds
+
+    # Compressed
+    raw_size = len(data)
+    buf = io.BytesIO()
+    dump_compressed(obj, buf)
+    comp_size = len(buf.getvalue())
+
+    return {
+        'encode_ms': round(encode_time * 1000, 3),
+        'decode_ms': round(decode_time * 1000, 3),
+        'raw_bytes': raw_size,
+        'compressed_bytes': comp_size,
+        'compression_ratio': round(raw_size / comp_size, 2) if comp_size else float('inf'),
+        'rounds': rounds,
+    }
+
+

mscs-2.2.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: mscs
+Version: 2.2.0
+Summary: Safe, fast serialization for Python — a secure replacement for pickle with native support for numpy arrays and PyTorch tensors.
+Project-URL: Homepage, https://github.com/esraderey/mscs
+Project-URL: Repository, https://github.com/esraderey/mscs
+Project-URL: Issues, https://github.com/esraderey/mscs/issues
+Author: Esraderey
+License-Expression: MIT
+License-File: LICENSE
+Keywords: binary,checkpoint,fast,numpy,pickle,pytorch,safe,secure,serialization,tensor
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: all
+Requires-Dist: numpy>=1.20; extra == 'all'
+Requires-Dist: torch>=2.0; extra == 'all'
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.20; extra == 'numpy'
+Provides-Extra: torch
+Requires-Dist: numpy>=1.20; extra == 'torch'
+Requires-Dist: torch>=2.0; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# MSCS — Safe Serialization for Python
+
+A secure, fast, binary serialization library. Drop-in replacement for `pickle` that **never executes arbitrary code** during deserialization.
+
+Built for AI/ML workflows — native support for **NumPy arrays** and **PyTorch tensors** with zero-copy performance.
+
+## Why not pickle?
+
+```python
+# pickle: arbitrary code execution on load
+data = pickle.loads(untrusted_bytes)  # can run os.system("rm -rf /")
+
+# mscs: only reconstructs explicitly registered classes
+data = mscs.loads(untrusted_bytes)    # MSCSecurityError if class not registered
+```
+
+## Install
+
+```bash
+pip install mscs              # core (no dependencies)
+pip install mscs[numpy]       # + numpy support
+pip install mscs[torch]       # + numpy + PyTorch tensor support
+pip install mscs[all]         # everything
+```
+
+## Quick Start
+
+```python
+import mscs
+
+# Primitives, collections, nested structures — just works
+data = {"model": "v5.2", "lr": 0.001, "layers": [64, 128, 256]}
+encoded = mscs.dumps(data)
+decoded = mscs.loads(encoded)
+
+# NumPy arrays
+import numpy as np
+arr = np.random.randn(100, 100).astype(np.float32)
+encoded = mscs.dumps(arr)  # 39 KB (vs 39.5 KB pickle)
+
+# PyTorch tensors — no .numpy() conversion needed
+import torch
+weights = torch.randn(256, 256)
+encoded = mscs.dumps(weights)  # safe, no pickle involved
+
+# Full model checkpoints
+checkpoint = {
+    "epoch": 100,
+    "model_state": {k: v for k, v in model.state_dict().items()},
+    "optimizer_lr": 0.0003,
+}
+mscs.dump(checkpoint, open("checkpoint.mscs", "wb"))
+restored = mscs.load(open("checkpoint.mscs", "rb"))
+```
+
+## Custom Classes
+
+```python
+import mscs
+from dataclasses import dataclass
+
+@mscs.register
+@dataclass
+class Config:
+    state_size: int = 256
+    lr: float = 0.001
+
+config = Config(512, 0.0003)
+data = mscs.dumps(config)
+restored = mscs.loads(data)  # Config(state_size=512, lr=0.0003)
+
+# Unregistered classes raise MSCSecurityError in strict mode
+mscs.loads(data_with_unknown_class)  # MSCSecurityError
+
+# Or get a dict fallback in non-strict mode
+mscs.loads(data_with_unknown_class, strict=False)  # {'__class__': '...', '__state__': {...}}
+```
+
+### Backward Compatibility with Renamed Classes
+
+```python
+# Class was renamed from OldConfig to Config
+mscs.register_alias("my_module.OldConfig", Config)
+# Old checkpoints now deserialize correctly
+```
+
+### Register All Classes in a Module
+
+```python
+import my_models
+mscs.register_module(my_models)  # registers all classes defined in the module
+```
+
+## Compression & Integrity
+
+```python
+# zlib compression
+with open("data.mscs.z", "wb") as f:
+    mscs.dump_compressed(large_obj, f)
+
+with open("data.mscs.z", "rb") as f:
+    obj = mscs.load_compressed(f)
+
+# CRC32 integrity check
+data = mscs.dumps(obj, with_crc=True)
+mscs.loads(data)  # verifies CRC, raises MSCDecodeError if corrupted
+```
+
+## API Reference
+
+### Core
+
+| Function | Description |
+|----------|------------|
+| `dumps(obj, *, with_crc=False) -> bytes` | Serialize to bytes |
+| `loads(data, *, strict=True) -> Any` | Deserialize from bytes |
+| `dump(obj, file, **kwargs)` | Serialize to file (binary mode) |
+| `load(file, **kwargs) -> Any` | Deserialize from file |
+| `dump_compressed(obj, file, level=6)` | Serialize with zlib compression |
+| `load_compressed(file) -> Any` | Deserialize compressed data |
+
+### Registry
+
+| Function | Description |
+|----------|------------|
+| `register(cls) -> cls` | Register class as safe (also works as decorator) |
+| `register_alias(old_path, cls)` | Map old class path to new class |
+| `register_module(module) -> list` | Register all classes in a module |
+
+### Utilities
+
+| Function | Description |
+|----------|------------|
+| `inspect(data) -> dict` | Get metadata without deserializing |
+| `benchmark(obj, rounds=100) -> dict` | Measure encode/decode performance |
+| `copy(obj) -> obj` | Deep copy via serialization round-trip |
+
+## Supported Types
+
+| Type | Tag | Notes |
+|------|-----|-------|
+| `None`, `bool`, `int`, `float`, `complex` | Built-in | Arbitrary precision ints |
+| `str`, `bytes`, `bytearray` | Built-in | UTF-8, ref-tracked |
+| `list`, `tuple`, `dict`, `set`, `frozenset` | Built-in | Circular refs supported |
+| `datetime`, `date`, `time`, `timedelta` | Built-in | ISO 8601 |
+| `Decimal`, `UUID`, `Path` | Built-in | Lossless |
+| `Enum` | Registry | Must be registered |
+| `numpy.ndarray` | Built-in | dtype whitelist enforced |
+| `torch.Tensor` | Built-in | Auto CPU transfer, preserves requires_grad |
+| `dataclass`, `__slots__`, `__dict__` | Registry | Must be registered |
+
+## Performance
+
+Benchmarked on a state_dict with 4 tensors (~57K parameters):
+
+| Method | Roundtrip | Size | Safe |
+|--------|-----------|------|------|
+| **mscs** | **0.098 ms** | **65 KB** | **Yes** |
+| pickle | 0.580 ms | 68 KB | No (RCE) |
+| torch.save | 0.437 ms | 67 KB | No (RCE) |
+
+**5.9x faster than pickle, 4.1x faster than torch.save** — while being the only option that doesn't allow arbitrary code execution.
+
+Tensor scaling (encode+decode):
+
+| Shape | mscs | pickle | Speedup |
+|-------|------|--------|---------|
+| 10x10 | 0.019 ms | 0.156 ms | 8.2x |
+| 256x256 | 0.069 ms | 0.278 ms | 4.0x |
+| 1024x1024 | 4.7 ms | 5.0 ms | 1.1x |
+
+## Security Model
+
+1. **No code execution**: Deserialization only reconstructs data, never runs arbitrary code
+2. **Explicit registry**: Custom classes must be registered before deserialization
+3. **No dynamic imports**: Class names in the binary stream are only used as registry keys
+4. **NumPy dtype whitelist**: Blocks `object`, `void`, and structured dtypes
+5. **Configurable limits**: `MAX_DEPTH=256`, `MAX_SIZE=512MB`, `MAX_COLLECTION=10M`
+6. **Anti zip-bomb**: `load_compressed` validates both compressed and decompressed sizes
+7. **CRC32 integrity**: Optional checksum to detect corruption
+8. **Auditable format**: Magic bytes (`MSCS`) + version byte + type tags
+
+## Binary Format
+
+```
+[MSCS][version:1][flags:1][type_tag:1][...payload...]
+```
+
+- Magic: `MSCS` (4 bytes)
+- Version: `\x02` (1 byte)
+- Flags: bit 0 = CRC32 appended (1 byte)
+- Payload: recursive type-tagged binary data
+- Optional CRC32 trailer (4 bytes)
+
+## License
+
+MIT

mscs-2.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+mscs/__init__.py,sha256=X6eNeE47moHbJpHGuQ-PycJcpdFdcnijCVbogTwZ0Sc,1003
+mscs/_core.py,sha256=blerUQ1qYLW-0LxP0Va-P-z6fXh_85mU4Kk3aCmp0Gc,35301
+mscs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mscs-2.2.0.dist-info/METADATA,sha256=Y86KzbN95zSBT2ev2tmMaeFh_D3CG6UTXv6saCduXjE,7756
+mscs-2.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mscs-2.2.0.dist-info/licenses/LICENSE,sha256=5JE5UgNWDjlc72iGP35F3hwU6b787nIO02slbWRjsfw,1066
+mscs-2.2.0.dist-info/RECORD,,

mscs-2.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mscs-2.2.0.dist-info/licenses/LICENSE

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