flpit 0.2.1.dev3__tar.gz → 0.2.1.dev4__tar.gz

{flpit-0.2.1.dev3 → flpit-0.2.1.dev4}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.5
 Name: flpit
-Version: 0.2.1.dev3
+Version: 0.2.1.dev4
 Summary: Fluent LINQ for Python — flip your iterables
 Project-URL: Homepage, https://github.com/riemar/flpit
+Project-URL: Repository, https://github.com/riemar/flpit
 License: MIT
 License-File: LICENSE
 Keywords: fluent,generators,iterable,lazy-evaluation,linq,pipeline,pyrefly,type-safe
@@ -10,7 +11,6 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14

{flpit-0.2.1.dev3 → flpit-0.2.1.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flpit"
-version = "0.2.1.dev3"
+version = "0.2.1.dev4"
 description = "Fluent LINQ for Python — flip your iterables"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -11,7 +11,6 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
@@ -24,6 +23,7 @@ dependencies = [
 
 [project.urls]
 Homepage = "https://github.com/riemar/flpit"
+Repository = "https://github.com/riemar/flpit"
 
 [dependency-groups]
 dev = [

{flpit-0.2.1.dev3 → flpit-0.2.1.dev4}/src/flpit/core/linq.py

@@ -1,3 +1,4 @@
+from flpit.io import StringWriter
 import decimal
 from decimal import Decimal, Overflow, Inexact
 
@@ -26,7 +27,8 @@ from typing import (
     GenericAlias
 )
 
-from flpit.json import JsonSerializerOptions, decode_dataclass, encode_dataclass
+from flpit.io import MemoryByteWriter
+from flpit.json import JsonConvert, JsonSerializerOptions
 
 TItem = TypeVar("TItem")
 TResult = TypeVar("TResult")
@@ -625,6 +627,24 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
         """Explicitly materializes the query into a FlpList."""
         return FlpList[TItem](self)
 
+    # =====================================================================
+    # 5. json serialization
+    # =====================================================================
+
+    @classmethod
+    def from_json[T](cls, data: str | bytes, item_type: type[T], jso: JsonSerializerOptions|None=None) -> FlpIt[T]:
+        return FlpIt[T](JsonConvert.deserialize(data, list[item_type], jso))
+
+    def to_json_bytes[T](self, item_type: type[T], jso: JsonSerializerOptions|None=None) -> bytes:
+        writer = MemoryByteWriter()
+        JsonConvert.serialize_to(self, item_type, writer, jso)
+        return writer.getvalue()
+
+    def to_json[T](self, item_type: type[T], jso: JsonSerializerOptions|None=None) -> str:
+        writer = StringWriter()
+        JsonConvert.serialize_to(self, item_type, writer, jso)
+        return writer.getvalue()
+
 
 from functools import partial
 
@@ -1192,12 +1212,12 @@ class FlpList(Collection[TItem], Generic[TItem]):
 
     @classmethod
     def from_json[T](cls, data: str | bytes, item_type: type[T], jso: JsonSerializerOptions|None=None) -> FlpList[T]:
-        return FlpList[T](decode_dataclass(data, list[item_type], jso))
+        return FlpList[T](JsonConvert.deserialize(data, list[item_type], jso))
 
     def to_json_bytes[T](self, item_type: type[T], jso: JsonSerializerOptions|None=None) -> bytes:
-        return encode_dataclass(self.__list.data, list[item_type], jso)
+        return JsonConvert.serialize_bytes(self.__list.data, list[item_type], jso)
 
     def to_json[T](self, item_type: type[T], jso: JsonSerializerOptions|None=None) -> str:
-        return self.to_json_bytes(item_type, jso).decode(encoding="utf-8")
+        return JsonConvert.serialize(self.__list.data, list[item_type], jso)
 
 

flpit-0.2.1.dev4/src/flpit/io.py

@@ -0,0 +1,212 @@
+from types import TracebackType
+from abc import ABC, abstractmethod
+from io import StringIO, TextIOWrapper
+from typing import Any, BinaryIO, Iterable
+
+import msgspec
+
+
+# ---------- Text layer ----------
+
+class StringBuilder:
+    __slots__ = ("_buffer", "_length")
+
+    def __init__(self, initial_value: str = ""):
+        self._buffer = StringIO()
+        self._length = 0
+        self.append(initial_value)
+
+    def append(self, text: str) -> "StringBuilder":
+        self._buffer.write(text)
+        self._length += len(text)
+        return self
+
+    def append_line(self, text: str = "") -> "StringBuilder":
+        return self.append(text).append("\n")
+
+    def clear(self) -> None:
+        self._buffer.seek(0)
+        self._buffer.truncate(0)
+        self._length = 0
+
+    @property
+    def length(self) -> int:
+        return self._length
+
+    def to_string(self) -> str:
+        return self._buffer.getvalue()
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+
+class TextWriter(ABC):
+    @abstractmethod
+    def write(self, text: str) -> int:
+        ...
+
+    def write_line(self, text: str = "") -> None:
+        self.write(text)
+        self.write("\n")
+
+    @abstractmethod
+    def flush(self) -> None:
+        ...
+
+    @abstractmethod
+    def close(self) -> None:
+        ...
+
+    def __enter__(self):
+        return self
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: TracebackType | None,
+    ) -> bool | None:
+        self.close()
+
+
+class StringWriter(TextWriter):
+    def __init__(self):
+        self._builder = StringBuilder()
+        self._closed = False
+
+    def write(self, text: str) -> int:
+        if self._closed:
+            raise ValueError("Writer is closed")
+        self._builder.append(text)
+        return len(text)
+
+    def flush(self) -> None:
+        if self._closed:
+            raise ValueError("Writer is closed")
+
+    def close(self) -> None:
+        self._closed = True
+
+    def getvalue(self) -> str:
+        return self._builder.to_string()
+
+
+class StreamWriter(TextWriter):
+    """Text writer over a binary stream; closing it closes the stream."""
+
+    def __init__(self, stream: BinaryIO, encoding: str = "utf-8"):
+        self._stream = TextIOWrapper(stream, encoding=encoding)
+
+    def write(self, text: str) -> int:
+        return self._stream.write(text)
+
+    def flush(self) -> None:
+        self._stream.flush()
+
+    def close(self) -> None:
+        self._stream.close()
+
+#===================================
+# ---------- Binary layer ----------
+#===================================
+
+class ByteWriter(ABC):
+    """write() must consume or copy the supplied bytes before returning."""
+
+    @abstractmethod
+    def write(self, data: bytes | bytearray | memoryview) -> None:
+        ...
+
+    @abstractmethod
+    def flush(self) -> None:
+        ...
+
+class MemoryByteWriter(ByteWriter):
+    def __init__(self):
+        self._buffer = bytearray()
+
+    def write(self, data: bytes | bytearray | memoryview) -> None:
+        self._buffer.extend(data)
+
+    def flush(self) -> None:
+        pass
+
+    def getvalue(self) -> bytes:
+        return bytes(self._buffer)
+
+
+class StreamByteWriter(ByteWriter):
+    """Adapter for a Python binary stream. The caller owns the stream."""
+
+    def __init__(self, stream: BinaryIO):
+        self._stream = stream
+
+    def write(self, data: bytes | bytearray | memoryview) -> None:
+        view = memoryview(data)
+
+        while view:
+            count = self._stream.write(view)
+            if count is None or count <= 0:
+                raise OSError("Stream failed to write data")
+            view = view[count:]
+
+    def flush(self) -> None:
+        self._stream.flush()
+
+
+class BufferedByteWriter(ByteWriter):
+    """Adds explicit, bounded-size output buffering to another writer."""
+
+    def __init__(self, destination: ByteWriter, chunk_size: int = 1 << 20):
+        if chunk_size < 1:
+            raise ValueError("chunk_size must be positive")
+
+        self._destination = destination
+        self._chunk_size = chunk_size
+        self._buffer = bytearray()
+
+    def write(self, data: bytes | bytearray | memoryview) -> None:
+        view = memoryview(data)
+
+        while view:
+            count = min(
+                self._chunk_size - len(self._buffer),
+                len(view),
+                )
+            self._buffer.extend(view[:count])
+            view = view[count:]
+
+            if len(self._buffer) == self._chunk_size:
+                self._flush_buffer()
+
+    def _flush_buffer(self) -> None:
+        if self._buffer:
+            self._destination.write(self._buffer)
+            self._buffer.clear()
+
+    def flush(self) -> None:
+        self._flush_buffer()
+        self._destination.flush()
+
+
+# ---------- JSON serialization policy ----------
+
+def write_json_array(
+        items: Iterable[Any],
+        output: ByteWriter,
+) -> None:
+    encoder = msgspec.json.Encoder()
+    scratch = bytearray()
+    first = True
+
+    output.write(b"[")
+
+    for item in items:
+        if not first:
+            output.write(b",")
+
+        encoder.encode_into(item, scratch)
+        output.write(scratch)
+        first = False
+
+    output.write(b"]")

flpit-0.2.1.dev4/src/flpit/json.py

@@ -0,0 +1,632 @@
+from collections.abc import Iterable
+import dataclasses
+import re
+import sys
+import threading
+import types
+import typing
+from dataclasses import MISSING, dataclass
+from enum import StrEnum
+from functools import lru_cache
+from hashlib import blake2s
+from typing import Annotated, Any, ForwardRef, get_args, get_origin, get_type_hints, Callable, cast as typing_cast
+
+import msgspec
+
+from flpit.io import ByteWriter, TextWriter
+
+
+class JsonNamingPolicy(StrEnum):
+    lower = "lower" # pyrefly: ignore [bad-override-mutable-attribute]
+    upper = "upper" # pyrefly: ignore [bad-override-mutable-attribute]
+    camel = "camel"
+    pascal = "pascal"
+    kebap = "kebab"
+
+
+class JsonDefaultHandling(StrEnum):
+    include = "include"
+    exclude = "exclude"
+
+class JsonUnknownFieldHandling(StrEnum):
+    allow = "allow"
+    disallow = "disallow"
+
+
+@dataclass(slots=True, frozen=True)
+class JsonSerializerOptions:
+    naming_policy: JsonNamingPolicy = JsonNamingPolicy.camel
+    default_handling: JsonDefaultHandling = JsonDefaultHandling.exclude
+    unknown_field_handling: JsonUnknownFieldHandling = JsonUnknownFieldHandling.allow
+
+    # write_indented: bool = False # will be supported later
+    native: bool = False
+    """
+    | Set to true for the native speed of msgspec
+    
+    !! only set to true if you know what you are doing !!
+    You'll receive the msgspec.msgstruct object that will try to do it's best to behave like your dataclass.
+    But remember !! "It's NOT your dataclass" !!
+    """
+
+    @property
+    def fingerprint(self) -> str:
+        """
+        Identifies a unique jso instance for building a struct
+        !! All parts of a jso that don't influence the defstruct MUST be ignored!
+        """
+        settings = (f"jpn-{self.naming_policy.value}:"
+                   f"dh-{self.default_handling}:"
+                   f"ufh-{self.unknown_field_handling}:"
+                   ).encode("utf-8")
+        return blake2s(settings, digest_size=6).hexdigest()
+
+# ---------------------------------------------------------------------------
+# Metadata Annotation Markers
+# ---------------------------------------------------------------------------
+
+class JsonIgnore:
+    def __class_getitem__[T](cls, item: type[T]) -> Any:
+        return Annotated[item, cls]
+
+class JsonInclude:
+    def __class_getitem__[T](cls, item: type[T]) -> Any:
+        return Annotated[item, cls]
+
+class JsonProperty:
+    def __class_getitem__[T](cls, item: tuple[type[T], str]) -> Any:
+        target_type, json_name = item
+        return Annotated[target_type, cls(json_name)]
+
+    def __init__(self, name: str):
+        self.name = name
+
+JIgnore = JsonIgnore
+JInclude = JsonInclude
+JProp = JsonProperty
+
+# ---------------------------------------------------------------------
+# Generated type metadata
+# ---------------------------------------------------------------------
+
+@dataclass(slots=True, eq=False)
+class _WireType:
+    source: type
+    """The source type to build a msgspec.struct for"""
+    hints: dict[str, Any]
+    namespace: types.ModuleType
+    """the name space we are targeting"""
+    struct: type | None = None
+
+    @property
+    def module_name(self: _WireType) -> str:
+        return self.namespace.__name__
+
+    @property
+    def class_name(self: _WireType) -> str:
+        return self.source.__name__
+
+    @property
+    def ref_name(self: _WireType) -> str:
+        identity = (
+            f"{self.source.__module__}_{self.source.__qualname__}"
+        )
+        return "_ref_" + re.sub(r"\W", "_", identity)
+
+
+# ---------------------------------------------------------------------
+# Never imagined this would be required to have a proper lib behavior
+# ---------------------------------------------------------------------
+
+def _apply_naming_policy(name: str, policy: JsonNamingPolicy) -> str:
+    """
+    Splits any attribute name (snake_case, PascalCase, UPPER_CASE)
+    into individual tokens and formats them according to the target policy.
+    """
+    # 1. Check if there is a leading underscore and save it
+    prefix = "_" if name.startswith("_") else ""
+    clean_name = name.lstrip("_")
+
+    # 2. Tokenize only the clean part of the string
+    tokens = [t for t in re.split(r'_(?=[a-zA-Z])|(?<=[a-z])(?=[A-Z])', clean_name) if t]
+    if not tokens:
+        return name
+
+    if policy == JsonNamingPolicy.lower:
+        result = "".join(t.lower() for t in tokens)
+
+    if policy == JsonNamingPolicy.upper:
+        result = "".join(t.upper() for t in tokens)
+
+    if policy == JsonNamingPolicy.pascal:
+        result = "".join(t.capitalize() for t in tokens)
+
+    if policy == JsonNamingPolicy.kebap:
+        result = "-".join(t.lower() for t in tokens)
+
+    if policy == JsonNamingPolicy.camel:
+        # Lowercase the first token completely, capitalize all subsequent tokens
+        result = tokens[0].lower() + "".join(t.capitalize() for t in tokens[1:])
+
+    else:
+        result = clean_name
+
+    return prefix + result
+
+
+
+def _generated_module(source: type) -> types.ModuleType:
+    """Generates the required module definition for our runtime only dynamic msgspec.struct"""
+    name = f"flpit.json._generated.{source.__module__}"
+
+    module = sys.modules.get(name)
+    if module is None:
+        module = types.ModuleType(name)
+        sys.modules[name] = module
+
+    return module
+
+
+def _is_dataclass_type(tp: Any) -> bool:
+    return isinstance(tp, type) and dataclasses.is_dataclass(tp)
+
+
+def _field_directives(
+        annotation: Any,
+) -> tuple[Any, bool, bool, str | None]:
+    """Extract JIgnore, JInclude, and JProp directives from a field annotation."""
+
+    if get_origin(annotation) is not typing.Annotated:
+        return annotation, False, False, None
+
+    args = get_args(annotation)
+    base_type = args[0]
+    metadata = args[1:]
+    ignored = any(item is JsonIgnore for item in metadata)
+    included = any(item is JsonInclude for item in metadata)
+    json_name = next(
+        (item.name for item in metadata if isinstance(item, JsonProperty)),
+        None,
+    )
+    remaining = tuple(
+        item
+        for item in metadata
+        if item is not JsonIgnore
+        and item is not JsonInclude
+        and not isinstance(item, JsonProperty)
+    )
+
+    if remaining:
+        base_type = Annotated[(base_type, *remaining)]
+
+    return base_type, ignored, included, json_name
+
+
+def _get_property_directive(prop_func: Callable[[Any, Any], None] | Callable[[Any], Any] | None):
+    if prop_func is not None:
+        getter_hints = get_type_hints(prop_func, include_extras=True)
+        source_annotation = getter_hints.get("return", Any)
+    else:
+        source_annotation = Any
+
+    return  _field_directives(source_annotation)
+
+
+def _nested_dataclasses(tp: Any):
+    """Yield dataclass types referenced by an annotation."""
+    if _is_dataclass_type(tp):
+        yield tp
+        return
+
+    if isinstance(tp, (list, tuple)):
+        for item in tp:
+            yield from _nested_dataclasses(item)
+        return
+
+    origin = get_origin(tp)
+
+    if origin is typing.Annotated:
+        yield from _nested_dataclasses(get_args(tp)[0])
+        return
+
+    if origin is typing.Literal:
+        return
+
+    for arg in get_args(tp):
+        yield from _nested_dataclasses(arg)
+
+
+def _rewrite_type(
+        tp: Any,
+        owner: _WireType,
+        graph: dict[type, _WireType],
+        *,
+        resolve: bool = False,
+) -> Any:
+    """Replace source dataclasses with generated Structs or ForwardRefs."""
+    if tp is getattr(typing, "Self", None):
+        info = owner
+        return info.struct if resolve else ForwardRef(info.ref_name)
+
+    if _is_dataclass_type(tp):
+        info = graph[tp]
+        return info.struct if resolve else ForwardRef(info.ref_name)
+
+    if isinstance(tp, list):
+        return [
+            _rewrite_type(item, owner, graph, resolve=resolve)
+            for item in tp
+        ]
+
+    if isinstance(tp, tuple):
+        return tuple(
+            _rewrite_type(item, owner, graph, resolve=resolve)
+            for item in tp
+        )
+
+    origin = get_origin(tp)
+
+    if origin is None or origin is typing.Literal:
+        return tp
+
+    args = get_args(tp)
+
+    if origin is typing.Annotated:
+        base = _rewrite_type(
+            args[0], owner, graph, resolve=resolve
+        )
+        return typing.Annotated[(base, *args[1:])]
+
+    rewritten: tuple[Any, ...] = tuple(
+        _rewrite_type(arg, owner, graph, resolve=resolve)
+        for arg in args
+    )
+
+    if origin in (typing.Union, types.UnionType):
+        union: Any = typing.Union # with all the magic here, there's no way to make typing really happy
+        return union[rewritten]
+
+    params = rewritten[0] if len(rewritten) == 1 else rewritten
+
+    try:
+        return origin[params]
+    except (TypeError, AttributeError) as exc:
+        copier = getattr(tp, "copy_with", None)
+        if copier is not None:
+            return copier(rewritten)
+
+        raise TypeError(
+            f"Cannot rewrite annotation {tp!r}"
+        ) from exc
+
+
+# ---------------------------------------------------------------------
+# Graph discovery
+# ---------------------------------------------------------------------
+
+
+def _discover_graph(
+        roots: tuple[type, ...],
+) -> dict[type, _WireType]:
+    """Discover reachable dataclasses and resolve their annotations."""
+    graph: dict[type, _WireType] = {}
+    pending = list(roots)
+
+    while pending:
+        source = pending.pop()
+
+        if source in graph:
+            continue
+
+        info = _WireType(
+            source=source,
+            hints=get_type_hints(source, include_extras=True),
+            namespace=_generated_module(source),
+        )
+        graph[source] = info
+
+        for field in dataclasses.fields(source):
+            annotation, ignored, included, _ = _field_directives(
+                info.hints[field.name]
+            )
+            if ignored:
+                continue
+
+            pending.extend(_nested_dataclasses(annotation))
+
+    return graph
+
+
+def _allows_none(tp: Any) -> bool:
+    if get_origin(tp) is typing.Annotated:
+        tp = get_args(tp)[0]
+
+    return type(None) in get_args(tp)
+
+# ---------------------------------------------------------------------
+# Struct construction
+# ---------------------------------------------------------------------
+
+
+def _struct_fields(
+        info: _WireType,
+        graph: dict[type, _WireType],
+        jso: JsonSerializerOptions,
+) -> list[tuple[Any, ...]]:
+    definitions: list[tuple[Any, ...]] = []
+    dataclass_fields = {f.name for f in dataclasses.fields(info.source)}
+
+    # 1. Process regular fields (regardless of init=True or init=False)
+    for field in dataclasses.fields(info.source):
+        source_annotation = info.hints[field.name]
+        annotation, ignored, included, json_name = _field_directives(source_annotation)
+
+        if ignored:
+            continue
+
+        # If the field starts with an underscore, it MUST have JInclude or JProp attached!
+        if field.name.startswith("_") and not (included or json_name is not None):
+            continue
+
+        annotation = _rewrite_type(annotation, info, graph)
+        wire_name = json_name if json_name is not None else _apply_naming_policy(field.name, jso.naming_policy)
+
+        # Resolve structural field default values cleanly
+        if field.default is not MISSING:
+            default_val = field.default
+            has_default = True
+        elif field.default_factory is not MISSING:
+            default_val = msgspec.field(default_factory=field.default_factory)
+            has_default = True
+        elif _allows_none(annotation):
+            default_val = None
+            has_default = True
+        else:
+            default_val = MISSING
+            has_default = False
+
+        field_options: dict[str, Any] = {"name": wire_name}
+        if has_default:
+            if field.default_factory is not MISSING:
+                field_options["default_factory"] = field.default_factory
+            else:
+                field_options["default"] = default_val
+
+        spec = (field.name, annotation, msgspec.field(**field_options))
+        definitions.append(spec)
+
+    # 2. Process properties automatically
+    for name, value in vars(info.source).items():
+        if isinstance(value, property) and name not in dataclass_fields:
+            # Extract the type annotation directly from the getter function signature
+            if value.fset is not None:
+                _, _, included, json_name = _get_property_directive(value.fset)
+
+                if included or json_name is not None:
+                    raise ValueError(
+                        f"{info.source.__qualname__}.{name}: "
+                        "fplit.json with msgspec backend doesn't support "
+                        "JProp/JInclude on property setters"
+                    )
+
+            annotation, ignored, included, json_name = _get_property_directive(value.fget)
+
+            if not included and json_name is None:
+                continue
+
+            annotation = _rewrite_type(annotation, info, graph)
+            wire_name = json_name if json_name is not None else _apply_naming_policy(name, jso.naming_policy)
+
+            # Map the field into the C-struct. Default to None so the inbound parser never complains.
+            spec = (name, annotation, msgspec.field(name=wire_name, default=None))
+            definitions.append(spec)
+
+
+    return definitions
+
+
+def _register_forward_refs(
+        graph: dict[type, _WireType],
+) -> None:
+    """Expose every graph reference in each participating module."""
+    namespaces = []
+
+    for info in graph.values():
+        if not any(info.namespace is ns for ns in namespaces):
+            namespaces.append(info.namespace)
+
+    for namespace in namespaces:
+        for info in graph.values():
+            setattr(namespace, info.ref_name, info.struct)
+
+
+def _behavior_namespace(source: type) -> dict[str, Any]:
+    return {
+        name: value
+        for name, value in vars(source).items()
+        if (
+                not name.startswith("__")
+                and (callable(value) or isinstance(value, property))
+        )
+        # pyrefly: ignore [implicit-any-lambda]
+    } | {  "__class__": property(lambda self, cls=source: cls) }
+
+
+def _create_structs(
+        graph: dict[type, _WireType],
+        jso: JsonSerializerOptions,
+) -> None:
+    """Create the generated msgspec structs for every node in the graph."""
+    for wt in graph.values():
+        fields = _struct_fields(wt, graph, jso)
+        wt.struct = msgspec.defstruct(
+            wt.class_name,
+            fields,
+            module=wt.module_name,
+            namespace=_behavior_namespace(wt.source),
+            rename=None,
+            kw_only=False,
+            omit_defaults=jso.default_handling.value == JsonDefaultHandling.exclude,
+            forbid_unknown_fields=jso.unknown_field_handling.value == JsonUnknownFieldHandling.disallow,
+        )
+
+
+def _validate_structs(graph: dict[type, _WireType]) -> None:
+    """Force msgspec to inspect each generated struct after refs are registered."""
+    for wt in graph.values():
+        msgspec.inspect.type_info(wt.struct)
+
+
+def _publish_structs(graph: dict[type, _WireType]) -> None:
+    # Publish the readable generated class names.
+    for wt in graph.values():
+        setattr(wt.namespace, wt.class_name, wt.struct)
+
+
+def _build_graph(
+        roots: tuple[type, ...],
+        jso: JsonSerializerOptions,
+) -> dict[type, _WireType]:
+    graph = _discover_graph(roots)
+    _create_structs(graph, jso)
+    _register_forward_refs(graph)
+    _validate_structs(graph)
+    _publish_structs(graph)
+    return graph
+
+
+# ---------------------------------------------------------------------
+# Cache and public API
+# ---------------------------------------------------------------------
+
+# we must only build new when the
+_jso_registry: dict[str, JsonSerializerOptions] = {}
+_registry_lock = threading.Lock()
+
+
+@lru_cache(maxsize=None)
+def _wrapped_lru(roots: tuple[type, ...], jso_id: str):
+    with _registry_lock:
+        jso = _jso_registry[jso_id]
+
+    return _build_graph(roots, jso)
+
+
+@lru_cache(maxsize=None)
+def _cached_wire_type(target_type: object, jso_id: str):
+    roots = tuple(_nested_dataclasses(target_type))
+
+    if not roots:
+        raise TypeError(
+            "Only @dataclass are supported!, "
+            f"got {target_type!r}"
+        )
+
+    graph_roots = tuple(sorted(set(roots), key=id))
+    graph = _wrapped_lru(graph_roots, jso_id)
+
+    return _rewrite_type(
+        target_type,
+        graph[roots[0]],
+        graph,
+        resolve=True,
+    )
+
+
+def wire_type_for(target_type: type, jso: JsonSerializerOptions) -> type:
+    jso_id = jso.fingerprint
+
+    with _registry_lock:
+        _jso_registry[jso_id] = jso
+
+    return _cached_wire_type(target_type, jso_id)
+
+
+@lru_cache(maxsize=256)
+def _get_decoder(wire_type: Any):
+    return msgspec.json.Decoder(type=wire_type)
+
+
+_JSON_ENCODER = msgspec.json.Encoder()
+
+
+class JsonConvert:
+
+    @staticmethod
+    def deserialize[T](
+            data: bytes | str,
+            target: type[T],
+            jso: JsonSerializerOptions | None = None
+    ) -> T:
+        if jso is None:
+            jso = JsonSerializerOptions()
+
+        wire_type = wire_type_for(target, jso)
+        parsed = _get_decoder(wire_type).decode(data)
+
+        if jso.native:
+            return parsed
+
+        result = msgspec.convert(
+            parsed,
+            target,
+            from_attributes=True,
+        )
+
+        return result
+
+    @staticmethod
+    def serialize[T](
+            data: Any,
+            target: type[T],
+            jso: JsonSerializerOptions | None = None
+    ) -> str:
+        return JsonConvert.serialize_bytes(data, target, jso).decode("utf-8")
+
+    @staticmethod
+    def serialize_bytes[T](
+            data: Any,
+            target: type[T],
+            jso: JsonSerializerOptions | None = None
+    ) -> bytes:
+        if jso is None:
+            jso = JsonSerializerOptions()
+
+        wire_type = wire_type_for(target, jso)
+        wire_obj = msgspec.convert(data, wire_type, from_attributes=True)
+        return _JSON_ENCODER.encode(wire_obj)
+
+    @staticmethod
+    def serialize_to[T](
+            it: Iterable[T],
+            target: type[T],
+            output: ByteWriter | TextWriter,
+            jso: JsonSerializerOptions | None = None
+    ) -> None:
+        if jso is None:
+            jso = JsonSerializerOptions()
+
+        if isinstance(output, ByteWriter):
+            write = output.write
+        elif isinstance(output, TextWriter):
+            def write(data: bytes | bytearray) -> int:
+                return output.write(data.decode("utf-8"))
+        else:
+            raise TypeError("output must be ByteWriter or TextWriter")
+
+        first = True
+        wire_type = wire_type_for(target, jso)
+
+        write(b"[")
+
+        for item in iter(it):
+            if not first:
+                write(b",")
+
+            wire_obj = msgspec.convert(item, wire_type, from_attributes=True)
+            write(_JSON_ENCODER.encode(wire_obj))
+            first = False
+
+        write(b']')
+
+

flpit-0.2.1.dev3/src/flpit/json.py

@@ -1,427 +0,0 @@
-from typing import Annotated
-import dataclasses
-import re
-import sys
-import types
-import typing
-
-import threading
-from dataclasses import MISSING, dataclass
-from functools import lru_cache
-from typing import Any, ForwardRef, get_args, get_origin, get_type_hints
-from hashlib import blake2s
-
-import msgspec
-
-from enum import StrEnum
-
-class JsonNamingPolicy(StrEnum):
-    lower_case = "lower"
-    upper_case = "upper"
-    camel_case = "camel"
-    pascal_case = "pascal"
-    kebap_case = "kebab"
-
-
-@dataclass(slots=True, frozen=True)
-class JsonSerializerOptions:
-    naming_policy: JsonNamingPolicy = JsonNamingPolicy.camel_case
-    write_indented: bool = False
-    native:bool=False
-    """
-    | Set to true for the native speed of msgspec
-    
-    !! only set to true if you know what you are doing !!
-    You'll receive the msgspec.msgstruct object that will try to do it's best to behave like your dataclass.
-    But remember !! "It's NOT your dataclass" !!
-    """
-
-    @property
-    def fingerprint(self) -> str:
-        """
-        Identifies a unique jso instance for building a struct
-        !! All parts of a jso that don't influence the defstruct MUST be ignored!
-        """
-        settings = self.naming_policy.value
-        return blake2s(settings.encode(), digest_size=6).hexdigest()
-
-# ---------------------------------------------------------------------------
-# Metadata Annotation Markers
-# ---------------------------------------------------------------------------
-
-class JsonIgnore:
-    def __class_getitem__[T](cls, item: type[T]) -> Any:
-        return Annotated[item, cls]
-
-class JsonInclude:
-    def __class_getitem__[T](cls, item: type[T]) -> Any:
-        return Annotated[item, cls]
-
-class JsonProperty:
-    def __class_getitem__[T](cls, item: tuple[type[T], str]) -> Any:
-        target_type, json_name = item
-        return Annotated[target_type, cls(json_name)]
-
-    def __init__(self, name: str):
-        self.name = name
-
-JIgnore = JsonIgnore
-JInclude = JsonInclude
-JProp = JsonProperty
-
-# ---------------------------------------------------------------------
-# Generated type metadata
-# ---------------------------------------------------------------------
-
-@dataclass(slots=True, eq=False)
-class _WireType:
-    source: type
-    """The source type to build a msgspec.struct for"""
-    hints: dict[str, Any]
-    namespace: types.ModuleType
-    """the name space we are targeting"""
-    struct: type | None = None
-
-    @property
-    def module_name(self: _WireType) -> str:
-        return self.namespace.__name__
-
-    @property
-    def class_name(self: _WireType) -> str:
-        return self.source.__name__
-
-    @property
-    def ref_name(self: _WireType) -> str:
-        identity = (
-            f"{self.source.__module__}_{self.source.__qualname__}"
-        )
-        return "_ref_" + re.sub(r"\W", "_", identity)
-
-
-# ---------------------------------------------------------------------
-# Module and annotation utilities
-# ---------------------------------------------------------------------
-
-def _generated_module(source: type) -> types.ModuleType:
-    """Generates the required module definition for our runtime only dynamic msgspec.struct"""
-    name = f"flpit.json._generated.{source.__module__}"
-
-    module = sys.modules.get(name)
-    if module is None:
-        module = types.ModuleType(name)
-        sys.modules[name] = module
-
-    return module
-
-
-def _is_dataclass_type(tp: Any) -> bool:
-    return isinstance(tp, type) and dataclasses.is_dataclass(tp)
-
-
-def _nested_dataclasses(tp: Any):
-    """Yield dataclass types referenced by an annotation."""
-    if _is_dataclass_type(tp):
-        yield tp
-        return
-
-    if isinstance(tp, (list, tuple)):
-        for item in tp:
-            yield from _nested_dataclasses(item)
-        return
-
-    origin = get_origin(tp)
-
-    if origin is typing.Annotated:
-        yield from _nested_dataclasses(get_args(tp)[0])
-        return
-
-    if origin is typing.Literal:
-        return
-
-    for arg in get_args(tp):
-        yield from _nested_dataclasses(arg)
-
-
-def _rewrite_type(
-        tp: Any,
-        owner: _WireType,
-        graph: dict[type, _WireType],
-        *,
-        resolve: bool = False,
-) -> Any:
-    """Replace source dataclasses with generated Structs or ForwardRefs."""
-    if tp is getattr(typing, "Self", None):
-        info = owner
-        return info.struct if resolve else ForwardRef(info.ref_name)
-
-    if _is_dataclass_type(tp):
-        info = graph[tp]
-        return info.struct if resolve else ForwardRef(info.ref_name)
-
-    if isinstance(tp, list):
-        return [
-            _rewrite_type(item, owner, graph, resolve=resolve)
-            for item in tp
-        ]
-
-    if isinstance(tp, tuple):
-        return tuple(
-            _rewrite_type(item, owner, graph, resolve=resolve)
-            for item in tp
-        )
-
-    origin = get_origin(tp)
-
-    if origin is None or origin is typing.Literal:
-        return tp
-
-    args = get_args(tp)
-
-    if origin is typing.Annotated:
-        base = _rewrite_type(
-            args[0], owner, graph, resolve=resolve
-        )
-        return typing.Annotated[(base, *args[1:])]
-
-    rewritten: tuple[Any, ...] = tuple(
-        _rewrite_type(arg, owner, graph, resolve=resolve)
-        for arg in args
-    )
-
-    if origin in (typing.Union, types.UnionType):
-        union: Any = typing.Union # with all the magic here, there's no way to make typing really happy
-        return union[rewritten]
-
-    params = rewritten[0] if len(rewritten) == 1 else rewritten
-
-    try:
-        return origin[params]
-    except (TypeError, AttributeError) as exc:
-        copier = getattr(tp, "copy_with", None)
-        if copier is not None:
-            return copier(rewritten)
-
-        raise TypeError(
-            f"Cannot rewrite annotation {tp!r}"
-        ) from exc
-
-
-# ---------------------------------------------------------------------
-# Graph discovery
-# ---------------------------------------------------------------------
-
-def _discover_graph(
-        roots: tuple[type, ...],
-) -> dict[type, _WireType]:
-    """Discover reachable dataclasses and resolve their annotations."""
-    graph: dict[type, _WireType] = {}
-    pending = list(roots)
-
-    while pending:
-        source = pending.pop()
-
-        if source in graph:
-            continue
-
-        info = _WireType(
-            source=source,
-            hints=get_type_hints(source, include_extras=True),
-            namespace=_generated_module(source),
-        )
-        graph[source] = info
-
-        for field in dataclasses.fields(source):
-            if not field.init:
-                continue
-
-            pending.extend(
-                _nested_dataclasses(info.hints[field.name])
-            )
-
-    return graph
-
-def _allows_none(tp: Any) -> bool:
-    if get_origin(tp) is typing.Annotated:
-        tp = get_args(tp)[0]
-
-    return type(None) in get_args(tp)
-
-# ---------------------------------------------------------------------
-# Struct construction
-# ---------------------------------------------------------------------
-
-def _struct_fields(
-        info: _WireType,
-        graph: dict[type, _WireType],
-) -> list[tuple[Any, ...]]:
-    definitions: list[tuple[Any, ...]] = []
-
-    for field in dataclasses.fields(info.source):
-        if not field.init:
-            continue
-
-        annotation = _rewrite_type(
-            info.hints[field.name],
-            info,
-            graph,
-        )
-
-        if field.default is not MISSING:
-            spec = (field.name, annotation, field.default)
-
-        elif field.default_factory is not MISSING:
-            spec = (
-                field.name,
-                annotation,
-                msgspec.field(
-                    default_factory=field.default_factory
-                ),
-            )
-
-        # for now... no enforcing of explicit null in json
-        elif _allows_none(info.hints[field.name]):
-            spec = (field.name, annotation, None)
-
-        else:
-            spec = (field.name, annotation)
-
-        definitions.append(spec)
-
-    return definitions
-
-
-def _register_forward_refs(
-        graph: dict[type, _WireType],
-) -> None:
-    """Expose every graph reference in each participating module."""
-    namespaces = []
-
-    for info in graph.values():
-        if not any(info.namespace is ns for ns in namespaces):
-            namespaces.append(info.namespace)
-
-    for namespace in namespaces:
-        for info in graph.values():
-            setattr(namespace, info.ref_name, info.struct)
-
-def _behavior_namespace(source: type) -> dict[str, Any]:
-    return {
-        name: value
-        for name, value in vars(source).items()
-        if (
-                not name.startswith("__")
-                and callable(value)
-        )
-    # pyrefly: ignore [implicit-any-lambda]
-    } | {  "__class__": property(lambda self, cls=source: cls) }
-
-def _build_graph(
-        roots: tuple[type, ...],
-        jso: JsonSerializerOptions,
-) -> dict[type, _WireType]:
-    graph = _discover_graph(roots)
-
-    for wt in graph.values():
-        wt.struct = msgspec.defstruct(
-            wt.class_name,
-            _struct_fields(wt, graph),
-            module=wt.module_name,
-            namespace=_behavior_namespace(wt.source),
-            rename=jso.naming_policy.value,
-            kw_only=True,
-            omit_defaults=True, # don't render nulls
-            forbid_unknown_fields=False, # ensure ignoring unknow fields!
-        )
-
-    _register_forward_refs(graph)
-
-    for wt in graph.values():
-        msgspec.inspect.type_info(wt.struct)
-
-    # Publish the readable generated class names.
-    for wt in graph.values():
-        setattr(wt.namespace, wt.class_name, wt.struct)
-
-    return graph
-
-
-# ---------------------------------------------------------------------
-# Cache and public API
-# ---------------------------------------------------------------------
-
-# we must only build new when the
-_jso_registry: dict[str, JsonSerializerOptions] = {}
-_registry_lock = threading.Lock()
-
-@lru_cache(maxsize=None)
-def _wrapped_lru(roots: tuple[type, ...], jso_id: str):
-    with _registry_lock:
-        jso = _jso_registry[jso_id]
-    return _build_graph(roots, jso)
-
-def _cached_graph(roots:tuple[object, ...], jso: JsonSerializerOptions):
-    with _registry_lock:
-        _jso_registry[jso.fingerprint] = jso
-
-    return _wrapped_lru(roots, jso.fingerprint)
-
-def wire_type_for(
-        target_type: type,
-        jso: JsonSerializerOptions,
-):
-    roots = tuple(_nested_dataclasses(target_type))
-
-    if not roots:
-        raise TypeError(
-            "Only @dataclass are supported!, "
-            f"got {target_type!r}"
-        )
-
-    # Normalize the root set so User and list[User] share the graph.
-    graph_roots = tuple(sorted(set(roots), key=id))
-
-    graph = _cached_graph(
-        graph_roots,
-        jso,
-    )
-
-    return _rewrite_type(
-        target_type,
-        graph[roots[0]],
-        graph,
-        resolve=True,
-    )
-
-
-def decode_dataclass(
-        data: bytes | str,
-        target: type,
-        jso: JsonSerializerOptions|None=None
-):
-    if jso is None:
-        jso = JsonSerializerOptions()
-
-    wire_type = wire_type_for(target, jso)
-    parsed = msgspec.json.decode(data, type=wire_type)
-
-    if jso.native:
-        return parsed
-
-    return msgspec.convert(
-        parsed,
-        target,
-        from_attributes=True,
-    )
-
-def encode_dataclass[T](
-        data: Any,
-        target: type[T],
-        jso: JsonSerializerOptions|None=None
-) -> bytes:
-    if jso is None:
-        jso = JsonSerializerOptions()
-
-    wire_type = wire_type_for(target, jso)
-    wire_obj = msgspec.convert(data, wire_type, from_attributes=True)
-    return msgspec.json.encode(wire_obj)
-