python-corekit 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

corekit/utils/coercion.py

@@ -6,17 +6,36 @@ empty value rather than raising. Use them at boundaries where the input is
 genuinely unknown -- an API payload, a config value, a scraped field -- and a
 crash would be worse than a default.
 
+These are thin wrappers around ``corekit.utils.parsers``. Extraction logic lives
+there once; here we only fix the fallback to the type's empty value so the
+return type is guaranteed.
+
 The tradeoff is real: ``safe_int("banana")`` is ``0``, indistinguishable from a
-genuine zero. Where telling those apart matters, parse explicitly instead.
+genuine zero. Where telling those apart matters, call the parser directly and
+inspect ``ParsedValue.success``, or pass a sentinel ``default``.
 """
 
-import json
-from datetime import date, datetime
 from typing import Any
 
-from corekit.utils.text import list_to_english
-
-__all__ = ["safe_dict", "safe_float", "safe_int", "safe_list", "safe_string", "safe_tuple"]
+from corekit.utils.parsers import (
+    parse_dict,
+    parse_float,
+    parse_int,
+    parse_list,
+    parse_set,
+    parse_string,
+    parse_tuple,
+)
+
+__all__ = [
+    "safe_dict",
+    "safe_float",
+    "safe_int",
+    "safe_list",
+    "safe_set",
+    "safe_string",
+    "safe_tuple",
+]
 
 
 def safe_string(item: Any, pretty: bool = False) -> str:
@@ -27,54 +46,21 @@ def safe_string(item: Any, pretty: bool = False) -> str:
     list instead -- ``"a, b, c"``, or ``"key: value, ..."`` for a mapping --
     which reads better in a notification than raw JSON.
     """
-    if isinstance(item, bytes):
-        item = item.decode("utf-8", errors="ignore")
-    if isinstance(item, str):
-        return item.strip()
-    # bool is a subclass of int, so both land here and render as "True"/"1".
-    if isinstance(item, (int, float)):
-        return str(item)
-    if isinstance(item, (list, tuple, set, dict)):
-        if pretty:
-            if isinstance(item, dict):
-                return list_to_english([f"{key}: {value}" for key, value in item.items()])
-            return list_to_english([safe_string(element) for element in item])
-        return json.dumps(item)
-    if isinstance(item, (date, datetime)):
-        return item.isoformat()
-    return ""
+    return parse_string(item, pretty=pretty, default="").value
 
 
 def safe_int(item: Any) -> int:
     """
     Convert anything to an int, or ``0`` if it will not convert.
     """
-    if isinstance(item, int):
-        return item
-    if isinstance(item, bytes):
-        item = item.decode("utf-8", errors="ignore")
-    if isinstance(item, (float, str)):
-        try:
-            return int(item)
-        except ValueError:
-            return 0
-    return 0
+    return parse_int(item, default=0).value
 
 
 def safe_float(item: Any) -> float:
     """
     Convert anything to a float, or ``0.0`` if it will not convert.
     """
-    if isinstance(item, float):
-        return item
-    if isinstance(item, bytes):
-        item = item.decode("utf-8", errors="ignore")
-    if isinstance(item, (int, str)):
-        try:
-            return float(item)
-        except ValueError:
-            return 0.0
-    return 0.0
+    return parse_float(item, default=0.0).value
 
 
 def safe_list(item: Any) -> list[Any]:
@@ -84,13 +70,7 @@ def safe_list(item: Any) -> list[Any]:
     A mapping yields its values. A string is *not* treated as a collection --
     exploding it into characters is almost never what the caller meant.
     """
-    if isinstance(item, list):
-        return item
-    if isinstance(item, (tuple, set)):
-        return list(item)
-    if isinstance(item, dict):
-        return list(item.values())
-    return []
+    return parse_list(item, default=[]).value
 
 
 def safe_tuple(item: Any) -> tuple[Any, ...]:
@@ -100,19 +80,25 @@ def safe_tuple(item: Any) -> tuple[Any, ...]:
     A mapping yields its values. A string is *not* treated as a collection --
     exploding it into characters is almost never what the caller meant.
     """
