httk-core 2.0.0__py3-none-any.whl

httk/core/datastream/textstream_request_view.py

@@ -0,0 +1,44 @@
+import urllib.request
+from typing import Any, Self
+
+from ..views import unwrap
+from .textstream_backend import TextstreamBackend
+from .textstream_like import TextstreamLike
+from .textstream_view import TextstreamView
+
+
+class TextstreamRequestView(TextstreamView, urllib.request.Request):
+    """
+    A view presenting an underlying data streaming backend via a urllib.request.Request.
+    This view is mostly useful for providing a Request to functions that will open it.
+    Note: this view is not lazy (it does not fetch); it only mirrors the underlying request/URL.
+
+    Raises TypeError if created with a streaming data source that does not come with a URL.
+    """
+
+    _backend: TextstreamBackend
+
+    def __new__(cls, obj: TextstreamLike, **hints: Any) -> Self:
+        if isinstance(obj, cls):
+            return obj
+        backend = cls._prepare_backend(obj, hints)
+        request = getattr(backend, "request", None)
+        if request is not None:
+            full_url, data, headers = request.full_url, request.data, request.headers
+        else:
+            url = getattr(backend, "url", None)
+            if url is None:
+                raise TypeError("This backend cannot be represented as a Request (no underlying URL)")
+            full_url, data, headers = url, None, {}
+        instance = super().__new__(cls)
+        # Request is mutable, so its state is initialized here in __new__ (keeping __init__ a no-op),
+        # so that rewrapping an existing view via cls(view) does not re-initialize it.
+        urllib.request.Request.__init__(instance, full_url, data=data, headers=headers)
+        instance._backend = backend
+        return instance
+
+    def __init__(self, obj: TextstreamLike, **hints: Any) -> None:
+        pass
+
+    def unwrap(self) -> Any:
+        return unwrap(self._backend)

httk/core/datastream/textstream_string.py

@@ -0,0 +1,47 @@
+import io
+from typing import Any
+
+from .compression import reject_text_native_compression
+from .textstream_backend import TextstreamBackend
+from .textstream_common import TextstreamCommon
+
+
+class TextstreamString(TextstreamCommon, TextstreamBackend):
+    """
+    Backend for streaming text backed by an actual string
+    """
+
+    s: str
+    _f: io.TextIOBase | None
+    _underlying: io.IOBase | None
+    _closed: bool
+
+    # Cannot type annotate __new__ as `Self | None` for some reason
+    def __new__(cls, content: str, **hints: Any) -> Any:
+        if not isinstance(content, str):
+            return None
+        if hints and hints.get("kind", "content") != "content":
+            return None
+        return super().__new__(cls)
+
+    def __init__(self, content: str, **hints: Any) -> None:
+        reject_text_native_compression(hints.get("compression"))
+        self.s = content
+        self._f = None
+        self._underlying = None
+        self._closed = False
+
+    def _ensure_f(self) -> io.TextIOBase:
+        if self._closed:
+            raise ValueError("I/O operation on closed stream")
+        if self._f is None:
+            self._f = io.StringIO(self.s)
+        return self._f
+
+    @property
+    def name(self) -> str | None:
+        return None
+
+    @property
+    def closed(self) -> bool:
+        return self._closed

httk/core/datastream/textstream_string_view.py

@@ -0,0 +1,31 @@
+from typing import Any, Self
+
+from ..views import unwrap
+from .textstream_backend import TextstreamBackend
+from .textstream_like import TextstreamLike
+from .textstream_view import TextstreamView
+
+
+class TextstreamStringView(TextstreamView, str):
+    """
+    A view presenting an underlying data streaming as a string.
+    This view can be used both to pass a string in place of streaming data, and for reading streaming data into a string.
+    Note: this view is not lazy (this is impossible for views inherting str, since str is immutable), hence all the streaming data
+    is read immedately upon creating this view.
+    """
+
+    _backend: TextstreamBackend
+
+    def __new__(cls, obj: TextstreamLike, **hints: Any) -> Self:
+        if isinstance(obj, cls):
+            return obj
+        backend = cls._prepare_backend(obj, hints)
+        instance = super().__new__(cls, backend.read())
+        instance._backend = backend
+        return instance
+
+    def __init__(self, obj: TextstreamLike, **hints: Any) -> None:
+        super().__init__()
+
+    def unwrap(self) -> Any:
+        return unwrap(self._backend)

