nace-haystack 0.1.0__py3-none-any.whl

haystack_integrations/components/routers/nace/text_router.py

@@ -0,0 +1,316 @@
+# SPDX-FileCopyrightText: 2026-present Nace AI
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+
+# Mirrors deepset's TypeSafeTextRouter (typesafe-haystack) so a Jev pipeline switches to Drex by changing the import,
+# the class name and the API key.
+from typing import Any
+
+import nace_sdk
+from haystack import component, default_to_dict
+from haystack.utils import Secret
+
+from haystack_integrations.common.nace.client import (
+    DEFAULT_MODEL,
+    client_options,
+    is_openrouter,
+    make_async_client,
+    make_client,
+    provider_name,
+    resolve_base_url,
+)
+from haystack_integrations.common.nace.errors import readable_error
+from haystack_integrations.common.nace.images import ImageInput, image_types
+from haystack_integrations.common.nace.request import DrexResponse, build_call
+
+_LOW_CONFIDENCE = "low_confidence"
+_PROBABILITIES = "probabilities"
+_QUESTION_ID = "route"
+
+
+@component
+class NaceTextRouter:
+    """
+    Routes a text to the connection of the label a Drex decision model picks for it.
+
+    The model answers a single `choice` question over `labels` and returns calibrated probabilities. The component
+    has one output per label. When `min_confidence` is set, it also has a `low_confidence` output that receives the
+    text whenever the answer's `confidence` is below the threshold, so uncertain texts can go to a fallback such as
+    an LLM or a human. With `include_probabilities=True`, a `probabilities` output carries the full answer, so
+    thresholds stay in your pipeline.
+
+    Images can be routed too: pass them to `run` and the default model, `drex-max-v1.1`, reads them alongside the text,
+    as "Image 1", "Image 2" and so on. Images too big for one request are shrunk to fit.
+
+    The component also works with OpenRouter and other TypeSafe-compatible hosts: set `api_base_url` to the server
+    and `model` to one of its models.
+
+    ### Usage example
+
+    ```python
+    from haystack_integrations.components.routers.nace import NaceTextRouter
+
+    router = NaceTextRouter(
+        labels={
+            "billing": "Payments, invoices, refunds and charges",
+            "technical": "Bugs, crashes and errors in the product",
+        },
+        instructions="Which team should handle this support request?",
+        min_confidence=0.6,
+    )
+
+    print(router.run(text="I was charged twice for my subscription."))
+    # {'billing': 'I was charged twice for my subscription.'}
+    ```
+    """
+
+    def __init__(
+        self,
+        labels: list[str] | dict[str, str | None],
+        *,
+        instructions: str = "Which category does this text belong to?",
+        model: str = DEFAULT_MODEL,
+        api_key: Secret = Secret.from_env_var("NACE_API_KEY"),
+        api_base_url: str | None = None,
+        min_confidence: float | None = None,
+        include_probabilities: bool = False,
+        timeout: float | None = None,
+        max_retries: int | None = None,
+    ) -> None:
+        """
+        Creates a NaceTextRouter.
+
+        :param labels:
+            The labels to route between, each becoming an output connection. Pass a dict of label to description to
+            tell the model what each label means.
+        :param instructions:
+            The question the model answers by picking one of the labels.
+        :param model:
+            The Drex model to use. Defaults to the newest Drex model, which reads images; pin a model such as
+            `"drex-max-v1.1"` or `"drex-v2.0"` in production. On OpenRouter, use its model IDs, such as
+            `"nace-ai/drex-max"`.
+        :param api_key:
+            The Nace API key.
+        :param api_base_url:
+            Base URL of the API. If `None`, the `NACE_BASE_URL` environment variable is used, or
+            `https://console.nace.ai` if it is unset.
+        :param min_confidence:
+            Threshold between 0 and 1 for the answer's `confidence`. Texts below it are sent to the `low_confidence`
+            output. If `None`, every text goes to a label output.
+        :param include_probabilities:
+            If `True`, a `probabilities` output also receives the full answer: the picked label, its `confidence` and
+            every label's probability.
+        :param timeout:
+            Timeout in seconds for each request attempt. If `None`, 60 seconds are used, because Drex may take up to
+            55 seconds to answer.
+        :param max_retries:
+            Maximum number of retries after a failed request attempt. If `None`, the SDK default of 2 is used.
+        :raises ValueError:
+            If `labels` is empty, contains a reserved output name or a described label named `type`, or if
+            `min_confidence` is outside 0 to 1.
+        """
+        if not labels:
+            msg = "`labels` must contain at least one label."
+            raise ValueError(msg)
+        if _LOW_CONFIDENCE in labels:
+            msg = f"`{_LOW_CONFIDENCE}` is reserved for the low confidence output and can't be used as a label."
+            raise ValueError(msg)
+        if include_probabilities and _PROBABILITIES in labels:
+            msg = f"`{_PROBABILITIES}` is reserved for the probabilities output and can't be used as a label."
+            raise ValueError(msg)
+        if isinstance(labels, dict) and "type" in labels:
+            # Haystack reads a saved dict with a "type" key as a serialized object, so the pipeline couldn't be loaded
+            msg = (
+                "A label named `type` can't have a description, because a saved pipeline couldn't be loaded. "
+                "Rename the label, or pass `labels` as a list."
+            )
+            raise ValueError(msg)
+        if min_confidence is not None and not 0 <= min_confidence <= 1:
+            msg = f"`min_confidence` must be between 0 and 1, got {min_confidence}."
+            raise ValueError(msg)
+
+        self.labels = labels
+        self.instructions = instructions
+        self.model = model
+        self.api_key = api_key
+        self.api_base_url = api_base_url
+        self.min_confidence = min_confidence
+        self.include_probabilities = include_probabilities
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._client: nace_sdk.NaceClient | None = None
+        self._async_client: nace_sdk.AsyncNaceClient | None = None
+        self._async_client_loop: asyncio.AbstractEventLoop | None = None
+
+        # Drex takes choice criteria as a dict of label to description
+        criteria = labels if isinstance(labels, dict) else dict.fromkeys(labels)
+        self._question = nace_sdk.Choice(instructions=instructions, criteria=criteria)
+
+        outputs: dict[str, Any] = dict.fromkeys(labels, str)
+        if min_confidence is not None:
+            outputs[_LOW_CONFIDENCE] = str
+        if include_probabilities:
+            outputs[_PROBABILITIES] = dict[str, Any]
+        component.set_output_types(self, **outputs)
+
+    def _client_options(self) -> dict[str, Any]:
+        return client_options(self.api_key, self.api_base_url, self.timeout, self.max_retries)
+
+    def warm_up(self) -> None:
+        """
+        Creates the synchronous Nace client.
+        """
+        if self._client is None:
+            self._client = make_client(self._client_options())
+
+    async def warm_up_async(self) -> None:
+        """
+        Creates the asynchronous Nace client for the running event loop.
+        """
+        loop = asyncio.get_running_loop()
+        if self._async_client_loop is not None and self._async_client_loop is not loop:
+            # An async HTTP client belongs to the event loop it first ran on, so a new `asyncio.run` (a second
+            # notebook cell, a second script run) needs a new client. The old one can't be closed from this loop.
+            self._async_client = None
+        if self._async_client is None:
+            self._async_client = make_async_client(self._client_options())
+        self._async_client_loop = loop
+
+    def close(self) -> None:
+        """
+        Releases the synchronous Nace client.
+        """
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    async def close_async(self) -> None:
+        """
+        Releases the asynchronous Nace client.
+        """
+        if self._async_client is not None:
+            await self._async_client.aclose()
+            self._async_client = None
+            self._async_client_loop = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            labels=self.labels,
+            instructions=self.instructions,
+            model=self.model,
+            api_key=self.api_key,
+            api_base_url=self.api_base_url,
+            min_confidence=self.min_confidence,
+            include_probabilities=self.include_probabilities,
+            timeout=self.timeout,
+            max_retries=self.max_retries,
+        )
+
+    def _call(self, text: str, images: list[ImageInput] | None) -> dict[str, Any]:
+        if not isinstance(text, str):
+            msg = "NaceTextRouter expects a str as input."
+            raise TypeError(msg)
+        return build_call(
+            text,
+            {_QUESTION_ID: self._question},
+            model=self.model,
+            images=images,
+            openrouter=is_openrouter(resolve_base_url(self.api_base_url)),
+        )
+
+    def _error(self, error: nace_sdk.NaceError, images: list[ImageInput] | None) -> nace_sdk.NaceError:
+        return readable_error(
+            error, provider_name(resolve_base_url(self.api_base_url)), image_types=image_types(images or [])
+        )
+
+    def _route(self, text: str, response: DrexResponse) -> dict[str, Any]:
+        """
+        Picks the output for the text from the Drex response.
+
+        :param text:
+            The routed text.
+        :param response:
+            The Drex response for the text.
+        :returns:
+            A dictionary mapping `low_confidence` to the text if `min_confidence` is set and the answer's `confidence`
+            is below it, otherwise mapping the picked label to the text. With `include_probabilities`, it also maps
+            `probabilities` to the full answer.
+        """
+        answer = response.answers[_QUESTION_ID]
+        if answer["choice"] not in self._question.criteria:
+            msg = (
+                f"{provider_name(resolve_base_url(self.api_base_url))} answered {answer['choice']!r}, which isn't one "
+                f"of the labels {list(self._question.criteria)}."
+            )
+            raise ValueError(msg)
+        if self.min_confidence is not None and answer["confidence"] < self.min_confidence:
+            routed: dict[str, Any] = {_LOW_CONFIDENCE: text}
+        else:
+            routed = {answer["choice"]: text}
+        if self.include_probabilities:
+            routed[_PROBABILITIES] = answer
+        return routed
+
+    def run(self, text: str, images: list[ImageInput] | None = None) -> dict[str, Any]:
+        """
+        Routes the text to the output of the label the model picks.
+
+        :param text:
+            The text to route.
+        :param images:
+            Optional images the model reads with the text, referred to as "Image 1", "Image 2" and so on:
+            `ImageContent`, `ByteStream`, or files uploaded to Drex with nace-sdk.
+        :returns:
+            A dictionary with the picked label or `low_confidence` mapped to the input text, and `probabilities`
+            mapped to the full answer if `include_probabilities` is `True`.
+        :raises TypeError:
+            If `text` is not a string.
+        :raises ValueError:
+            If images are passed to a model that reads text only.
+        """
+        call = self._call(text, images)
+        self.warm_up()
+        assert self._client is not None  # noqa: S101  # mypy: the client is created by warm_up above
+
+        try:
+            response = self._client.system_one(**call)
+        except nace_sdk.NaceError as error:
+            raise self._error(error, images) from error
+        return self._route(text=text, response=response)
+
+    async def run_async(self, text: str, images: list[ImageInput] | None = None) -> dict[str, Any]:
+        """
+        Asynchronously routes the text to the output of the label the model picks.
+
+        This is the asynchronous version of the `run` method with the same parameters and return values.
+
+        :param text:
+            The text to route.
+        :param images:
+            Optional images the model reads with the text, referred to as "Image 1", "Image 2" and so on.
+        :returns:
+            A dictionary with the picked label or `low_confidence` mapped to the input text, and `probabilities`
+            mapped to the full answer if `include_probabilities` is `True`.
+        :raises TypeError:
+            If `text` is not a string.
+        :raises ValueError:
+            If images are passed to a model that reads text only.
+        """
+        call = self._call(text, images)
+        await self.warm_up_async()
+        assert self._async_client is not None  # noqa: S101  # mypy: the client is created by warm_up_async above
+
+        try:
+            response = await self._async_client.system_one(**call)
+        except nace_sdk.NaceError as error:
+            raise self._error(error, images) from error
+        return self._route(text=text, response=response)

