flpit 0.2.0.dev2__py3-none-any.whl → 0.2.1.dev3__py3-none-any.whl

flpit/__init__.py

@@ -5,33 +5,59 @@ from __future__ import annotations
 from importlib.metadata import version
 __version__ = version("flpit")
 
-import builtins
-from typing import Iterable as _Iterable, TypeVar
-
 from flpit import flp
 from flpit.core.linq import (
     FlpIt,
     FlpList,
     Grouping,
     OrderedIt,
+
+    #====================
+    # InvalidOperationException
+    #====================
+    InvalidOperationError,
     EmptySequenceError,
     NoMatchError,
     MultipleElementsError,
     MultipleMatchesError,
+
+    #====================
+    # ArgumentExceptions
+    #====================
+    ArgumentError,
+    ArgumentNullError,
     SourceNoneError,
     PredicateNoneError,
+    CollectionNoneError,
+    SelectorNoneError,
+    SecondNoneError,
+    ArgumentOutOfRangeError,
+    ArgumentNonNegError,
+    ArgumentOutOfBoundsError
 )
 
 __all__ = [
+    "flp",
     "FlpIt",
     "FlpList",
     "Grouping",
     "OrderedIt",
+
+    "InvalidOperationError",
     "EmptySequenceError",
     "NoMatchError",
     "MultipleElementsError",
     "MultipleMatchesError",
+
+    "ArgumentError",
+    "ArgumentNullError",
     "SourceNoneError",
     "PredicateNoneError",
+    "CollectionNoneError",
+    "SelectorNoneError",
+    "SecondNoneError",
+    "ArgumentOutOfRangeError",
+    "ArgumentNonNegError",
+    "ArgumentOutOfBoundsError",
 ]
 

flpit/core/linq.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-from typing import SupportsIndex
 import decimal
 from decimal import Decimal, Overflow, Inexact
 
@@ -15,15 +13,21 @@ from typing import (
     Iterable,
     Iterator,
     Collection,
+    SupportsIndex,
     List,
     Set,
     Type,
     TypeVar,
+    ClassVar,
     Union,
     override,
     overload,
     cast as typing_cast,
+    GenericAlias
 )
+
+from flpit.json import JsonSerializerOptions, decode_dataclass, encode_dataclass
+
 TItem = TypeVar("TItem")
 TResult = TypeVar("TResult")
 TKey = TypeVar("TKey")
@@ -39,38 +43,70 @@ class _Sentinel:
 _SENTINEL = _Sentinel()
 _MISSING = object()
 
+# =============================================================================
+# Invalid Operation Errors
+# =============================================================================
+class InvalidOperationError(ValueError):
+    pass
 
-class EmptySequenceError(ValueError):
+class EmptySequenceError(InvalidOperationError):
     def __init__(self):
         super().__init__("Sequence contains no elements")
 
-class NoMatchError(ValueError):
+class NoMatchError(InvalidOperationError):
     def __init__(self):
         super().__init__("Sequence contains no matching elements")
 
-class MultipleMatchesError(ValueError):
+class MultipleMatchesError(InvalidOperationError):
     def __init__(self):
         super().__init__("Sequence contains more than one matching element")
 
-class MultipleElementsError(ValueError):
+class MultipleElementsError(InvalidOperationError):
     def __init__(self):
         super().__init__("Sequence contains more than one element")
 
-class SourceNoneError(TypeError):
+
+# =============================================================================
+# Argument Errors
+# =============================================================================
+class ArgumentError(TypeError):
+    pass
+
+class ArgumentNullError(ArgumentError):
+    def __init__(self, argument: str):
+        super().__init__(f"Value cannot be None. (Argument '{argument}')")
+
+class SourceNoneError(ArgumentNullError):
     def __init__(self):
-        super().__init__("Value cannot be None. (Argument 'source')")
+        super().__init__("source")
 
-class PredicateNoneError(TypeError):
+class PredicateNoneError(ArgumentNullError):
     def __init__(self):