httk/core/datastream/textstream_url.py

@@ -0,0 +1,77 @@
+import io
+import urllib.parse
+import urllib.request
+from typing import Any, cast
+
+from .compression import open_compressed, validate_compression
+from .textstream_backend import TextstreamBackend
+from .textstream_common import TextstreamCommon
+
+_URL_SCHEMES = ("http", "https", "ftp", "file")
+
+
+class TextstreamURL(TextstreamCommon, TextstreamBackend):
+    """
+    Backend for streaming text fetched from a URL string.
+    A bare string is interpreted as a URL when its scheme is one of http, https, ftp, or file,
+    or when an explicit kind="url" hint is given.
+    """
+
+    _url: str
+    _timeout: float | None
+    _encoding: str | None
+    _compression: str
+    _f: io.TextIOBase | None
+    _underlying: io.IOBase | None
+    _closed: bool
+
+    # mypy does not allow to type annotate __new__ as `Self | None` for some reason
+    def __new__(cls, url: str, **hints: Any) -> Any:
+        if not isinstance(url, str):
+            return None
+        kind = hints.get("kind")
+        if kind == "url":
+            if not urllib.parse.urlsplit(url).scheme:
+                return None
+            return super().__new__(cls)
+        if kind is None and urllib.parse.urlsplit(url).scheme in _URL_SCHEMES:
+            return super().__new__(cls)
+        return None
+
+    def __init__(self, url: str, **hints: Any) -> None:
+        self._url = url
+        self._timeout = hints.get("timeout")
+        self._encoding = hints.get("encoding")
+        self._compression = hints.get("compression", "auto")
+        validate_compression(self._compression)
+        self._f = None
+        self._underlying = None
+        self._closed = False
+
+    def _ensure_f(self) -> io.TextIOBase:
+        if self._closed:
+            raise ValueError("I/O operation on closed stream")
+        if self._f is None:
+            if self._timeout is None:
+                resp = urllib.request.urlopen(self._url)
+            else:
+                resp = urllib.request.urlopen(self._url, timeout=self._timeout)
+            encoding = self._encoding or resp.headers.get_content_charset() or "utf-8"
+            raw = cast(io.IOBase, resp)
+            name = urllib.parse.urlsplit(self._url).path
+            decompressed = open_compressed(raw, compression=self._compression, name=name)
+            self._underlying = raw if decompressed is not raw else None
+            self._f = io.TextIOWrapper(cast(io.BufferedReader, decompressed), encoding=encoding)
+        return self._f
+
+    @property
+    def name(self) -> str | None:
+        return None
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def closed(self) -> bool:
+        return self._closed

httk/core/datastream/textstream_url_view.py

@@ -0,0 +1,35 @@
+from typing import Any, Self
+
+from ..views import unwrap
+from .textstream_backend import TextstreamBackend
+from .textstream_like import TextstreamLike
+from .textstream_view import TextstreamView
+
+
+class TextstreamURLView(TextstreamView, str):
+    """
+    A view presenting an underlying data streaming backend via a URL string.
+    This view is mostly useful for providing a URL to functions that will open it.
+    Note: this view is not lazy (this is impossible for views inheriting str, since str is immutable).
+
+    Raises TypeError if created with a streaming data source that does not come with a URL.
+    """
+
+    _backend: TextstreamBackend
+
+    def __new__(cls, obj: TextstreamLike, **hints: Any) -> Self:
+        if isinstance(obj, cls):
+            return obj
+        backend = cls._prepare_backend(obj, hints)
+        url = getattr(backend, "url", None)
+        if url is None:
+            raise TypeError("This backend cannot be represented as a URL (no underlying URL)")
+        instance = super().__new__(cls, url)
+        instance._backend = backend
+        return instance
+
+    def __init__(self, obj: TextstreamLike, **hints: Any) -> None:
+        super().__init__()
+
+    def unwrap(self) -> Any:
+        return unwrap(self._backend)

