dirigent-block-http 0.17.0__py3-none-any.whl

dirigent_block_http/__init__.py

@@ -0,0 +1,31 @@
+"""The HTTP block family: calling an endpoint, waiting for one, and posting a signed body."""
+
+from dirigent_block_http.connections import HttpConnectionKind
+from dirigent_block_http.http import HttpReadySensor, HttpRequestOperator
+from dirigent_block_http.webhooks import WebhookPostOperator
+from dirigent_plugin import Contribution, extension
+
+
+class HttpBlocks:
+    """The plugin object the host discovers under the dirigent.plugins.v1 entry-point group."""
+
+    @extension
+    def contribute(self) -> Contribution:
+        """Contribute the HTTP blocks and the connection kind they are addressed through."""
+        return Contribution(
+            operators=[HttpRequestOperator(), WebhookPostOperator()],
+            sensors=[HttpReadySensor()],
+            connection_kinds=[HttpConnectionKind()],
+        )
+
+
+plugin = HttpBlocks()
+
+__all__ = [
+    "HttpBlocks",
+    "HttpConnectionKind",
+    "HttpReadySensor",
+    "HttpRequestOperator",
+    "WebhookPostOperator",
+    "plugin",
+]

dirigent_block_http/connections.py

@@ -0,0 +1,36 @@
+"""The generic HTTP connection kind, and the client one is turned into.
+
+The configuration it registers is :class:`dirigent_common.HttpConnectionConfig`, so an adapter
+pack presents the same HTTP connection as this one rather than redefining base URL, auth, TLS
+and timeouts into a fourth slightly different form.
+"""
+
+from typing import ClassVar
+
+import httpx2
+from pydantic import BaseModel
+
+from dirigent_common import HealthReport, HttpConnectionConfig, build_client
+from dirigent_plugin import ConnectionKind
+
+
+class HttpConnectionKind(ConnectionKind):
+    """The connection kind every generic HTTP block resolves its credentials through."""
+
+    id: ClassVar[str] = "http"
+    config_model: ClassVar[type[BaseModel]] = HttpConnectionConfig
+
+    async def check(self, config: BaseModel) -> HealthReport:
+        """Request the health path and report whether the service answered."""
+        settings = HttpConnectionConfig.model_validate(config.model_dump())
+        try:
+            async with build_client(settings) as client:
+                response = await client.get(settings.health_path)
+        except httpx2.HTTPError as error:
+            return HealthReport(healthy=False, detail=f"{type(error).__name__}: {error}")
+        healthy = response.status_code < 500
+        return HealthReport(
+            healthy=healthy,
+            detail=f"HTTP {response.status_code}",
+            version=response.headers.get("server"),
+        )

dirigent_block_http/http.py