nace_haystack-0.1.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.5
+Name: nace-haystack
+Version: 0.1.0
+Summary: Haystack integration for Drex decision models by Nace
+Project-URL: Documentation, https://console.nace.ai/docs
+Project-URL: Issues, https://github.com/nace-ai/nace-haystack/issues
+Project-URL: Source, https://github.com/nace-ai/nace-haystack
+Author-email: Nace AI <hello@nace.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Keywords: Drex,Haystack,Nace,classification,decision model,evaluation,routing
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.11
+Requires-Dist: filetype>=1.0.0
+Requires-Dist: haystack-ai>=3.0.0
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: nace-sdk<1.0.0,>=0.3.0
+Requires-Dist: pydantic>=2.0
+Description-Content-Type: text/markdown
+
+# nace-haystack
+
+Haystack components for [Drex](https://console.nace.ai/docs), Nace's decision models.
+
+Drex models don't generate text. They answer typed questions about a text, JSON or images in one request and return
+calibrated probabilities:
+
+- `choice` picks one label from a set of options,
+- `score` rates the input on ordered levels,
+- `noul` gives the probability that a yes/no statement is true.
+
+This package brings them to Haystack pipelines:
+
+| Component | What it does |
+| --- | --- |
+| `NaceTextRouter` | Routes a text (and optional images) to one output per label, with a `low_confidence` fallback |
+| `NaceDocumentClassifier` | Answers questions about each document and stores the answers in its metadata |
+| `NaceFaithfulnessEvaluator` | Judges whether answers are supported by their contexts, like Haystack's `FaithfulnessEvaluator` |
+| `NaceContextRelevanceEvaluator` | Judges whether retrieved contexts help answer the question, like `ContextRelevanceEvaluator` |
+
+The router and classifier mirror deepset's `typesafe-haystack` components for Jev, so a Jev pipeline switches to Drex
+with a few edits (see [Switching from TypeSafe](#switching-from-typesafe)).
+
+## Installation
+
+```bash
+pip install nace-haystack
+```
+
+Create an API key at [console.nace.ai](https://console.nace.ai) and set it as `NACE_API_KEY`.
+
+## Usage
+
+### Route text
+
+```python
+from haystack_integrations.components.routers.nace import NaceTextRouter
+
+router = NaceTextRouter(
+    labels={
+        "billing": "Payments, invoices, refunds and charges",
+        "technical": "Bugs, crashes and errors in the product",
+    },
+    instructions="Which team should handle this support request?",
+    min_confidence=0.6,
+)
+
+print(router.run(text="I was charged twice for my subscription."))
+# {'billing': 'I was charged twice for my subscription.'}
+```
+
+Texts whose answer is less confident than `min_confidence` go to the `low_confidence` output, for a fallback such
+as an LLM or a person. With `include_probabilities=True`, a `probabilities` output carries the full answer, so
+thresholds stay in your pipeline.
+
+### Classify documents
+
+```python
+from haystack import Document
+
+from haystack_integrations.components.classifiers.nace import NaceDocumentClassifier
+
+classifier = NaceDocumentClassifier(
+    questions={
+        "department": {
+            "type": "choice",
+            "instructions": "Which department should handle this ticket?",
+            "criteria": {"billing": None, "technical": None, "sales": None},
+        },
+        "urgency": {
+            "type": "score",
+            "instructions": "How urgent is this ticket?",
+            "criteria": ["can wait", "this week", "today"],
+        },
+        "refund": {"type": "noul", "instructions": "Is the customer asking for a refund?"},
+    },
+)
+
+result = classifier.run(documents=[Document(content="I was charged twice, please refund me today.")])
+print(result["documents"][0].meta["nace"]["department"])
+# {'type': 'choice', 'choice': 'billing', 'confidence': 0.97, 'probabilities': {...}}
+```
+
+Each document is one request carrying every question, with up to `max_workers` requests (default 3) at once.
+Documents that can't be classified are returned in `failed_documents` with the reason in
+`meta["classification_error"]`.
+
+### Evaluate RAG answers
+
+```python
+from haystack_integrations.components.evaluators.nace import NaceFaithfulnessEvaluator
+
+evaluator = NaceFaithfulnessEvaluator()
+result = evaluator.run(
+    questions=["Who won the race?"],
+    contexts=[["Ada won the 2026 city race."]],
+    predicted_answers=["Ada won the race."],
+)
+print(result["score"], result["individual_scores"])
+```
+
+Both evaluators take the same inputs and return the same outputs (`score`, `individual_scores`, `results`, `meta`) as
+Haystack's built-in LLM evaluators. Each item is one Drex request, and its score is the probability that the answer
+is faithful (or that the contexts are relevant).
+
+## Models
+
+The default model is `drex-max-v1.1` (Drex Max v1.1), which reads text, JSON and images. The default moves to the
+newest Drex model in package releases, and a new model can shift probabilities, so **pin `model=` in production** if
+your pipeline relies on thresholds.
+
+`drex-v2.0` reads text only and bills fewer tokens on short texts: for a short email with three questions, we
+measured 74 input tokens on `drex-v2.0` and 165 on `drex-max-v1.1` (2026-10-29). See
+[Drex's limits](https://console.nace.ai/docs/drex/reference/limits) for questions per request and state sizes.
+Any model ID is sent as given, so new Drex models work without a new release of this package.
+
+## Images
+
+The router and the evaluators take images: `ImageContent`, `ByteStream`, or files uploaded to Drex with nace-sdk
+(`client.documents.upload(...)`). Prompts refer to them as "Image 1", "Image 2" and so on.
+
+```python
+from haystack.dataclasses import ImageContent
+
+router = NaceTextRouter(
+    labels={"invoice": "A bill or invoice", "receipt": "A proof of payment", "other": None},
+    instructions="What kind of document is Image 1?",
+)
+router.run(text="A customer attached a scan.", images=[ImageContent.from_file_path("scan.jpg")])
+```
+
+Images too big to send in one request are shrunk automatically, with a logged warning. Drex Max reads images at about
+1.6 megapixels (1,638,400 pixels), and an image is never shrunk below about 1 megapixel: if the text leaves too little
+room for the images, you get a clear error instead of a blurry image. Photos are turned upright using their EXIF
+orientation before shrinking. Shrinking needs `pip install pillow`; to skip it, downscale earlier with
+`ImageFileToImageContent(size=(2048, 2048))` or `PDFToImageContent(size=(2048, 2048))`. PDFs must be converted to
+images first.
+
+## Other backends
+
+Set `api_base_url` to use Drex through [OpenRouter](https://openrouter.ai) (`https://openrouter.ai/api/v1`, with
+model IDs such as `nace-ai/drex-max`) or another TypeSafe-compatible host. OpenRouter takes inline images only.
+
+## Errors and retries
+
+Requests that hit a rate limit (429) or an overloaded model (529) are retried, waiting as long as Drex asks. Other
+errors are raised as nace-sdk's error classes with a readable message, for example:
+
+```text
+422 from Drex: the request is invalid
+  questions.department.criteria: must have at least 2 labels
+```
+
+## Switching from TypeSafe
+
+The router and classifier take the same parameters and produce the same outputs as `TypeSafeTextRouter` and
+`TypeSafeDocumentClassifier`.
+
+In Python code that uses Jev's default model, change the import, the class name and the API key:
+
+```diff
+-from haystack_integrations.components.routers.typesafe import TypeSafeTextRouter
++from haystack_integrations.components.routers.nace import NaceTextRouter
+
+-router = TypeSafeTextRouter(labels=..., min_confidence=0.6)
++router = NaceTextRouter(labels=..., min_confidence=0.6)
+```
+
+```diff
+-export TYPESAFE_API_KEY=...
++export NACE_API_KEY=...
+```
+
+The classifier writes answers to `meta["nace"]` by default. If your code reads `meta["typesafe"]` (in a filter or a
+`MetadataRouter` rule, for example), pass `metadata_field="typesafe"` to keep the old key.
+
+Questions built with `typesafe_sdk` objects (`Choice`, `Score`, `Noul`) work as they are; you can switch them to
+`nace_sdk`'s classes of the same names when convenient. Where your code catches `TypeSafeError`, catch
+`nace_sdk.NaceError` instead.
+
+In a saved YAML pipeline, make three edits per component:
+
+```diff
+-    type: haystack_integrations.components.routers.typesafe.text_router.TypeSafeTextRouter
++    type: haystack_integrations.components.routers.nace.text_router.NaceTextRouter
+...
+-        - TYPESAFE_API_KEY
++        - NACE_API_KEY
+...
+-      model: jev-latest
++      model: drex-max-v1.1
+```
+
+The classifier's type becomes `haystack_integrations.components.classifiers.nace.document_classifier.NaceDocumentClassifier`.
+A saved pipeline keeps `metadata_field: typesafe`, so answers stay where your filters read them. Model names aren't
+translated: Drex rejects `jev-latest` with a message listing its models.
+
+Drex's own guide covers the API side: [Migrate from TypeSafe](https://console.nace.ai/docs/drex/guides/migrate-from-typesafe).
+
+## License
+
+Apache-2.0

nace_haystack-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+haystack_integrations/common/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/common/nace/__init__.py,sha256=QolspE1wblU-W4W7Pu_vsjugoVpVLj_cjvWbXxymbkY,87
+haystack_integrations/common/nace/client.py,sha256=ySzvabuUFZ9vSHqLCa59l4Ab6700nH3A856SttBY8Aw,6599
+haystack_integrations/common/nace/concurrency.py,sha256=M1ba-1OBlzwhmYrZbvvH6K1bTOBeumpKQri9kTiw800,2024
+haystack_integrations/common/nace/errors.py,sha256=zujZc6rHx9Z2SBtlA5ICP7geJ-KVu_zoU_x93qHcm1w,5896
+haystack_integrations/common/nace/images.py,sha256=ZjAyj5ISYJOrQpMFHVRmiBcHFyOrt0PmMmwxLyMpVsg,9032
+haystack_integrations/common/nace/request.py,sha256=ISeMV8T35HH0JOnav7Q02QfEELVVB81rd30KPREXDHE,6173
+haystack_integrations/components/classifiers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/classifiers/nace/__init__.py,sha256=7zsTQdJqrASGK8PPlvNcv8vHQA-NEhief6FTnbqsXTE,182
+haystack_integrations/components/classifiers/nace/document_classifier.py,sha256=2UeMax_D68_Jnojxcxdqt5UbGlV8Of235bjdAt8YAXQ,17582
+haystack_integrations/components/evaluators/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/evaluators/nace/__init__.py,sha256=kcWH4m89kQzQdF4IolK71lTpU71DYDfOPNwBUfiAYIg,416
+haystack_integrations/components/evaluators/nace/_base.py,sha256=QH1xgZhVusVatLJsz_Jqk1anZkwDuYQwCBkdtu-BaVU,9854
+haystack_integrations/components/evaluators/nace/context_relevance.py,sha256=CpgAQ7MMPyRCPYQDo5v-zDQTrUfdY_w_MmJgmhKaL9k,5528
+haystack_integrations/components/evaluators/nace/faithfulness.py,sha256=4rTX5RuydvjgsolxvL9TYddm86Zu--_-YMsQTXIpuzE,6513
+haystack_integrations/components/routers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/routers/nace/__init__.py,sha256=s-lbJqrePJgDwjBsPcpLhP08ax8fImuWu14F6B-YsVY,158
+haystack_integrations/components/routers/nace/text_router.py,sha256=N_4Ktpu4b8U3k2T7jQW4mIGbt_Jcql41n1Z7tmkmB5Q,13458
+nace_haystack-0.1.0.dist-info/METADATA,sha256=oETyIzCbc3Hqf3Lzu3INf3qEYgMW5lVRH-PgAS9qpx0,9421
+nace_haystack-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+nace_haystack-0.1.0.dist-info/licenses/LICENSE.txt,sha256=VuvjWkPRc52LhptIM3ddscFplogwRiT9Qx4QgMm7s_8,11345
+nace_haystack-0.1.0.dist-info/RECORD,,

nace_haystack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any