flpit 0.2.1.dev3__py3-none-any.whl → 0.2.1.dev4__py3-none-any.whl

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/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/json.py

@@ -1,33 +1,46 @@
-from typing import Annotated
+from collections.abc import Iterable
 import dataclasses
 import re
 import sys
+import threading
 import types
 import typing
-
-import threading
 from dataclasses import MISSING, dataclass
+from enum import StrEnum
 from functools import lru_cache
-from typing import Any, ForwardRef, get_args, get_origin, get_type_hints
 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 enum import StrEnum
+from flpit.io import ByteWriter, TextWriter
+
 
 class JsonNamingPolicy(StrEnum):
-    lower_case = "lower"
-    upper_case = "upper"
-    camel_case = "camel"
-    pascal_case = "pascal"
-    kebap_case = "kebab"
+    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_case
-    write_indented: bool = False
-    native:bool=False
+    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
     
@@ -42,8 +55,11 @@ class JsonSerializerOptions:
         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()
+        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
@@ -99,9 +115,46 @@ class _WireType:
 
 
 # ---------------------------------------------------------------------
-# Module and annotation utilities
+# 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__}"
@@ -118,6 +171,47 @@ 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):
@@ -210,6 +304,7 @@ def _rewrite_type(
 # Graph discovery
 # ---------------------------------------------------------------------
 
+
 def _discover_graph(
         roots: tuple[type, ...],
 ) -> dict[type, _WireType]:
@@ -231,15 +326,17 @@ def _discover_graph(
         graph[source] = info
 
         for field in dataclasses.fields(source):
-            if not field.init:
+            annotation, ignored, included, _ = _field_directives(
+                info.hints[field.name]
+            )
+            if ignored:
                 continue
 
-            pending.extend(
-                _nested_dataclasses(info.hints[field.name])
-            )
+            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]
@@ -250,43 +347,81 @@ def _allows_none(tp: Any) -> bool:
 # 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):
-        if not field.init:
+        source_annotation = info.hints[field.name]
+        annotation, ignored, included, json_name = _field_directives(source_annotation)
+
+        if ignored:
             continue
 
-        annotation = _rewrite_type(
-            info.hints[field.name],
-            info,
-            graph,
-        )
+        # 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
 
-        if field.default is not MISSING:
-            spec = (field.name, annotation, field.default)
+        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:
-            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)
-
+            default_val = msgspec.field(default_factory=field.default_factory)
+            has_default = True
+        elif _allows_none(annotation):
+            default_val = None
+            has_default = True
         else:
-            spec = (field.name, annotation)
+            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
 
 
@@ -304,44 +439,59 @@ def _register_forward_refs(
         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)
+                and (callable(value) or isinstance(value, property))
         )
-    # pyrefly: ignore [implicit-any-lambda]
+        # 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)
 
+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,
-            _struct_fields(wt, graph),
+            fields,
             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!
+            rename=None,
+            kw_only=False,
+            omit_defaults=jso.default_handling.value == JsonDefaultHandling.exclude,
+            forbid_unknown_fields=jso.unknown_field_handling.value == JsonUnknownFieldHandling.disallow,
         )
 
-    _register_forward_refs(graph)
 
+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
 
 
@@ -353,22 +503,17 @@ def _build_graph(
 _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 _build_graph(roots, jso)
 
-    return _wrapped_lru(roots, jso.fingerprint)
 
-def wire_type_for(
-        target_type: type,
-        jso: JsonSerializerOptions,
-):
+@lru_cache(maxsize=None)
+def _cached_wire_type(target_type: object, jso_id: str):
     roots = tuple(_nested_dataclasses(target_type))
 
     if not roots:
@@ -377,13 +522,8 @@ def wire_type_for(
             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,
-    )
+    graph = _wrapped_lru(graph_roots, jso_id)
 
     return _rewrite_type(
         target_type,
@@ -393,35 +533,100 @@ def wire_type_for(
     )
 
 
-def decode_dataclass(
-        data: bytes | str,
-        target: type,
-        jso: JsonSerializerOptions|None=None
-):
-    if jso is None:
-        jso = JsonSerializerOptions()
+def wire_type_for(target_type: type, jso: JsonSerializerOptions) -> type:
+    jso_id = jso.fingerprint
 
-    wire_type = wire_type_for(target, jso)
-    parsed = msgspec.json.decode(data, type=wire_type)
+    with _registry_lock:
+        _jso_registry[jso_id] = jso
 
-    if jso.native:
-        return parsed
+    return _cached_wire_type(target_type, jso_id)
 
-    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)
+@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.dist-info → flpit-0.2.1.dev4.dist-info}/METADATA

@@ -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.dev4.dist-info/RECORD

@@ -0,0 +1,12 @@
+flp/__init__.py,sha256=reAHhZtYt0f2LHeIYJbklta6Vatr6yeQCL1R-9TTyY0,688
+flpit/__init__.py,sha256=tx4tkpLxoKQTP7wu2PyUtQtLs9_pWHbx1jHh4Vdsrus,1275
+flpit/flp.py,sha256=i-FbnMeO92cxNRssYsgdlm2UGjILpveXgYUT468fWvY,999
+flpit/io.py,sha256=ATXt0H7DpKt9aC7-td5FhR601alVDsAPZ1tFJ9tVYvM,5259
+flpit/json.py,sha256=Ujlk8jo6kCIaVwhYRwDV17PQ6rmCVa8G9IjPz_Tvfsw,19115
+flpit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flpit/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flpit/core/linq.py,sha256=h2KKK9wP77cGFKsqDtCRlulSlhKj40DCVZj4D9tpK2s,41049
+flpit-0.2.1.dev4.dist-info/METADATA,sha256=1O1rnsiWRbdz8f1bJbgKMrgCyDK9wlbsNmwz-IF9epk,13047
+flpit-0.2.1.dev4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+flpit-0.2.1.dev4.dist-info/licenses/LICENSE,sha256=bi5Vg_YP3Oq3jaOMQT4b7WZu0NfBcZr-nRyOExUKJrQ,1063
+flpit-0.2.1.dev4.dist-info/RECORD,,

flpit-0.2.1.dev3.dist-info/RECORD

@@ -1,11 +0,0 @@
-flp/__init__.py,sha256=reAHhZtYt0f2LHeIYJbklta6Vatr6yeQCL1R-9TTyY0,688
-flpit/__init__.py,sha256=tx4tkpLxoKQTP7wu2PyUtQtLs9_pWHbx1jHh4Vdsrus,1275
-flpit/flp.py,sha256=i-FbnMeO92cxNRssYsgdlm2UGjILpveXgYUT468fWvY,999
-flpit/json.py,sha256=KHACbdvunJyyuVt18AZjC_L-CGh0aptkem0wiJtJx0s,11687
-flpit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flpit/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flpit/core/linq.py,sha256=ekihrga5XEhWUyG5pIRl3LJBrhr3V0cv498jFfyZhKg,40136
-flpit-0.2.1.dev3.dist-info/METADATA,sha256=KqNxb2w0XNQsTcNVNVyGCX4nqnWHhCtH6-RvRFn5XXg,13041
-flpit-0.2.1.dev3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-flpit-0.2.1.dev3.dist-info/licenses/LICENSE,sha256=bi5Vg_YP3Oq3jaOMQT4b7WZu0NfBcZr-nRyOExUKJrQ,1063
-flpit-0.2.1.dev3.dist-info/RECORD,,