httk/core/datastream/textstream_view.py

@@ -0,0 +1,16 @@
+from typing import ClassVar, Self
+
+from ..views import View
+from .textstream_backend import TextstreamBackend
+
+
+class TextstreamView(View[TextstreamBackend]):
+    """
+    Abstract base class for all views of streaming text data.
+    """
+
+    _backend_base_cls: ClassVar[type[TextstreamBackend]] = TextstreamBackend  # type: ignore[type-abstract]
+    _view_base_cls: ClassVar[type[Self]]
+
+
+TextstreamView._view_base_cls = TextstreamView

httk/core/loading.py

@@ -0,0 +1,29 @@
+#
+#    The high-throughput toolkit (httk)
+#    Copyright (C) 2012-2024 the httk AUTHORS
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from pathlib import Path
+from typing import Any
+
+from .register import loaders
+
+
+def load(filename: str, **kwargs: Any) -> Any:
+    ext = Path(filename).suffix.lower()
+    if ext:
+        return loaders.dispatch(ext, filename, **kwargs)
+    else:
+        raise Exception("Could not determine file type.")

httk/core/register.py

@@ -0,0 +1,30 @@
+#
+#    The high-throughput toolkit (httk)
+#    Copyright (C) 2012-2024 the httk AUTHORS
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+from ._plugins import PluginRegistry
+
+loaders = PluginRegistry()
+
+
+def register_loader(*, name: str, loader: str, extensions: tuple[str, ...]) -> None:
+    for ext in extensions:
+        loaders.register(key=ext.lower(), handler=loader, name=name)
+
+
+def known_extensions() -> list[str]:
+    return loaders.keys()

httk/core/views/__init__.py

@@ -0,0 +1,5 @@
+from .backend import Backend
+from .unwrapping import unwrap
+from .view import View
+
+__all__ = ["Backend", "View", "unwrap"]

httk/core/views/backend.py

@@ -0,0 +1,49 @@
+from abc import ABC
+from typing import Any, ClassVar, Self, cast
+
+
+class Backend[BackendT: Backend](ABC):
+    """
+    Abstract base class to be subclassed into classes that keep track of alternative
+    representations of certain types of data, all adhering to a common API interface.
+
+    The class variable backend_classes is a list of all classes that can carry the kind of data the subclass represents.
+
+    A system of "hints" are used primarily to disambiguate between multiple valid interpretations of the same input object.
+    Unless otherwise documented for a specific backend, extra hints that do not affect this interpretation are ignored.
+
+    A set of backends are meant to be combined with a set of Views.
+    """
+
+    # Subclasses must implement this class variable, which only appear as a type annotation here
+    backend_classes: ClassVar[list[type["Backend[Any]"]]]
+
+    @classmethod
+    def create(cls: type[Self], obj: Any, **hints: Any) -> Self:
+        """
+        Given a source data (obj) and a set of hints, create a backend from one of the alternatives in the class variable `backend_classes`.
+
+        By design this creation depends heavily on order of the classes in `backend_classes`.
+        Each class is tried in the order they appear until one of them is successful, in the sense that their `__new__` does not return None.
+        Sometimes multiple backend classes can handle the same input type. In that case, dispatch is guided by keyword arguments `**hints`,
+        with the convention that:
+
+        * if a hint named `kind` is given, a backend class should accept the object only if it matches that `kind`;
+        * when `kind` matches, additional unrecognized hints may be ignored.
+        """
+        for t in cls.backend_classes:
+            instance = t(obj, **hints)
+            if instance is not None:
+                return cast(Self, instance)
+        raise TypeError(f"Cannot represent {type(obj)} as {cls.__name__}")
+
+    def __init__(self, backend, **hints) -> None:
+        pass
+
+    def unwrap(self) -> Any:
+        """
+        Return the most raw representation possible of this backend, i.e., if it uses a backend with an internal representaion -
+        or if it can (possibly lossly) convert itself into a more raw representation that still would be recognized as a <Something>Like type,
+        that representation will be returned. If this is not possible, the instance itself is returned.
+        """
+        return self