-        super().__init__("Value cannot be None. (Argument 'predicate')")
+        super().__init__("predicate")
 
-class CollectionNoneError(TypeError):
+class CollectionNoneError(ArgumentNullError):
     def __init__(self):
-        super().__init__("Value cannot be None. (Argument 'collection')")
+        super().__init__("collection")
+
+class SelectorNoneError(ArgumentNullError):
+    def __init__(self):
+        super().__init__("keySelector")
+
+class SecondNoneError(ArgumentNullError):
+    def __init__(self):
+        super().__init__("second")
+
+class ArgumentOutOfRangeError(ArgumentError):
+    def __init__(self, argument: str, pattern:str="Index was out of range. Must be non-negative and less than the size of the collection."):
+        super().__init__(f"{pattern} (Parameter '{argument}')")
+
+class ArgumentNonNegError(ArgumentOutOfRangeError):
+    def __init__(self, argument:str):
+        super().__init__(argument, "Non-negative number required.")
 
-class SelectorNoneError(TypeError):
+class ArgumentOutOfBoundsError(ArgumentError):
     def __init__(self):
-        super().__init__("Value cannot be None. (Parameter 'keySelector')")
+        super().__init__("Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.")
 
 
 def _guard_empty(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -191,6 +227,9 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
         return builtins.all(map(predicate, self))
 
     def concat(self, second: Iterable[TItem]) -> "FlpIt[TItem]":
+        if second is None:
+            raise SecondNoneError()
+
         def _generator() -> Iterator[TItem]:
             yield from self
             yield from second
@@ -211,8 +250,8 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
             for item in self:
                 if predicate(item):
                     yield item
-
-        return typing_cast(FlpIt[TItem], FlpIt(_FactoryIterable(_generator)))
+        # return typing_cast(FlpIt[TItem], FlpIt[TItem](_FactoryIterable(_generator)))
+        return FlpIt[TItem](_FactoryIterable(_generator))
 
     def select(self, selector: Callable[[TItem], TResult]) -> FlpIt[TResult]:
         """Projects each element into a new form."""
@@ -232,6 +271,18 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
 
         return FlpIt(_FactoryIterable(_generator))
 
+    def skip(self, count: int) -> "FlpIt[TItem]":
+        """
+        |Bypasses a specified number of elements from the start.
+        """
+        if count <= 0:
+            return self
+
+        def _generator() -> Iterator[TItem]:
+            yield from islice(iter(self), count, None)
+
+        return FlpIt(_FactoryIterable(_generator))
+
     def take(self, count: int) -> "FlpIt[TItem]":
         """
         |Returns a specified number of contiguous elements from the start.
@@ -528,11 +579,13 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
     def element_at(self, index: int) -> TItem:
         """Returns the element at a specified index in a sequence."""
         if index < 0:
-            raise IndexError("Index out of range")
+            raise ArgumentOutOfRangeError("index")
+
         for i, item in enumerate(self):
             if i == index:
                 return item
-        raise IndexError("Index out of range")
+
+        raise ArgumentOutOfRangeError("index")
 
     def first(self, predicate: Callable[[TItem], bool] | _Sentinel = _SENTINEL) -> TItem:
         """Returns the first element matching a predicate, or raises ValueError."""
@@ -568,10 +621,10 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
 
         raise MultipleMatchesError() if has_predicate else MultipleElementsError()
 
-
     def to_list(self) -> FlpList[TItem]:
         """Explicitly materializes the query into a FlpList."""
-        return FlpList(self)
+        return FlpList[TItem](self)
+
 
 from functools import partial
 
@@ -682,6 +735,8 @@ class FlpList(Collection[TItem], Generic[TItem]):
     | Fluent List
     A materialized list extending UserList that yields lazy FlpIt instances for query operations.
     """
+    __type_args__: ClassVar[tuple[Any, ...]]
+
     def __init__(self, source: Iterable[TItem] | _Sentinel=_SENTINEL):
         if source is None:
             raise SourceNoneError()
@@ -830,7 +885,7 @@ class FlpList(Collection[TItem], Generic[TItem]):
 
     def insert(self, index: int, item: TItem) -> None:
         if index < 0 or index > len(self.__list.data):
-            raise IndexError(f"Index {index} is out of range.")
+            raise ArgumentOutOfRangeError("index")
 
         self.__list.data.insert(index, item)
 
@@ -839,7 +894,7 @@ class FlpList(Collection[TItem], Generic[TItem]):
             raise CollectionNoneError()
 
         if index < 0 or index > len(self.__list.data):
-            raise IndexError(f"Index {index} is out of range.")
+            raise ArgumentOutOfRangeError("index")
 
         self.__list.data[index:index] = list(collection)
 
@@ -865,22 +920,22 @@ class FlpList(Collection[TItem], Generic[TItem]):
         return original_length - len(self.__list.data)
 
     def remove_at(self, index: int) -> None:
-        if index < 0 or index > len(self.__list.data):
-            raise IndexError(f"Index {index} is out of range.")
+        if index < 0 or index >= len(self.__list.data):
+            raise ArgumentOutOfRangeError("index")
 
         del self.__list.data[index]
 
     def remove_range(self, index: int, count: int) -> None:
         size = len(self.__list.data)
 
-        if index < 0 or index > size:
-            raise IndexError("index")
+        if index < 0:
+            raise ArgumentNonNegError("index")
 
         if count < 0:
-            raise IndexError("count")
+            raise ArgumentNonNegError("count")
 
         if count > size - index:
-            raise IndexError("The range is invalid.")
+            raise ArgumentOutOfBoundsError()
 
         del self.__list.data[index : index + count]
 
@@ -899,17 +954,13 @@ class FlpList(Collection[TItem], Generic[TItem]):
 
         # Apply your List<T>-compatible argument validation here.
         if index < 0 or index > size:
-            raise IndexError("Non-negative number required.")
+            raise ArgumentNonNegError("index")
 
         if count < 0:
-            raise IndexError("Non-negative number required.")
+            raise ArgumentNonNegError("count")
 
         if index + count > size:
-            raise IndexError(
-                "Offset and length were out of bounds for the array or "
-                "count is greater than the number of elements from index "
-                "to the end of the source collection."
-            )
+            raise ArgumentOutOfBoundsError()
 
         self.__list.data[index:index + count] = reversed(
             self.__list.data[index:index + count]
@@ -948,12 +999,15 @@ class FlpList(Collection[TItem], Generic[TItem]):
         """Prepends an element to the sequence lazily, returning a FlpIt without mutating this list."""
         return FlpIt(self.__list.data).prepend(element)
 
+    def concat(self, second: Iterable[TItem]) -> FlpIt[TItem]:
+        return FlpIt(self.__list.data).concat(second)
+
     # noinspection unused-parameter
     def as_type(self, target_type: Type[TResult]) -> FlpList[TResult]:
         return self  # type: ignore[return-value]
 
     def where(self, predicate: Callable[[TItem], bool]) -> FlpIt[TItem]:
-        return FlpIt(self.__list.data).where(predicate)
+        return FlpIt[TItem](self.__list.data).where(predicate)
 
     def select(self, selector: Callable[[TItem], TResult]) -> FlpIt[TResult]:
         return FlpIt(self.__list.data).select(selector)
@@ -963,6 +1017,9 @@ class FlpList(Collection[TItem], Generic[TItem]):
     ) -> FlpIt[TResult]:
         return FlpIt(self.__list.data).select_many(selector)
 
+    def skip(self, count: int) -> FlpIt[TItem]:
+        return FlpIt(self.__list.data).skip(count)
+
     def take(self, count: int) -> FlpIt[TItem]:
         return FlpIt(self.__list.data).take(count)
 
@@ -1076,7 +1133,7 @@ class FlpList(Collection[TItem], Generic[TItem]):
 
     def element_at(self, index: int) -> TItem:
         if index < 0 or index >= len(self.__list.data):
-            raise IndexError("Index out of range")
+            raise ArgumentOutOfRangeError("index")
         return self.__list.data[index]
 
     def first(self, predicate: Callable[[TItem], bool] | _Sentinel = _SENTINEL) -> TItem:
@@ -1128,3 +1185,19 @@ class FlpList(Collection[TItem], Generic[TItem]):
     def to_list(self) -> FlpList[TItem]:
         """Explicitly returns a shallow copy instance to isolate mutations."""
         return FlpList(self.__list.data.copy())
+
+    # =====================================================================
+    # 5. json serialization
+    # =====================================================================
+
+    @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))
+
+    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)
+
+    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")
+
+