-    if isinstance(item, tuple):
-        return item
-    if isinstance(item, (list, set)):
-        return tuple(item)
-    if isinstance(item, dict):
-        return tuple(item.values())
-    return ()
+    return parse_tuple(item, default=()).value
+
+
+def safe_set(item: Any) -> set[Any]:
+    """
+    Convert a collection to a set, or ``set()`` for anything else.
+
+    A mapping yields its values. A string is *not* treated as a collection --
+    exploding it into characters is almost never what the caller meant.
+    Unhashable elements yield ``set()``.
+    """
+    return parse_set(item, default=set()).value
 
 
 def safe_dict(item: Any) -> dict[str, Any]:
     """
     Return the mapping unchanged, or ``{}`` for anything else.
+
+    Also accepts objects that expose ``to_dict``, ``model_dump``, or ``dict``,
+    and falls back to ``__dict__`` when present.
     """
-    if isinstance(item, dict):
-        return item
-    return {}
+    return parse_dict(item, default={}).value

corekit/utils/collections.py

@@ -7,10 +7,29 @@ once. Built for JSON from somewhere you do not control, where any level may be
 missing or the wrong type.
 """
 
-from copy import deepcopy
-from typing import Any, Callable
+from __future__ import annotations
 
-__all__ = ["MultiMatch", "attr_or_key", "keygetter", "repeated_get", "split_list"]
+import inspect
+from collections.abc import AsyncIterable, AsyncIterator, Iterable, Mapping
+from copy import deepcopy
+from typing import Any, Awaitable, Callable, Iterator, Literal
+
+__all__ = [
+    "MultiMatch",
+    "aiterator",
+    "attr_or_key",
+    "iterator",
+    "keygetter",
+    "kv_string",
+    "repeated_get",
+    "split_list",
+]
+
+WhereSeq = Callable[[Any], bool]
+WhereMap = Callable[[Any, Any], bool]
+AsyncWhereSeq = Callable[[Any], bool | Awaitable[bool]]
+AsyncWhereMap = Callable[[Any, Any], bool | Awaitable[bool]]
+IteratorMode = Literal["keys", "values", "items"]
 
 KEY_SEPARATOR = "."
 
@@ -40,6 +59,120 @@ def attr_or_key(obj: Any, name: str) -> Any:
     return getattr(obj, name, None)
 
 
+def _mapping_item(key: Any, value: Any, mode: IteratorMode) -> Any:
+    if mode == "values":
+        return value
+    if mode == "items":
+        return key, value
+    return key
+
+
+def iterator(
+    obj: Iterable[Any] | Mapping[Any, Any] | None = None,
+    *,
+    mode: IteratorMode = "keys",
+    where: WhereSeq | WhereMap | None = None,
+    compact: bool = False,
+) -> Iterator[Any]:
+    """
+    Iterate an iterable or mapping, optionally filtered.
+
+    Non-mappings ignore ``mode`` and yield elements. Mappings yield keys,
+    values, or items according to ``mode`` (default ``keys``).
+
+    ``compact=True`` skips ``None`` items, or mapping entries whose **value**
+    is ``None``. ``where`` is a sync predicate: one argument for iterables,
+    ``(key, value)`` for mappings — the entry is filtered, then ``mode``
+    selects what is yielded.
+
+    ``None`` yields nothing.
+    """
+    if obj is None:
+        return
+
+    if isinstance(obj, Mapping):
+        for key, value in obj.items():
+            if compact and value is None:
+                continue
+            if where is not None and not where(key, value):  # type: ignore[call-arg, arg-type]
+                continue
+            yield _mapping_item(key, value, mode)
+        return
+
+    for item in obj:
+        if compact and item is None:
+            continue
+        if where is not None and not where(item):  # type: ignore[call-arg, arg-type]
+            continue
+        yield item
+
+
+async def aiterator(
+    obj: AsyncIterable[Any] | Iterable[Any] | Mapping[Any, Any] | None = None,
+    *,
+    mode: IteratorMode = "keys",
+    where: AsyncWhereSeq | AsyncWhereMap | None = None,
+    compact: bool = False,
+) -> AsyncIterator[Any]:
+    """
+    Async counterpart to ``iterator``.
+
+    Accepts async iterables, sync iterables, and mappings. ``where`` may be
+    sync or async; mapping predicates still receive ``(key, value)``. Use with
+    ``async for``.
+    """
+    if obj is None:
+        return
+
+    async def _allow_mapping(_key: Any, _value: Any) -> bool:
+        if where is None:
+            return True
+        result = where(_key, _value)  # type: ignore[call-arg, arg-type]
+        if inspect.isawaitable(result):
+            result = await result
+        return bool(result)
+
+    async def _allow_item(_item: Any) -> bool:
+        if where is None:
+            return True
+        result = where(_item)  # type: ignore[call-arg, arg-type]
+        if inspect.isawaitable(result):
+            result = await result
+        return bool(result)
+
+    if isinstance(obj, Mapping):
+        for key, value in obj.items():
+            if compact and value is None:
+                continue
+            if not await _allow_mapping(key, value):
+                continue
+            yield _mapping_item(key, value, mode)
+        return
+
+    if isinstance(obj, AsyncIterable):
+        async for item in obj:
+            if compact and item is None:
+                continue
+            if not await _allow_item(item):
+                continue
+            yield item
+        return
+
+    for item in obj:
+        if compact and item is None:
+            continue
+        if not await _allow_item(item):
+            continue
+        yield item
+
+
+def kv_string(key: str, value: Any, sep: str = ": ", prefix: str = "") -> str:
+    """
+    Format a key-value pair into a string.
+    """
+    return f"{prefix}{key}{sep}{value}"
+
+
 class MultiMatch(dict[str, Any]):
     """
     The result of a path step that matched more than one key.