httk/core/views/unwrapping.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+
+def unwrap(obj: Any) -> Any:
+    """
+    Given a Backend or a View, return the most raw representation possible, i.e., if the backend has an internal representaion -
+    or if it can (possibly lossly) convert itself into a more raw representation that still would be recognized as a <Something>Like type,
+    that representation will be returned. If this is not possible, the instance itself is returned.
+    """
+    if hasattr(obj, "unwrap"):
+        return obj.unwrap()
+    return obj

httk/core/views/view.py

@@ -0,0 +1,56 @@
+from typing import Any, ClassVar
+
+from .backend import Backend
+from .unwrapping import unwrap
+
+
+class View[BackendT: Backend]:
+    """
+    A set of views allow manipulating data and state of a backend through different interfaces.
+    Hence, creating a View from a Backend, or from another View, allows to read and operate on the data through the interface of that view,
+    even if it is not the natural representation of the underlying data.
+
+    Important: views are always meant to reference the data and state of *the same* underlying object, hence, e.g.:
+
+    * If a function is given an X object, and the function applies an Xvariant1View and then calls, e.g., close() via that view,
+      the excpectation should be that the original X object is now also closed.
+    * When, e.g., a TextstreamStringView is created on an already partially read stream, only the unread data will appear through that string interface.
+
+    All backends and views of the same kind of data (X) should be combined into a type union XLike that functions use to declare they support this kind of data.
+    Such functions should start with creating a View on the passed data, giving them access to the data in a single desired format.
+    """
+
+    # Python typing, and mypy in particular, have trouble with variables being assigned abstract base classes
+    _backend_base_cls: ClassVar[Any]  # Subclass of Backend that defines a set of backends for similar data
+    _view_base_cls: ClassVar[Any]  # Subclass of view that defines a set of views of similar data
+    _backend: BackendT
+
+    @classmethod
+    def _prepare_backend(
+        cls,
+        obj: Any,
+        hints: dict[str, Any],
+    ) -> BackendT:
+        """
+        Normalize an arbitrary backend/view/raw object into a backend suitable for constructing a view.
+
+        Behavior:
+        - if `obj` is already one of the accepted views, unwrap its underlying backend to adopt it;
+        - if `obj` is a backend inheriting from the right superclass, return it unchanged.
+        - if `obj` otherwise try to create a backend from that superclass via `backend_cls.create(obj, **hints)`;
+
+        `hints` are forwarded for backend selection/disambiguation.
+        """
+        if isinstance(obj, cls._view_base_cls):
+            return obj._backend
+        if not isinstance(obj, cls._backend_base_cls):
+            return cls._backend_base_cls.create(obj, **hints)
+        return obj
+
+    def unwrap(self) -> Any:
+        """
+        Return the most raw representation possible of this view, i.e., if it uses a backend with an internal representaion -
+        or if it can (possibly lossly) convert itself into a more raw representation that still would be recognized as a <Something>Like type,
+        that representation will be returned. If this is not possible, the instance itself is returned.
+        """
+        return unwrap(self._backend)