flpit/json.py

@@ -0,0 +1,427 @@
+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)
+

{flpit-0.2.0.dev2.dist-info → flpit-0.2.1.dev3.dist-info}/METADATA

@@ -1,7 +1,8 @@
 Metadata-Version: 2.5
 Name: flpit
-Version: 0.2.0.dev2
+Version: 0.2.1.dev3
 Summary: Fluent LINQ for Python — flip your iterables
+Project-URL: Homepage, https://github.com/riemar/flpit
 License: MIT
 License-File: LICENSE
 Keywords: fluent,generators,iterable,lazy-evaluation,linq,pipeline,pyrefly,type-safe
@@ -15,7 +16,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+Requires-Python: >=3.12
+Requires-Dist: msgspec>=0.22.0
 Description-Content-Type: text/markdown
 
 # FlpIt
@@ -369,16 +371,18 @@ Distributed under the MIT License. See `LICENSE` for more information.
 | ├── test_all.py                                |          80 |
 | ├── test_any.py                                |          90 |
 | ├── test_average.py                            |         572 |
+| ├── test_concat.py                             |          64 |
 | ├── test_count.py                              |          37 |
 | ├── test_generic_list.py                       |          95 |
 | ├── test_last.py                               |          29 |
 | ├── test_order_by.py                           |         100 |
 | ├── test_order_descending_by.py                |          45 |