corekit/utils/parsers.py

@@ -0,0 +1,205 @@
+"""
+Flexible parsers with caller-controlled fallbacks.
+
+Each helper attempts to extract the target type and returns a ``ParsedValue``
+carrying both the result and a ``success`` flag. On failure the ``value`` is
+whatever ``default`` the caller supplied (``None`` unless overridden).
+
+These are the extraction layer. For a guaranteed target type with that type's
+empty value as the fallback, use the ``safe_*`` wrappers in
+``corekit.utils.coercion``.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date, datetime
+from typing import Any, NamedTuple
+
+from corekit.utils.text import list_to_english
+
+__all__ = [
+    "ParsedValue",
+    "parse_dict",
+    "parse_float",
+    "parse_int",
+    "parse_list",
+    "parse_set",
+    "parse_string",
+    "parse_tuple",
+]
+
+
+class ParsedValue(NamedTuple):
+    """Outcome of a parse attempt."""
+
+    value: Any
+    success: bool
+
+    @classmethod
+    def ok(cls, value: Any) -> ParsedValue:
+        return cls(value=value, success=True)
+
+    @classmethod
+    def error(cls, value: Any) -> ParsedValue:
+        return cls(value=value, success=False)
+
+
+def parse_string(
+    item: Any,
+    *,
+    pretty: bool = False,
+    strip: bool = True,
+    default: Any = None,
+) -> ParsedValue:
+    """
+    Extract a string rendering of ``item``, or ``default`` if there is none.
+
+    Collections become JSON by default. With ``pretty`` they become an English
+    list instead -- ``"a, b, c"``, or ``"key: value, ..."`` for a mapping --
+    which reads better in a notification than raw JSON.
+    """
+
+    def _clean(text: str) -> str:
+        return text.strip() if strip else text
+
+    def _parse_collection(collection: Any) -> str:
+        if pretty:
+            if isinstance(collection, dict):
+                return list_to_english([f"{key}: {value}" for key, value in collection.items()])
+            return list_to_english(
+                [parse_string(element, pretty=pretty, strip=strip, default="").value for element in collection]
+            )
+        return json.dumps(collection)
+
+    if isinstance(item, bytes):
+        item = item.decode("utf-8", errors="ignore")
+    if isinstance(item, str):
+        return ParsedValue.ok(_clean(item))
+    # bool is a subclass of int, so both land here and render as "True"/"1".
+    if isinstance(item, (int, float)):
+        return ParsedValue.ok(str(item))
+    if isinstance(item, (list, tuple, set, dict)):
+        return ParsedValue.ok(_parse_collection(item))
+    if isinstance(item, (date, datetime)):
+        return ParsedValue.ok(item.isoformat())
+    return ParsedValue.error(default)
+
+
+def parse_int(item: Any, *, default: Any = None) -> ParsedValue:
+    """
+    Extract an int from ``item``, or ``default`` if it will not convert.
+    """
+    if isinstance(item, bool):
+        return ParsedValue.ok(int(item))
+    if isinstance(item, int):
+        return ParsedValue.ok(item)
+    if isinstance(item, bytes):
+        item = item.decode("utf-8", errors="ignore")
+    if isinstance(item, (float, str)):
+        try:
+            return ParsedValue.ok(int(item))
+        except (TypeError, ValueError):
+            return ParsedValue.error(default)
+    return ParsedValue.error(default)
+
+
+def parse_float(item: Any, *, default: Any = None) -> ParsedValue:
+    """
+    Extract a float from ``item``, or ``default`` if it will not convert.
+    """
+    if isinstance(item, bool):
+        return ParsedValue.ok(float(item))
+    if isinstance(item, float):
+        return ParsedValue.ok(item)
+    if isinstance(item, bytes):
+        item = item.decode("utf-8", errors="ignore")
+    if isinstance(item, (int, str)):
+        try:
+            return ParsedValue.ok(float(item))
+        except (TypeError, ValueError):
+            return ParsedValue.error(default)
+    return ParsedValue.error(default)
+
+
+def parse_list(item: Any, *, default: Any = None) -> ParsedValue:
+    """
+    Extract a list from a collection, or ``default`` for anything else.
+
+    A mapping yields its values. A string is *not* treated as a collection --
+    exploding it into characters is almost never what the caller meant.
+    """
+    if isinstance(item, list):
+        return ParsedValue.ok(item)
+    if isinstance(item, (tuple, set)):
+        return ParsedValue.ok(list(item))
+    if isinstance(item, dict):
+        return ParsedValue.ok(list(item.values()))
+    return ParsedValue.error(default)
+
+
+def parse_tuple(item: Any, *, default: Any = None) -> ParsedValue:
+    """
+    Extract a tuple from a collection, or ``default`` for anything else.
+
+    A mapping yields its values. A string is *not* treated as a collection --
+    exploding it into characters is almost never what the caller meant.
+    """
+    if isinstance(item, tuple):
+        return ParsedValue.ok(item)
+    if isinstance(item, (list, set)):
+        return ParsedValue.ok(tuple(item))
+    if isinstance(item, dict):
+        return ParsedValue.ok(tuple(item.values()))
+    return ParsedValue.error(default)
+
+
+def parse_set(item: Any, *, default: Any = None) -> ParsedValue:
+    """
+    Extract a set from a collection, or ``default`` for anything else.
+
+    A mapping yields its values. A string is *not* treated as a collection --
+    exploding it into characters is almost never what the caller meant.
+    Unhashable elements fail the conversion and yield ``default``.
+    """
+    if isinstance(item, set):
+        return ParsedValue.ok(item)
+    if isinstance(item, (list, tuple)):
+        try:
+            return ParsedValue.ok(set(item))
+        except TypeError:
+            return ParsedValue.error(default)
+    if isinstance(item, dict):
+        try:
+            return ParsedValue.ok(set(item.values()))
+        except TypeError:
+            return ParsedValue.error(default)
+    return ParsedValue.error(default)
+
+
+def parse_dict(item: Any, *, default: Any = None) -> ParsedValue:
+    """
+    Extract a mapping from ``item``, or ``default`` if none is available.
+
+    Accepts a ``dict`` directly, then common dump protocols (``to_dict``,
+    ``model_dump``, ``dict``), then a plain ``__dict__``.
+    """
+    if isinstance(item, dict):
+        return ParsedValue.ok(item)
+
+    for method_name in ("to_dict", "model_dump", "dict"):
+        method = getattr(item, method_name, None)
+        if not callable(method):
+            continue
+        try:
+            result = method()
+        except Exception:
+            continue
+        if isinstance(result, dict):
+            return ParsedValue.ok(result)
+
+    namespace = getattr(item, "__dict__", None)
+    if isinstance(namespace, dict):
+        return ParsedValue.ok(namespace)
+
+    return ParsedValue.error(default)

{python_corekit-0.4.1.dist-info → python_corekit-0.5.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: python-corekit
-Version: 0.4.1
-Summary: Shared foundations for Python projects: logging, benchmarking, registries, FastAPI application and routers, SQL statements and migrations, background tasks, ETL, and LLM chat/tool primitives
+Version: 0.5.0
+Summary: Shared foundations for Python projects: logging, benchmarking, registries, FastAPI application and routers, SQL statements and migrations, background tasks, ETL, LLM chat/tool primitives, and HTML scraping
 Author: Steven Jacobsen
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/stevejaker/corekit
@@ -23,6 +23,7 @@ Requires-Dist: sqlmodel<0.1,>=0.0.16
 Requires-Dist: SQLAlchemy<3,>=2.0
 Requires-Dist: redis<7,>=5.0
 Requires-Dist: httpx<1,>=0.27
+Requires-Dist: selectolax<1,>=0.3
 Requires-Dist: docker<8,>=7.0
 Requires-Dist: PyYAML<7,>=6.0
 Requires-Dist: dill<0.5,>=0.3.8
@@ -347,13 +348,13 @@ class GithubClient(BaseApiClient):
         return "https://api.github.com"
 
 response = GithubClient().get("/users/octocat")
-response.data["login"]
+response.data.login
 ```
 
-Retries 429 and 5xx with exponential backoff. Every response is a
-`BaseApiResponse`, so a non-JSON error page leaves `data` empty rather than
-raising. The same methods are awaitable inside a running event loop:
-`await client.get(...)`.
+Retries 429 and 5xx with exponential backoff. ``BaseHttpClient`` returns a
+``BaseHttpResponse`` (text + metadata); ``BaseApiClient`` adds structured
+``data`` from JSON (``None`` when the body is not JSON). The same methods are
+awaitable inside a running event loop: `await client.get(...)`.
 
 ## Serialization
 

{python_corekit-0.4.1.dist-info → python_corekit-0.5.0.dist-info}/RECORD

@@ -22,7 +22,7 @@ corekit/connections/registry.py,sha256=BR04dGthcGCtON2MxNsl-TlhRgbRlvGj0RLymDFBk
 corekit/connections/redis/__init__.py,sha256=BsWLZNqpKAqIoreHGLEtftnMqVw-ESK8jbexDAughag,174
 corekit/connections/redis/connection.py,sha256=H6r5WsDfXFgIQlp6vq3rKjp-oBFQoE5h_YaJXZEvHIs,9850
 corekit/connections/sql/__init__.py,sha256=WRBcQ9draDQSooYi4k4peWyuRTgSyEk_WwOYYOAN9K4,882
-corekit/connections/sql/connection.py,sha256=PvLhYXMmq6JneshWhoUb2WD2usGH7uOA9H_ZufybKgQ,12318
+corekit/connections/sql/connection.py,sha256=1ieLXssO2lyFZD9Uf_5wyM5TJmdEqYl8RzR2fMTJTlg,12410
 corekit/connections/sql/query.py,sha256=8s5atIssmN2l9FCL2IHnIQqwxOk0fA_mPNh36koLhoE,233
 corekit/connections/sql/table.py,sha256=C7_QCRPd7C1JeH7aIByUBVWsx5qiEOFavWOo6c72djM,3125
 corekit/connections/sql/fields/__init__.py,sha256=2I-TCsvi321yQhesKNZgY1T77FtATZ6o7pw0MNHtbAo,184
@@ -94,12 +94,19 @@ corekit/files/base.py,sha256=Ca2bhdlwntHh425PedaUG-UW2fEFZsPCss_3f7REsAE,4022
 corekit/files/enum.py,sha256=mcrQXcp-AizTAp4VoaVMLj9zu5D81XXMsnZwZqe6fz0,597
 corekit/files/json.py,sha256=pRYLKNjeVmkDQsgtjBboFFY5Ljx1Pwa3MFEeQBc4o-g,909
 corekit/files/toml.py,sha256=YFRwghMapbCRSl7srqcI7IhqaTQDyO56XRasGMu_Aug,1273
-corekit/http/__init__.py,sha256=pDSzU3w8ZHMdcnZ1XCR_KWEGRSlIhy-K_jT5qH_T2Y4,1681
-corekit/http/api.py,sha256=L4iZ9TdCQH3klKWxIxFE3bEQzqMTDOwy-HKrvHXwsbI,784
-corekit/http/client.py,sha256=IEXZGd-4-zaQmkKXOIlTyLrFKWaJd6uDxu14o5-u9z4,7997
+corekit/html/__init__.py,sha256=25xsrlhaWREDuGpWc6xnN-Mbir7AsCnzjjQODJ58XVo,535
+corekit/html/client.py,sha256=59eTlvJh9QFiPQ7HFHEhju9UkoEpS5YafinxFI5w7Q0,664
+corekit/html/models.py,sha256=zxN3mSAuTQ0GE27Gxa3ptcp_EAmm5tlBUzwMovDevLU,357
+corekit/html/parser.py,sha256=blSEBl5clbx_dOBPKu0S45_MiRjLSa7LeGpGc8opdWA,10300
+corekit/html/scraper.py,sha256=af3UHf8LZuE4tEYr_MHo-h9FF6b8PQUtoTmlzSFR3FE,4366
+corekit/html/settings.py,sha256=Xalz1Zg9wHyPhlzfIwsFE23aOE6woShHJLNEHg4mCWE,6951
+corekit/html/state.py,sha256=McWmvu7y4qR0M2mSnjPAFtnAow9sv-nWHzolJQlvbyk,1534
+corekit/http/__init__.py,sha256=S3FlvpBjYoLrFaMY7OTQLMM6d7etaDRJP53_4aPuKZk,1723
+corekit/http/api.py,sha256=WiBfv3tTifxUuvoj3rGqZxCPm2L8z3N_F7hvmLuzprM,3027
+corekit/http/client.py,sha256=CONO9z5CGVh5H99yCYnNjPMUYe8G8FFzbeBhusLbBSw,7217
 corekit/http/exceptions.py,sha256=etkKN6rgnhENctO7YNvaRAKsctK0PXKCxAe15l6mNwY,4252
 corekit/http/exponential_backoff.py,sha256=5jjGTspX_BC9aBKPr5Y5dNhJqXesmljsjJoQ6i2d4_I,3180
-corekit/http/response.py,sha256=rOcUEgPYxfmKXfGO5fQsMA8q4YJof8dNNGBf-nb7l8k,2375
+corekit/http/response.py,sha256=t_nGIwA-uyuQlJBGMgxbodCNjRnqc1xUcxMsbEXeMBM,3415
 corekit/http/status.py,sha256=rZ-cdliG9EAvWMTzvxjqjipRkZRc6RgSzcBY4Kewdg0,2377
 corekit/http/stream.py,sha256=lkERyCXz5amOWzoE-b12iftf3l_G-ghwSvN1lL5lUio,3257
 corekit/jobs/__init__.py,sha256=vsv8o23ApT6MlOwOq-AFYeQW2NT1kjyvu89A5CL2PsY,880
@@ -107,13 +114,13 @@ corekit/jobs/registry.py,sha256=cco6884eVuIYHEtSv6P62MICFjX-QhuSZIFkEJcQi_M,2557
 corekit/jobs/runner.py,sha256=VyiTrQJT-E8-XuNBh8s1QgLJkKhkpBq_398Fs_03Kow,3321
 corekit/jobs/task.py,sha256=tqr-QaQSHyfPjbyZscM5i-YgT-fl58cpd2FVxevtG_E,6112
 corekit/llm/__init__.py,sha256=Qa-5V2cG4aH98b0nLY2tMx0G7uhoWhcaaZ7JY1dJjcA,3217
-corekit/llm/client.py,sha256=bO2o21ntKdGNjcWOoEv4ew2QQD7-HQ6Hsn01Zf_5a1I,6441
+corekit/llm/client.py,sha256=X-dkizlps-ndhDzcImBfLDDWaoPdwMin7bf58QU2fdQ,6519
 corekit/llm/enum.py,sha256=WyikZcEt17Rnj5jFS6o2ENXIdBBFB-NFjdCKDVtIToc,2582
 corekit/llm/events.py,sha256=gEj3HpXLndCoPLF3C5jn-Gv5N1K6EPosR7bc5DaHwz4,2202
 corekit/llm/messages.py,sha256=KomU69Kjfgif0fMXrbEr9VsQ_RpcFjgsE2S0ThC2SIA,5070
 corekit/llm/protocols.py,sha256=ahCZwR3vQiB6LqaarTBGc5VSbe5mtb9vDLoLcOTmL_k,1770
 corekit/llm/streaming.py,sha256=fiQdJMHDrMBSF5hDMCqcQ3WulrOyoQ67N-c3Chb00Sg,4319
-corekit/llm/wire.py,sha256=3OTD0Cj3ewbBqCqdrqAs06gXQrxmNPI7LYsvBnO9zws,6024
+corekit/llm/wire.py,sha256=GbK7nF27YryNIDe1uOG_3RR-er3BFvULhVy73DiGgE0,6308
 corekit/llm/prompts/__init__.py,sha256=9z8UwMqkh11MNcrom8hNZjugXq1MVF_EpPkRfF72zNA,544
 corekit/llm/prompts/enum.py,sha256=OYTd-riG70HiGoBVxJpA1_FttyGR-ITsEojHfHjDKdk,1219
 corekit/llm/prompts/exceptions.py,sha256=BX7VvngByXfSf3UGKAnFAPOytJrYukdEN_gVKYIfypc,546
@@ -122,7 +129,7 @@ corekit/llm/prompts/template.py,sha256=dgKje-v4R3JN3SPsDBjGm4zdohEsGRTgpbv1bvaOT
 corekit/llm/tools/__init__.py,sha256=3hoiam1oatawk9k8-pcY63JoywiOh3EoM7TvkW00nMY,527
 corekit/llm/tools/base.py,sha256=Mby2M3WA4nKgkmOpQwJWvKHGXlaZU62EGlHQUxsL_wk,3309
 corekit/llm/tools/detection.py,sha256=R3jMxJwOdMzyTo9DISi_yYx1zEHUJJ6AN61bHkvO3zM,3292
-corekit/llm/tools/loop.py,sha256=kpzNMmFEDV-QwY-ja6WHyGKfKyl9v4Ih7RovFoajofU,9200
+corekit/llm/tools/loop.py,sha256=x7zlfYgeiXbtgna3IIczKkh5PK9fY2SfUpBOle21Dtw,9381
 corekit/llm/tools/registry.py,sha256=dkIucONGsmaw-cgTNIIV2WDVGAF45twOHrvTvavs4X4,3362
 corekit/log_monitor/__init__.py,sha256=uuXTQdI8EMeFbdt69G-2K8dKh5Nt-h9SzBEsOGcu0lo,371
 corekit/log_monitor/constants.py,sha256=8nzIzU3Qit9h7_stZLWW1Q_0DTnYglw_j5bQUsF586g,230
@@ -142,13 +149,13 @@ corekit/observability/timing/timer.py,sha256=rBGYYnBq-1E85Om37dkbPM9wKsXsltyeWeA
 corekit/registry/__init__.py,sha256=R67Jssr06Eyx2u5AbX1omm2LziWvwS_Sd7fExnNv9CM,681
 corekit/registry/ordered.py,sha256=_KS4mWzmLgFvODW2M0_ugxZIBW_dKhwwxrVrtNqLMfs,2506
 corekit/registry/registry.py,sha256=t1iwzxgvd-iyLIf_5wahg_P7eN9V1oumpupkAqi2GdQ,5601
-corekit/schemas/__init__.py,sha256=Qty0EM2XlbvUgnk-JU2IRaE6_Kclocw6QqKyaD-CbZg,369
+corekit/schemas/__init__.py,sha256=4EK7QNWP16U6ZKno_ZKTDfgSflc9W2PFMPskc0kvSdw,470
 corekit/schemas/enum.py,sha256=gLc44kIXRfpDFkV51JoN4KT1CU92hnb529rd1b88fBM,2033
 corekit/schemas/types.py,sha256=AWIxZHXUiUjJRZjmOhAdCq3RIsRzL-Fy7RvYy4i5Ozo,1347
 corekit/schemas/version.py,sha256=InWtfKf0iyfu_eBLaFm_QNwkSjpgKc1jGJZeWYjQQUc,1753
 corekit/schemas/dataclasses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 corekit/schemas/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-corekit/schemas/models/arbitrary.py,sha256=L2Uqxo_twPAmzoly3Lyo5rzYhDzReSB_U-oAuRgWubg,396
+corekit/schemas/models/arbitrary.py,sha256=ik8V9Pm2X3eKv1vUp3IF5v3c6gDqoyisSBnen63-Pcc,1681
 corekit/schemas/models/date_models.py,sha256=UOlSLVsWqgr_jnHfxVRgSl4nVVdfbe6zPBYveOgRcIg,399
 corekit/schemas/pydantic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 corekit/schemas/pydantic/fields.py,sha256=ScP2ZQCR2qTWaqwjKl7lGvkTGSIeQBJ0yeNs79E47AA,1175
@@ -157,18 +164,19 @@ corekit/serialization/enum.py,sha256=pzHuAIXeonEF7-jyN1uYddJk-xvmQGuymDf1U6RWR5w
 corekit/serialization/pickle_file.py,sha256=dudKIxR8ueT3wx_IBxHJeoqnFeP1rT7dlTb_PXlSkd8,2251
 corekit/serialization/serializable.py,sha256=viF3ZCKRJ90hk6m4lbqIfo6ifsY2c4sXr4xZrn1Yz-Q,1999
 corekit/serialization/serializer.py,sha256=XlGE1Rq8M55Jl2a4F5MkvDcba2VI7lrh0v9kwL0DWG8,6617
-corekit/utils/__init__.py,sha256=xOHqpsAipQbkCLurKOYBSQ8RJyHULfoeEKPXqudNWH4,1827
-corekit/utils/coercion.py,sha256=Aq63jrxQYg1ooWUFXHff2uepB_LoHm1izao8_3xkzEU,3650
-corekit/utils/collections.py,sha256=cn7Bzh67utzBi7UO4FfjWrjDun05ye5_rTscwfWcmwo,4475
+corekit/utils/__init__.py,sha256=lNdmVmQBUFckkCIjzxYLHpLe06rudXS9t_evVEv-le4,2419
+corekit/utils/coercion.py,sha256=lnAdPuY7Hha81of1I8oPIu6C8ow6JqWWpuF1sPX17Ek,3084
+corekit/utils/collections.py,sha256=4ieN3r44Y1DPoJQYpoXn8mL_nTKd5i9GjAoBOMXwd40,8335
 corekit/utils/ids.py,sha256=BVniaYqewM-EosDxcJAT_S_7T9C1c5X8nsaVGs5up34,1731
+corekit/utils/parsers.py,sha256=b7bCaMd7_VKaFnin6vn3v1Eol_Z0vvr3vjDO4ro5ycI,6628
 corekit/utils/payload.py,sha256=T7EgdVU0S5h8MAzvQsmkfRPMatWqUbxjHL9hmZdM9ho,3882
 corekit/utils/raise_exc.py,sha256=cz7ljc6ZW90AGQussKuANN8PLsDLUhl-E8FZ0Ipsw-0,175
 corekit/utils/text.py,sha256=0322DdZGuDGEagTyejuda6QT1jbbxNIO6loC-_AGml0,2311
 corekit/utils/time.py,sha256=-iPaETXcgDu7J39Kwe938JyZKhPVjl6a572BBqsqcDQ,2215
 corekit/utils/validators.py,sha256=_HVKo3y264KGNaZ-1RyM1x46VPvu7XKcQkrHWDC9uxs,340
 corekit/utils/void.py,sha256=eXDb2QynuguiSgHGJLdgE08MuRnxBdYebRdMD7s1m9o,178
-python_corekit-0.4.1.dist-info/licenses/LICENSE,sha256=357LYxbxAQZ95q5cV-8JK6j-KNgiE6AteRodjEsm-kE,1072
-python_corekit-0.4.1.dist-info/METADATA,sha256=M24uRb1as-03LHKgbGhDIFJeQ30Z3mEO84EfCj_GNIE,15084
-python_corekit-0.4.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_corekit-0.4.1.dist-info/top_level.txt,sha256=SDK4o8BoaI47E9tPbiNCbbWoc2y6N_wCjwnIEfr-GWI,8
-python_corekit-0.4.1.dist-info/RECORD,,
+python_corekit-0.5.0.dist-info/licenses/LICENSE,sha256=357LYxbxAQZ95q5cV-8JK6j-KNgiE6AteRodjEsm-kE,1072
+python_corekit-0.5.0.dist-info/METADATA,sha256=GFJChQrVckK79FiPnCddTLGr36xpxik6BqrtAjskE_A,15185
+python_corekit-0.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_corekit-0.5.0.dist-info/top_level.txt,sha256=SDK4o8BoaI47E9tPbiNCbbWoc2y6N_wCjwnIEfr-GWI,8
+python_corekit-0.5.0.dist-info/RECORD,,