httk_core-2.0.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: httk-core
+Version: 2.0.0
+Summary: httk₂ core functionality
+Author-email: Rickard Armiento <rickard-gpg@armiento.net>
+License-Expression: AGPL-3.0-or-later
+Project-URL: Homepage, https://httk.org
+Project-URL: Documentation, https://docs.httk.org/httk-core/
+Project-URL: Repository, https://github.com/httk/httk-core
+Project-URL: Issues, https://github.com/httk/httk-core/issues
+Keywords: Materials Discovery,Materials Informatics,Materials Science
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: myst-nb; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: sphinx-autoapi; extra == "docs"
+Provides-Extra: release
+Requires-Dist: build>=1.2; extra == "release"
+Requires-Dist: twine>=6.0; extra == "release"
+Dynamic: license-file
+
+# httk-core
+
+![Status: Pre-release](https://img.shields.io/badge/status-pre--release-red)
+
+> **⚠️ PRE-RELEASE**
+>
+> The version assigned to *httk-core* designates the overall version of *httk₂*,
+> and thus starts at v2.0.0. However, versions v2.0.* are to be considered
+> prereleases, and semantic versioning will not be used until v2.1.0.
+
+`httk-core` is the central lightweight dependency shared by httk₂ modules.
+
+It provides:
+
+- the `httk.core` package within the PEP 420 native `httk` namespace;
+- shared view/backend and data-stream primitives; and
+- plugin discovery and aggregate operations such as `httk.core.load`, to which
+  other httk modules can register handlers.
+
+Most users should install the [`httk2`](https://github.com/httk/httk2)
+metapackage, which selects a useful set of httk modules:
+
+```console
+pip install httk2
+```
+
+Install only the core package with:
+
+```console
+pip install httk-core
+```
+
+Other distributions, such as `httk-io`, install their own packages under the
+same `httk` namespace and can then be imported as `httk.io`.

httk_core-2.0.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+httk/core/__init__.py,sha256=YSARcnjJER8mFkrsQRiCHSOHDE_KATkuvn2E2mvt18I,2895
+httk/core/_discover.py,sha256=pEWZs-Kn2nQe3p5Edhek676iVZ10rGePR80fEc4D_NM,1215
+httk/core/_plugins.py,sha256=9CwgeF6G97tHyMOZkeJQZE_ZCQNZ5AIKUfkDYD9QV_M,3092
+httk/core/dataloader.py,sha256=2lFzg8i5j3ovNg-O-pMH9a41LVynqNoEDIAGYmFfF_Q,10081
+httk/core/loading.py,sha256=VUXGwSWLhtYEyF1b5XX9qgNfutDGkBPueUgm71pkX68,1081
+httk/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httk/core/register.py,sha256=c7ZHZ2guB9TmaYPRLr5rRZ3kNCZvbG0RSbTpI85vRak,1090
+httk/core/datastream/__init__.py,sha256=PpDxhJrfeTW6UliPcMTcKutmZKO_3UsWANP5yYjjX84,2738
+httk/core/datastream/bytestream_api.py,sha256=ad53pPAwZC17dfW0ldv9R6ZVl5QdEA_vqckgtr1utyI,871
+httk/core/datastream/bytestream_backend.py,sha256=etGEfI1rMGLcxkgFM92yO9p3gnXd3ZK3L3SBZEMSLKQ,314
+httk/core/datastream/bytestream_bytes.py,sha256=DiKzl0ivt5OOrtpM4q02krVqYgVmbU-74qmrUMgeVok,1646
+httk/core/datastream/bytestream_bytes_view.py,sha256=tWZuThktCHFjq_X5ZDiXUCjEjgthJ0KC9QrHHYbUNVo,1107
+httk/core/datastream/bytestream_common.py,sha256=LDIXkViHlrgzn2xQT2EeRVMhtzG9GCADv9rI7vr8Lb8,1134
+httk/core/datastream/bytestream_file.py,sha256=DKwCs0EjEGP78UVMiTH8w5hL2c0GbUxtonQI4POxWvs,1834
+httk/core/datastream/bytestream_file_view.py,sha256=bLpU_CH8fqlr2SBf-H18q09NXOMb7uIWoyvB7yFPQWA,5604
+httk/core/datastream/bytestream_filename.py,sha256=6S_6fIHWiFiW3y7FERR7qzaXEZWkU7X2iWSokYI052M,1725
+httk/core/datastream/bytestream_filename_view.py,sha256=w3OULUJvLJaHGvOP9l9v3Yen118J0IPNFaKnsYMnlrg,1245
+httk/core/datastream/bytestream_like.py,sha256=U2RFkuVF9IQx7Ax3-bypx7sEhIeqMt5rFa-uUy3gF38,322
+httk/core/datastream/bytestream_request.py,sha256=bW6BBIa3mgd7T8dYTymJ--x0rxvIIzArgrk_ZNTi4yA,2262
+httk/core/datastream/bytestream_request_view.py,sha256=69fPVjRZY1qBqf0aeoCq93OL-obzyeHr0Ll-sPLhhkc,1816
+httk/core/datastream/bytestream_url.py,sha256=ThzfvtvHz_YfL20lo6jlOB2rUGDQY0F-4y9q-CXWFZM,2410
+httk/core/datastream/bytestream_url_view.py,sha256=ZqSVX4vIYLpIjqPdMDfXySqcSGM_kj7MelcU3iMBYwY,1251
+httk/core/datastream/bytestream_view.py,sha256=g87V1HQXFRUZGUBgyk3mWCjim7jVqsfPFcRqq3AgC5k,436
+httk/core/datastream/compression.py,sha256=P6d0lyXjbWn7wYYyxhKs944dTakWzBV6ieVJgUvQeMk,6966
+httk/core/datastream/textstream_api.py,sha256=7ltSE1eiCufUea3dfPlr1FWPyczzbLB2-gWV1Aezboo,868
+httk/core/datastream/textstream_backend.py,sha256=_tfj1KfgXOUhByT4ueW9wAfuqFV4tImDPqAkzp19atY,314
+httk/core/datastream/textstream_common.py,sha256=nYupIVL_g3CdCx_Dw3W2K8NdGLlJb2UcXeaJQtqHBWU,1079
+httk/core/datastream/textstream_file.py,sha256=1ukkIWQF2YIEcgHaR2AFrL6vojQ_Mxqy3_dF5k5JsKM,1462
+httk/core/datastream/textstream_file_view.py,sha256=0qvTXYiXEwJRKIwExK4lY3FPz5AKE-3_31-mX5W5gS8,6420
+httk/core/datastream/textstream_filename.py,sha256=AVuUlmQ8ItsJ78F3msV7uqGmxigerZTx5tq0dHCXns0,1902
+httk/core/datastream/textstream_filename_view.py,sha256=2E_e0DKE_XeitInKOKIJHxLo0qlSm-Y8cvRsDSHeMvs,1332
+httk/core/datastream/textstream_like.py,sha256=R2eGKVWGS12i5thtjA8dqpuvkBlVE0rFqqtPwyLvMDY,299
+httk/core/datastream/textstream_request.py,sha256=DPFDBHUjttFBd3YZYox6KOC74udajOglnIEFVCBP6Pc,2505
+httk/core/datastream/textstream_request_view.py,sha256=EflFJJ3dgUhUmuFblIauwoUY5Rsv088hwIaDf6RxjJk,1816
+httk/core/datastream/textstream_string.py,sha256=VipgoYgLiSEsePzhgs0xbbxwFwIWgQqI6lEwkj2HlzI,1334
+httk/core/datastream/textstream_string_view.py,sha256=z9NxkXjRD62QqJW3-inMPRi7lIBNfr7tjuAugD9nmTE,1111
+httk/core/datastream/textstream_url.py,sha256=j1gjNQKlIUiGDyxVMLRC1mLKZIeTAOWmGZkUWB6R8oc,2653
+httk/core/datastream/textstream_url_view.py,sha256=DOUovDax_JevCB8gkLAYAoLRGpblS1ddO-vLZKGEub8,1251
+httk/core/datastream/textstream_view.py,sha256=S4lgenptFquuO5gqAc7R2GBQkjQgXhCR9IJzHmdhg2E,436
+httk/core/views/__init__.py,sha256=o2794D3HSQPwIqP31ujvgceR_iHqS1-xAMoQTvl0mYs,124
+httk/core/views/backend.py,sha256=m2EMCK9A8a_j216lIN024wv8IIjAkFf-IKLI2Lu6wEg,2485
+httk/core/views/unwrapping.py,sha256=VyFC-QWokBuDHpTCmSBRVjQgQIe9nF-TWm7joo7uZTc,512
+httk/core/views/view.py,sha256=yL3ML_OX26vFodTSDCtqkU5uHZ24c08HwOpxjDNOWs8,2892
+httk/handlers/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httk_core-2.0.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+httk_core-2.0.0.dist-info/METADATA,sha256=_6od5xP_hrLJln7gLUYUVRsiA4yguBnDq7radPTr2VI,2756
+httk_core-2.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+httk_core-2.0.0.dist-info/top_level.txt,sha256=UBbnLJzPWLPWOl6JzJzeLuWa3uq7iStjxrP4741hFRg,5
+httk_core-2.0.0.dist-info/RECORD,,

httk_core-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+