+| ├── test_skip.py                               |          75 |
 | ├── test_sum.py                                |         134 |
 | ├── test_take.py                               |          39 |
 | ├── test_then_by.py                            |          40 |
 | └── test_then_descending_by.py                 |          34 |
 ----------------------------------------------------------------
-| GRAND TOTALS                                   |        1295 |
+| GRAND TOTALS                                   |        1434 |
 ================================================================
 ```

flpit-0.2.1.dev3.dist-info/RECORD

@@ -0,0 +1,11 @@
+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,,

flpit-0.2.0.dev2.dist-info/RECORD

@@ -1,10 +0,0 @@
-flp/__init__.py,sha256=reAHhZtYt0f2LHeIYJbklta6Vatr6yeQCL1R-9TTyY0,688
-flpit/__init__.py,sha256=T8tdJmfJiYiBuUszbACGan0U1meuBQa7IQpfIncADLA,705
-flpit/flp.py,sha256=i-FbnMeO92cxNRssYsgdlm2UGjILpveXgYUT468fWvY,999
-flpit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flpit/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flpit/core/linq.py,sha256=S4rbqA4UTIze_NOeSKLJMm1gWcWWS_voHdHhEVmlZ8U,37560
-flpit-0.2.0.dev2.dist-info/METADATA,sha256=IgRIlar-JXbxGK2Dt1Jcj8Sbf_GZNmp6X3yl9JjLJaU,12813
-flpit-0.2.0.dev2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-flpit-0.2.0.dev2.dist-info/licenses/LICENSE,sha256=bi5Vg_YP3Oq3jaOMQT4b7WZu0NfBcZr-nRyOExUKJrQ,1063
-flpit-0.2.0.dev2.dist-info/RECORD,,