@@ -0,0 +1,323 @@
+"""The generic HTTP blocks: one operator that calls a service, one sensor that waits for one."""
+
+import json
+import time
+from datetime import timedelta
+from typing import ClassVar, Literal
+
+import httpx2
+from pydantic import BaseModel, Field, JsonValue, model_validator
+
+from dirigent_block_http.connections import HttpConnectionConfig
+from dirigent_block_http.messages import (
+    NO_TARGET,
+    RESPONSE_TOO_LARGE,
+    STATUS_REFUSED,
+)
+from dirigent_common import BlockModel, Duration, Size
+from dirigent_plugin import (
+    BlockFailure,
+    ConnectionRef,
+    ErrorClass,
+    NotYet,
+    Operator,
+    OperatorSpec,
+    RemoteHandle,
+    Sensor,
+    SensorSpec,
+    StepContext,
+)
+
+type HttpMethod = Literal["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]
+
+DEFAULT_TEXT_CONTENT_TYPE = "text/plain; charset=utf-8"
+
+JSON_CONTENT_TYPE = "application/json"
+
+
+class HttpTarget(BlockModel):
+    """The half of an HTTP block's config that says which service to talk to."""
+
+    connection: ConnectionRef | None = None
+    """The code of the connection whose base URL, auth, TLS, and timeout apply."""
+
+    url: str | None = None
+    """An absolute URL, for the case where no connection is configured."""
+
+    path: str = "/"
+    """The path resolved against the connection's base URL."""
+
+    timeout: Duration | None = Field(default=None, gt=timedelta(0))
+    """Overrides the connection's timeout for this call alone."""
+
+    follow_redirects: bool = False
+    """Whether a 3xx is followed rather than returned as the answer.
+
+    A redirect to another host arrives without the connection's credentials: the client drops
+    the ``Authorization`` header when the origin changes, so a service that redirects before
+    authenticating must be configured with the URL it redirects to.
+    """
+
+    @model_validator(mode="after")
+    def _require_a_target(self) -> "HttpTarget":
+        """Reject a config that names neither a connection nor an absolute URL."""
+        if not self.connection and not self.url:
+            raise ValueError(NO_TARGET.render())
+        return self
+
+
+def client_for(target: HttpTarget, ctx: StepContext) -> httpx2.AsyncClient:
+    """Build the client one call uses: the connection's, or a bare one for an absolute URL."""
+    if target.connection:
+        return ctx.http(target.connection)
+    fallback: timedelta = HttpConnectionConfig.model_fields["timeout"].default
+    return httpx2.AsyncClient(timeout=(target.timeout or fallback).total_seconds())
+
+
+def request_timeout(target: HttpTarget, client: httpx2.AsyncClient) -> httpx2.Timeout:
+    """The timeout one request carries: the step's override, or the client's own.
+
+    ``build_request`` reads an explicit ``timeout=None`` as "no timeout on any phase" rather
+    than as "whatever the client is configured with", so a step that configures no override
+    is given the client's own timeout rather than the unset field.
+    """
+    if target.timeout is None:
+        return client.timeout
+    return httpx2.Timeout(target.timeout.total_seconds())
+
+
+def request_url(target: HttpTarget) -> str:
+    """Resolve what one call requests: the absolute URL, or the path on the connection."""
+    return target.url or target.path
+
+
+def decode(response: httpx2.Response, payload: bytes) -> tuple[JsonValue | None, str | None]:
+    """Split a body into its parsed JSON and its text, whichever it turned out to be."""
+    if "json" in response.headers.get("content-type", ""):
+        try:
+            parsed: JsonValue = json.loads(payload)
+        except ValueError:
+            return None, _as_text(payload)
+        return parsed, None
+    return None, _as_text(payload)
+
+
+def body_of(response: httpx2.Response, payload: bytes) -> JsonValue:
+    """The one value an output carries: the parsed JSON when the answer is JSON, else the text."""
+    parsed, text = decode(response, payload)
+    return text if parsed is None else parsed
+
+
+def _as_text(payload: bytes) -> str:
+    """Render a body as the text an output carries."""
+    return payload.decode("utf-8", errors="replace")
+
+
+async def read_bounded(response: httpx2.Response, limit: int) -> bytes:
+    """Read a whole body, refusing one larger than the step said it would hold.
+
+    Counted as it arrives rather than trusted from a header, because content-length is the
+    service's claim and this is the worker's memory.
+    """
+    chunks: list[bytes] = []
+    total = 0
+    async for chunk in response.aiter_bytes():
+        total += len(chunk)
+        if total > limit:
+            raise BlockFailure(RESPONSE_TOO_LARGE, error_class=ErrorClass.REJECTED, limit=limit)
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
+class HttpRequestConfig(HttpTarget):
+    """What one HTTP call sends, and which responses count as success."""
+
+    method: HttpMethod = "GET"
+    query: dict[str, str | int | float | bool] = Field(default_factory=dict[str, str | int | float | bool])
+    headers: dict[str, str] = Field(default_factory=dict[str, str])
+    body: JsonValue | None = None
+    """What the request sends, usually a reference to what an earlier step produced.
+
+    A string is sent as it stands, which is what a query language, an XML document or a csv
+    upload goes in; any other value is serialised and sent as JSON. A document held in
+    storage is read by ``storage.read`` first and referenced here.
+    """
+
+    content_type: str | None = None
+    """The content type the body is sent with, overriding the default for what it carries.
+
+    A string defaults to ``text/plain; charset=utf-8`` and any other value to
+    ``application/json``, so this is where an endpoint that wants ``text/csv`` or
+    ``application/xml`` is told.
+    """
+
+    success_status: list[int] = Field(default_factory=list[int])
+    """Status codes that count as success; empty means any 2xx."""
+
+    max_response: Size = 32 * 1024 * 1024
+    """How much of a response is read into memory.
+
+    A body has to be whole to be parsed, so one too large to hold is refused rather than
+    truncated: half a JSON document is not a smaller answer, it is a wrong one, and a step
+    that acted on it would be acting on something the service never said.
+    """
+
+    def request_body(self) -> tuple[dict[str, str], bytes | None]:
+        """The headers and the bytes one request is built with, the body serialised here.
+
+        Serialised by the block rather than by the client, so the content type and the bytes
+        are decided in one place.
+        """
+        if self.body is None:
+            return dict(self.headers), None
+        if isinstance(self.body, str):
+            content, declared = self.body.encode(), DEFAULT_TEXT_CONTENT_TYPE
+        else:
+            content = json.dumps(self.body, separators=(",", ":"), ensure_ascii=False).encode()
+            declared = JSON_CONTENT_TYPE
+        # Rebuilt without the header so one spelling of it reaches the client, whichever
+        # case the document wrote.
+        headers = {name: value for name, value in self.headers.items() if name.lower() != "content-type"}
+        named = next((value for name, value in self.headers.items() if name.lower() == "content-type"), None)
+        headers["content-type"] = self.content_type or named or declared
+        return headers, content
+
+
+class HttpRequestOutput(BlockModel):
+    """What one HTTP call observed, which downstream steps reference by field."""
+
+    status: int
+    headers: dict[str, str]
+    body: JsonValue = None
+    """What the service answered: the parsed document when it is JSON, else the text."""
+
+    body_bytes: int
+    """How many bytes the answer was."""
+
+    duration_ms: int
+
+
+class HttpRequestOperator(Operator[HttpRequestConfig, HttpRequestOutput]):
+    """Calls an HTTP service once and reports what it said."""
+
+    spec = OperatorSpec(id="http.request", summary="Call an HTTP endpoint.", idempotent=False)
+    config_model: ClassVar[type[BaseModel]] = HttpRequestConfig
+    output_model: ClassVar[type[BaseModel]] = HttpRequestOutput
+
+    async def execute(self, config: HttpRequestConfig, ctx: StepContext) -> HttpRequestOutput | RemoteHandle:
+        """Send the request, and turn an unsuccessful status into a classified failure."""
+        started = time.monotonic()
+        async with client_for(config, ctx) as client:
+            headers, content = config.request_body()
+            request = client.build_request(
+                config.method,
+                request_url(config),
+                params=dict(config.query) or None,
+                headers=headers or None,
+                content=content,
+                timeout=request_timeout(config, client),
+            )
+            response = await client.send(request, stream=True, follow_redirects=config.follow_redirects)
+            try:
+                payload = await read_bounded(response, config.max_response)
+            finally:
+                await response.aclose()
+        duration = round((time.monotonic() - started) * 1000)
+        ctx.log.info(
+            "http call",
+            method=config.method,
+            url=request_url(config),
+            status=response.status_code,
+            bytes=len(payload),
+            duration_ms=duration,
+        )
+        if not is_success(response.status_code, config.success_status):
+            raise BlockFailure(
+                STATUS_REFUSED,
+                error_class=status_class(response.status_code),
+                method=config.method,
+                url=request_url(config),
+                status=response.status_code,
+            )
+        return HttpRequestOutput(
+            status=response.status_code,
+            headers={name.lower(): value for name, value in response.headers.items()},
+            body=body_of(response, payload),
+            body_bytes=len(payload),
+            duration_ms=duration,
+        )
+
+
+class HttpReadyConfig(HttpTarget):
+    """What readiness means for one service."""
+
+    expect_status: list[int] = Field(default_factory=list[int])
+    """Status codes that mean ready; empty means any 2xx."""
+
+    contains: str | None = None
+    """Optional body matcher; readiness also requires the response to contain this text."""
+
+    max_response: Size = 1024 * 1024
+    """How much of the answer is read while looking for ``contains``.
+
+    A probe asks whether a service is up. An endpoint answering a readiness check with more
+    than this is not answering the question, so the poke reads that much and stops rather
+    than holding whatever arrives on a worker that pokes it every few seconds.
+    """
+
+
+class HttpReadyOutput(BlockModel):
+    """The observation that a service is up, passed downstream like any output."""
+
+    status: int
+    duration_ms: int
+    matched: bool
+
+
+class HttpReadySensor(Sensor[HttpReadyConfig, HttpReadyOutput]):
+    """Waits for an endpoint to answer successfully; each poke is one short, read-only GET."""
+
+    spec = SensorSpec(id="http.ready", summary="Wait for an HTTP endpoint to report ready.")
+    config_model: ClassVar[type[BaseModel]] = HttpReadyConfig
+    output_model: ClassVar[type[BaseModel]] = HttpReadyOutput
+
+    async def poke(self, config: HttpReadyConfig, ctx: StepContext) -> HttpReadyOutput | NotYet:
+        """Observe once. A service that is not up yet is the condition, not an error."""
+        started = time.monotonic()
+        try:
+            async with client_for(config, ctx) as client:
+                request = client.build_request("GET", request_url(config), timeout=request_timeout(config, client))
+                response = await client.send(request, stream=True, follow_redirects=config.follow_redirects)
+                try:
+                    answered = await read_bounded(response, config.max_response)
+                finally:
+                    await response.aclose()
+        except httpx2.TransportError as error:
+            ctx.log.debug("endpoint is not reachable yet", error=str(error))
+            return NotYet()
+        duration = round((time.monotonic() - started) * 1000)
+        if not is_success(response.status_code, config.expect_status):
+            ctx.log.debug("endpoint is not ready yet", status=response.status_code)
+            return NotYet()
+        if config.contains is not None and config.contains not in _as_text(answered):
+            ctx.log.debug("endpoint answered but the body does not match yet")
+            return NotYet()
+        return HttpReadyOutput(status=response.status_code, duration_ms=duration, matched=config.contains is not None)
+
+
+def status_class(status: int) -> ErrorClass:
+    """Classify an HTTP status the way retry policy needs it classified.
+
+    A 429 is the one client error that asks to be retried: the server is rate limiting, and
+    the same call succeeds once the window has passed.
+    """
+    if status >= 500 or status == 429:
+        return ErrorClass.TRANSIENT
+    if 400 <= status < 500:
+        return ErrorClass.REJECTED
+    return ErrorClass.UNKNOWN
+
+
+def is_success(status: int, expected: list[int]) -> bool:
+    """Decide whether a status counts as success: the declared set, or any 2xx."""
+    return status in expected if expected else 200 <= status < 300

dirigent_block_http/messages.py

@@ -0,0 +1,26 @@
+"""Every refusal the http family makes, catalogued under the ``http`` prefix."""
+
+from dirigent_common import Catalogue
+
+HTTP = Catalogue("http")
+
+RESPONSE_TOO_LARGE = HTTP.define(
+    "response_too_large",
+    "the response is larger than max_response ({limit} bytes) and is not being read; "
+    "raise max_response, or ask the endpoint for less",
+)
+
+STATUS_REFUSED = HTTP.define("status_refused", "{method} {url} answered {status}")
+
+WEBHOOK_STATUS_REFUSED = HTTP.define("webhook.status_refused", "the receiver at {url} answered {status}")
+
+WEBHOOK_NO_SECRET = HTTP.define(
+    "webhook.no_secret",
+    "connection {connection} has no hmac_secret, so this POST cannot be signed",
+)
+
+
+# What a config refuses at validation. Pydantic owns the code a validator's refusal reaches
+# the wire under, so these are rendered into the ``ValueError`` it wraps.
+
+NO_TARGET = HTTP.define("no_target", "an HTTP block needs either a connection or an absolute url")

dirigent_block_http/webhooks.py

@@ -0,0 +1,150 @@
+"""``webhook.post``: an outbound, optionally HMAC-signed JSON POST.
+
+The ``X-Dirigent-Signature`` it presents is computed the same way dirigent's own inbound
+``/hooks/{token}`` verifies one, so the two must stay in step.
+
+The block serialises the body itself, and the signature covers the bytes that go on the
+wire: letting the HTTP client re-encode the body after signing would produce a signature
+that verifies nowhere.
+"""
+
+import hashlib
+import hmac
+import json
+import time
+from typing import ClassVar, Final
+
+from pydantic import BaseModel, ConfigDict, Field, JsonValue
+
+from dirigent_block_http.connections import HttpConnectionConfig
+from dirigent_block_http.http import (
+    HttpTarget,
+    client_for,
+    decode,
+    is_success,
+    read_bounded,
+    request_url,
+    status_class,
+)
+from dirigent_block_http.messages import WEBHOOK_NO_SECRET, WEBHOOK_STATUS_REFUSED
+from dirigent_common import BlockModel, Size
+from dirigent_plugin import BlockFailure, ConnectionRef, ErrorClass, Operator, OperatorSpec, RemoteHandle, StepContext
+
+SIGNATURE_HEADER: Final = "X-Dirigent-Signature"
+
+JSON_CONTENT_TYPE: Final = "application/json"
+
+JSON_SEPARATORS: Final = (",", ":")
+
+
+class WebhookPostConfig(HttpTarget):
+    """What to POST, where, and what to sign it with."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    body: JsonValue = Field(default_factory=dict[str, JsonValue])
+    """The JSON payload, usually built from upstream outputs with ``${steps...}`` references."""
+
+    headers: dict[str, str] = Field(default_factory=dict[str, str])
+    """Extra headers the receiver wants, such as a routing key."""
+
+    max_response: Size = 1024 * 1024
+    """How much of the receiver's answer is read, before the step is failed instead.
+
+    An acknowledgement is small: what a receiver says back is that it took the delivery, not
+    the data itself. A megabyte is generous for that, and a receiver answering with more than
+    a step said it would hold is a receiver to find out about rather than to read.
+    """
+
+    sign_with: ConnectionRef | None = None
+    """The connection whose ``hmac_secret`` signs the body; unset means the POST is unsigned.
+
+    Named separately from ``connection`` so a POST to an absolute URL can still be signed
+    with a secret this instance holds, and so signing is something a document says out loud
+    rather than something that happens because a connection had a field set."""
+
+    success_status: list[int] = Field(default_factory=list[int])
+    """Status codes that count as delivered; empty means any 2xx."""
+
+
+class WebhookPostOutput(BlockModel):
+    """What the receiver said, which downstream steps reference by field."""
+
+    status: int
+    signed: bool
+    duration_ms: int
+    json_body: JsonValue | None = None
+    text: str | None = None
+
+
+class WebhookPostOperator(Operator[WebhookPostConfig, WebhookPostOutput]):
+    """POSTs a JSON body to a connection or a URL, optionally signed the way dirigent signs."""
+
+    spec = OperatorSpec(id="webhook.post", summary="POST a JSON body, optionally HMAC-signed.", idempotent=False)
+    config_model: ClassVar[type[BaseModel]] = WebhookPostConfig
+    output_model: ClassVar[type[BaseModel]] = WebhookPostOutput
+
+    async def execute(self, config: WebhookPostConfig, ctx: StepContext) -> WebhookPostOutput | RemoteHandle:
+        """Render the body once, sign those bytes, send them, and read the answer."""
+        payload = render(config.body)
+        headers = {**config.headers, "Content-Type": JSON_CONTENT_TYPE}
+        secret = _secret(config, ctx)
+        if secret is not None:
+            headers[SIGNATURE_HEADER] = sign(secret, payload)
+        started = time.monotonic()
+        async with client_for(config, ctx) as client:
+            request = client.build_request(
+                "POST",
+                request_url(config),
+                content=payload,
+                headers=headers,
+                timeout=config.timeout.total_seconds() if config.timeout is not None else None,
+            )
+            response = await client.send(request, stream=True, follow_redirects=config.follow_redirects)
+            try:
+                answered = await read_bounded(response, config.max_response)
+            finally:
+                await response.aclose()
+        duration = round((time.monotonic() - started) * 1000)
+        ctx.log.info(
+            "webhook delivered",
+            status=response.status_code,
+            bytes_sent=len(payload),
+            signed=secret is not None,
+            duration_ms=duration,
+        )
+        if not is_success(response.status_code, config.success_status):
+            raise BlockFailure(
+                WEBHOOK_STATUS_REFUSED,
+                error_class=status_class(response.status_code),
+                url=request_url(config),
+                status=response.status_code,
+            )
+        parsed, text = decode(response, answered)
+        return WebhookPostOutput(
+            status=response.status_code,
+            signed=secret is not None,
+            duration_ms=duration,
+            json_body=parsed,
+            text=text,
+        )
+
+
+def render(body: JsonValue) -> bytes:
+    """Serialise the body once, into the exact bytes that are both signed and sent."""
+    return json.dumps(body, separators=JSON_SEPARATORS, ensure_ascii=False).encode()
+
+
+def sign(secret: bytes, payload: bytes) -> str:
+    """Compute the signature over the raw body, the way dirigent's own intake verifies one."""
+    return hmac.new(secret, payload, hashlib.sha256).hexdigest()
+
+
+def _secret(config: WebhookPostConfig, ctx: StepContext) -> bytes | None:
+    """Read the signing secret off the named connection, refusing one that has none."""
+    if config.sign_with is None:
+        return None
+    connection = ctx.connection(config.sign_with, HttpConnectionConfig)
+    if connection.hmac_secret is None:
+        raise BlockFailure(WEBHOOK_NO_SECRET, error_class=ErrorClass.REJECTED, connection=repr(config.sign_with))
+    return connection.hmac_secret.get_secret_value().encode()

dirigent_block_http-0.17.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: dirigent-block-http
+Version: 0.17.0
+Summary: The HTTP block family for dirigent: http.request, http.ready, webhook.post, and the http connection kind.
+License-Expression: LicenseRef-Proprietary
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: dirigent-common==0.17.0
+Requires-Dist: dirigent-plugin==0.17.0
+Requires-Dist: httpx2>=2.12.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# dirigent-block-http
+
+The HTTP block family: `http.request` calls an endpoint, `http.ready` waits for one to answer,
+and `webhook.post` sends a JSON body that can carry an HMAC signature.
+
+It registers the `http` connection kind, which is where a base URL, its credential, its TLS
+settings and its timeouts are held, so a step names a connection rather than a URL and a
+secret. The configuration and the client behind that kind are `dirigent-common`'s, and any
+pack may use them; the registration is this family's.

dirigent_block_http-0.17.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+dirigent_block_http/__init__.py,sha256=nf4T94blO2qbnN2rRSXA64C8oL8tOn2f85_plZ_0cSw,989
+dirigent_block_http/connections.py,sha256=Kxk2Ha6TbZVf_KDClab7S0lJcQXS37__Oa20HvdCtR8,1448
+dirigent_block_http/http.py,sha256=NMSDcnSm5oRKO5hKjLpZCzvhxXCYYMcv8-B1wnHbZr0,13161
+dirigent_block_http/messages.py,sha256=Z57MYi9wZw6AjoaOE6FqLKcrgG91Un6ujy-ELjxiMrU,953
+dirigent_block_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dirigent_block_http/webhooks.py,sha256=j314Ir0iQLzZbhm7QkAu1EdKCO8ol76Ps8r76YGMgww,6059
+dirigent_block_http-0.17.0.dist-info/licenses/LICENSE,sha256=LKBm7Cx-WBc1zca4DjGxq99VEpAiWGnZDxIKmntn1hQ,910
+dirigent_block_http-0.17.0.dist-info/WHEEL,sha256=R1d3uUTbmXM1FHXH_itQashbrqrOSVj-hvBCpmkIIGE,81
+dirigent_block_http-0.17.0.dist-info/entry_points.txt,sha256=_V_HZvF2K9-oBPX4nr4QZ8qsfvPjQ9pYmjwLIj7FuMk,63
+dirigent_block_http-0.17.0.dist-info/METADATA,sha256=X28vqphyWMoYmiywQk_-YkjEEAsMEhszJfEPUWLUIBs,1032
+dirigent_block_http-0.17.0.dist-info/RECORD,,

dirigent_block_http-0.17.0.dist-info/WHEEL

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

dirigent_block_http-0.17.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[dirigent.plugins.v1]
+block-http = dirigent_block_http:plugin
+

dirigent_block_http-0.17.0.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2026 Morten Olav Hansen <morten@winterop.com>. All rights reserved.
+
+This source code and accompanying documentation are the property of
+Morten Olav Hansen. No license, express or implied, is granted to use, copy,
+modify, merge, publish, distribute, sublicense, or sell copies of this
+software or its derivatives.
+
+The source is published for reference only. Any use beyond reading
+requires written permission from the copyright holder.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES,
+OR OTHER LIABILITY ARISING FROM THE USE OF THE SOFTWARE.
+
+Third-party components redistributed with this software, and the licences they
+carry, are listed in THIRD_PARTY_NOTICES.md.