nighthawk-python 0.1.0__py3-none-any.whl

nighthawk/tools/contracts.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import tiktoken
+from pydantic import BaseModel
+
+from ..json_renderer import JsonRendererStyle, render_json_text
+
+type ErrorKind = Literal["invalid_input", "resolution", "execution", "transient", "internal"]
+
+
+class ToolBoundaryError(Exception):
+    def __init__(self, *, kind: ErrorKind, message: str, guidance: str | None = None) -> None:
+        super().__init__(message)
+        self.kind: ErrorKind = kind
+        self.guidance: str | None = guidance
+
+
+class _Error(BaseModel, extra="forbid"):
+    kind: ErrorKind
+    message: str
+    guidance: str | None = None
+
+
+class ToolResult[ValueType](BaseModel, extra="forbid"):
+    value: ValueType | None
+    error: _Error | None
+
+
+def render_tool_result_json_text(
+    *,
+    value: object | None,
+    error: object | None,
+    max_tokens: int,
+    encoding: tiktoken.Encoding,
+    style: JsonRendererStyle,
+) -> str:
+    """Render a tool result envelope as compact JSON text.
+
+    Both ``value`` and ``error`` are individually rendered under their own
+    token budgets via ``render_json_text``, then assembled into a
+    ``{"value": ..., "error": ...}`` envelope using f-string interpolation.
+    The sub-values are already valid JSON fragments produced by
+    ``render_json_text`` / ``json.dumps``, so the f-string concatenation
+    is structurally safe.
+    """
+    if error is None:
+        error_text = "null"
+        error_token_count = 0
+        value_max_tokens = max_tokens
+    else:
+        error_max_tokens = int(max_tokens * 0.9)
+        error_text, error_token_count = render_json_text(
+            error,
+            max_tokens=error_max_tokens,
+            encoding=encoding,
+            style=style,
+        )
+        value_max_tokens = max(max_tokens - error_token_count, 0)
+
+    if value is None:
+        value_text = "null"
+    else:
+        value_text, _ = render_json_text(
+            value,
+            max_tokens=value_max_tokens,
+            encoding=encoding,
+            style=style,
+        )
+
+    return f'{{"value":{value_text},"error":{error_text}}}'

nighthawk/tools/execution.py

@@ -0,0 +1,83 @@
+"""Tool execution wrappers: normalization, classification, and toolset wrapping."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from pydantic_ai import RunContext
+from pydantic_ai.exceptions import ApprovalRequired, CallDeferred, ModelRetry
+from pydantic_ai.toolsets.abstract import ToolsetTool
+from pydantic_ai.toolsets.wrapper import WrapperToolset
+
+from ..json_renderer import JsonableValue, to_jsonable_value
+from .contracts import ErrorKind, ToolBoundaryError, ToolResult, _Error
+
+
+def _classify_unexpected_exception(exception: BaseException) -> ErrorKind:
+    if isinstance(exception, TimeoutError):
+        return "transient"
+    return "internal"
+
+
+def _normalize_tool_success(value: object) -> ToolResult[JsonableValue]:
+    return ToolResult(value=to_jsonable_value(value), error=None)
+
+
+def _normalize_tool_failure(*, kind: ErrorKind, message: str, guidance: str | None) -> ToolResult[JsonableValue]:
+    return ToolResult(
+        value=None,
+        error=_Error(
+            kind=kind,
+            message=message,
+            guidance=guidance,
+        ),
+    )
+
+
+async def _run_tool_and_normalize(tool_call: Callable[[], Awaitable[object]]) -> ToolResult[JsonableValue]:
+    """Execute a tool call and normalize the outcome to a ToolResult.
+
+    Control-flow exceptions are re-raised unchanged.
+    """
+
+    try:
+        value = await tool_call()
+    except (ModelRetry, CallDeferred, ApprovalRequired):
+        raise
+    except ToolBoundaryError as exception:
+        return _normalize_tool_failure(
+            kind=exception.kind,
+            message=str(exception),
+            guidance=exception.guidance,
+        )
+    except TimeoutError:
+        raise ModelRetry("Tool execution timed out. Retry.") from None
+    except Exception as exception:
+        kind = _classify_unexpected_exception(exception)
+        return _normalize_tool_failure(
+            kind=kind,
+            message=str(exception) or "Tool execution failed",
+            guidance="The tool execution raised an unexpected error. Retry or report this error.",
+        )
+
+    return _normalize_tool_success(value)
+
+
+class ToolResultWrapperToolset[DepsType](WrapperToolset[DepsType]):
+    def __getattr__(self, name: str) -> object:
+        return getattr(self.wrapped, name)
+
+    async def call_tool(
+        self,
+        name: str,
+        tool_args: dict[str, Any],
+        ctx: RunContext[DepsType],
+        tool: ToolsetTool[DepsType],
+    ) -> ToolResult[JsonableValue]:
+        run_context = ctx
+
+        async def tool_call() -> object:
+            return await self.wrapped.call_tool(name, tool_args, run_context, tool)
+
+        return await _run_tool_and_normalize(tool_call)

nighthawk/tools/provided.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic_ai import RunContext
+from pydantic_ai.tools import Tool
+
+from ..runtime.step_context import StepContext
+from .assignment import assign_tool, eval_expression
+from .contracts import ToolBoundaryError
+
+
+@dataclass(frozen=True)
+class ProvidedToolDefinition:
+    name: str
+    tool: Tool[StepContext]
+
+
+def _eval_expression_or_raise(run_context: RunContext[StepContext], expression: str) -> object:
+    try:
+        return eval_expression(run_context.deps, expression)
+    except Exception as exception:
+        raise ToolBoundaryError(kind="execution", message=str(exception), guidance="Fix the expression and retry.") from exception
+
+
+def build_provided_tool_definitions() -> list[ProvidedToolDefinition]:
+    metadata = {"nighthawk.provided": True}
+
+    def nh_assign(
+        run_context: RunContext[StepContext],
+        target_path: str,
+        expression: str,
+    ) -> dict[str, Any]:
+        return assign_tool(
+            run_context.deps,
+            target_path,
+            expression,
+        )
+
+    def nh_eval(run_context: RunContext[StepContext], expression: str) -> object:
+        return _eval_expression_or_raise(run_context, expression)
+
+    # nh_exec intentionally shares the same implementation as nh_eval.
+    # Both use Python eval(); the two-tool split exists purely as a semantic
+    # signal to the LLM (inspect vs mutate intent), not a runtime distinction.
+    # If future requirements demand runtime differentiation (e.g., read-only
+    # enforcement for nh_eval), the split provides the structural hook for it.
+    def nh_exec(run_context: RunContext[StepContext], expression: str) -> object:
+        return _eval_expression_or_raise(run_context, expression)
+
+    return [
+        ProvidedToolDefinition(
+            name="nh_assign",
+            tool=Tool(
+                nh_assign,
+                name="nh_assign",
+                metadata=metadata,
+                description="Rebind a name or set a nested field to a new value. target_path format: name(.field)*.",
+            ),
+        ),
+        ProvidedToolDefinition(
+            name="nh_eval",
+            tool=Tool(
+                nh_eval,
+                name="nh_eval",
+                metadata=metadata,
+                description="Evaluate a Python expression and return the result.",
+            ),
+        ),
+        ProvidedToolDefinition(
+            name="nh_exec",
+            tool=Tool(
+                nh_exec,
+                name="nh_exec",
+                metadata=metadata,
+                description="Execute a Python expression for its side effect (e.g., list.append(), dict.update()). Returns the expression result.",
+            ),
+        ),
+    ]

nighthawk/tools/registry.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any, overload
+
+from pydantic_ai.tools import Tool
+
+from ..errors import ToolRegistrationError
+from ..runtime.step_context import StepContext
+from .provided import build_provided_tool_definitions
+
+
+@dataclass(frozen=True)
+class ToolDefinition:
+    name: str
+    tool: Tool[StepContext]
+
+
+_builtin_tool_name_to_definition: dict[str, ToolDefinition] = {}
+_builtin_tools_registered = False
+
+_global_tool_name_to_definition: dict[str, ToolDefinition] = {}
+
+_tool_scope_stack_var: ContextVar[tuple[dict[str, ToolDefinition], ...]] = ContextVar(
+    "nighthawk_tool_scope_stack",
+    default=(),
+)
+
+_call_scope_stack_var: ContextVar[tuple[dict[str, ToolDefinition], ...]] = ContextVar(
+    "nighthawk_call_tool_scope_stack",
+    default=(),
+)
+
+_VALID_NAME_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _validate_tool_name(name: str) -> None:
+    try:
+        name.encode("ascii")
+    except UnicodeEncodeError as e:
+        raise ToolRegistrationError(f"Tool name must be ASCII: {name!r}") from e
+
+    if not _VALID_NAME_PATTERN.fullmatch(name):
+        raise ToolRegistrationError(f"Tool name must match ^[A-Za-z_][A-Za-z0-9_]*$: {name!r}")
+
+
+def ensure_builtin_tools_registered() -> None:
+    global _builtin_tools_registered
+
+    if _builtin_tools_registered:
+        return
+
+    for builtin_definition in build_provided_tool_definitions():
+        _validate_tool_name(builtin_definition.name)
+        if builtin_definition.name in _builtin_tool_name_to_definition:
+            raise ToolRegistrationError(f"Duplicate builtin tool name: {builtin_definition.name!r}")
+        _builtin_tool_name_to_definition[builtin_definition.name] = ToolDefinition(
+            name=builtin_definition.name,
+            tool=builtin_definition.tool,
+        )
+
+    _builtin_tools_registered = True
+
+
+def _visible_tool_definitions() -> dict[str, ToolDefinition]:
+    ensure_builtin_tools_registered()
+
+    merged: dict[str, ToolDefinition] = dict(_builtin_tool_name_to_definition)
+    merged.update(_global_tool_name_to_definition)
+
+    for scope in _tool_scope_stack_var.get():
+        merged.update(scope)
+
+    for scope in _call_scope_stack_var.get():
+        merged.update(scope)
+
+    return merged
+
+
+def _register_tool_definition(tool_definition: ToolDefinition, *, overwrite: bool) -> None:
+    ensure_builtin_tools_registered()
+
+    name = tool_definition.name
+    visible = _visible_tool_definitions()
+
+    if name in visible and not overwrite:
+        raise ToolRegistrationError(f"Tool name conflict: {name!r}. Pass overwrite=True to replace the visible definition.")
+
+    call_scope_stack = _call_scope_stack_var.get()
+    if call_scope_stack:
+        call_scope_stack[-1][name] = tool_definition
+        return
+
+    tool_scope_stack = _tool_scope_stack_var.get()
+    if tool_scope_stack:
+        tool_scope_stack[-1][name] = tool_definition
+        return
+
+    _global_tool_name_to_definition[name] = tool_definition
+
+
+@contextmanager
+def tool_scope() -> Iterator[None]:
+    current = _tool_scope_stack_var.get()
+    token = _tool_scope_stack_var.set((*current, {}))
+    try:
+        yield
+    finally:
+        _tool_scope_stack_var.reset(token)
+
+
+@contextmanager
+def call_scope() -> Iterator[None]:
+    current = _call_scope_stack_var.get()
+    token = _call_scope_stack_var.set((*current, {}))
+    try:
+        yield
+    finally:
+        _call_scope_stack_var.reset(token)
+
+
+def get_visible_tools() -> list[Tool[StepContext]]:
+    ensure_builtin_tools_registered()
+    visible = dict(_visible_tool_definitions())
+    return [definition.tool for definition in visible.values()]
+
+
+type ToolFunction = Callable[..., Any]
+
+
+@overload
+def tool(func: ToolFunction, /) -> ToolFunction: ...
+
+
+@overload
+def tool(
+    func: None = None,
+    /,
+    *,
+    name: str | None = None,
+    overwrite: bool = False,
+    description: str | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> Callable[[ToolFunction], ToolFunction]: ...
+
+
+def tool(
+    func: ToolFunction | None = None,
+    /,
+    *,
+    name: str | None = None,
+    overwrite: bool = False,
+    description: str | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> ToolFunction | Callable[[ToolFunction], ToolFunction]:
+    """Register a Python function as a Nighthawk tool visible to Natural blocks.
+
+    Args:
+        func: The function to register. Can be omitted for use as a bare decorator.
+        name: Tool name override. Defaults to the function name.
+        overwrite: If True, replace any existing tool with the same name.
+        description: Tool description override. Defaults to the function docstring.
+        metadata: Arbitrary metadata attached to the tool definition.
+
+    Raises:
+        ToolRegistrationError: If the name conflicts with an existing tool and
+            overwrite is False.
+
+    Example:
+        ```python
+        @nighthawk.tool
+        def lookup_user(user_id: str) -> dict:
+            return {"user_id": user_id, "name": "Alice"}
+        ```
+    """
+
+    def decorator(inner: ToolFunction) -> ToolFunction:
+        ensure_builtin_tools_registered()
+
+        tool_name = name or inner.__name__
+        _validate_tool_name(tool_name)
+
+        resolved_description = description
+        if resolved_description is None:
+            resolved_description = inner.__doc__
+
+        tool_object: Tool[StepContext] = Tool(
+            inner,
+            name=tool_name,
+            description=resolved_description,
+            metadata=metadata,
+        )
+
+        tool_definition = ToolDefinition(name=tool_name, tool=tool_object)
+        _register_tool_definition(tool_definition, overwrite=overwrite)
+        return inner
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+def _reset_all_tools_for_tests() -> None:
+    global _builtin_tools_registered
+    _global_tool_name_to_definition.clear()
+    _builtin_tool_name_to_definition.clear()
+    _builtin_tools_registered = False

nighthawk_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: nighthawk-python
+Version: 0.1.0
+Summary: An experimental Python library that embeds Natural blocks inside Python functions and executes them using an LLM.
+Project-URL: Repository, https://github.com/kurusugawa-computer/nighthawk-python
+Project-URL: Documentation, https://kurusugawa-computer.github.io/nighthawk-python/
+Project-URL: Bug Tracker, https://github.com/kurusugawa-computer/nighthawk-python/issues
+Author-email: "Kurusugawa Computer Inc." <oss@kurusugawa.jp>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: embedded-dsl,interoperability,llm,natural-language,pydantic-ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: headson>=0.16.1
+Requires-Dist: pydantic-ai-slim>=1.59
+Requires-Dist: pydantic>=2
+Requires-Dist: pyyaml>=6
+Requires-Dist: tiktoken>=0.12
+Provides-Extra: claude-code-cli
+Requires-Dist: mcp>=1.26; extra == 'claude-code-cli'
+Provides-Extra: claude-code-sdk
+Requires-Dist: claude-agent-sdk>=0.1; extra == 'claude-code-sdk'
+Provides-Extra: codex
+Requires-Dist: mcp>=1.26; extra == 'codex'
+Description-Content-Type: text/markdown
+
+[![PyPI](https://img.shields.io/pypi/v/nighthawk-python)](https://pypi.org/project/nighthawk-python)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/nighthawk-python)
+[![license](https://img.shields.io/github/license/psg-mit/nighthawk-python.svg)](https://github.com/kurusugawa-computer/nighthawk-python/tree/main/LICENSE)
+[![issue resolution](https://img.shields.io/github/issues-closed-raw/kurusugawa-computer/nighthawk-python)](https://github.com/kurusugawa-computer/nighthawk-python/issues)
+
+# Nighthawk
+
+<div align="center">
+<img src="https://github.com/kurusugawa-computer/nighthawk-python/raw/main/docs/assets/nighthawk_logo-128x128.png" alt="nighthawk-logo" width="128px" margin="10px"></img>
+</div>
+
+Nighthawk is an experimental Python library exploring a clear separation between **hard control** (Python code) for strict procedure and deterministic flow, and **soft reasoning** (an LLM) for semantic interpretation inside small embedded "Natural blocks". It is a compact reimplementation of the core ideas of [Nightjar](https://github.com/psg-mit/nightjarpy).
+
+## Quickstart
+
+Prerequisites: Python 3.13+
+
+Install Nighthawk and a provider:
+
+```bash
+pip install nighthawk-python pydantic-ai-slim[openai]
+```
+
+Save as `quickstart.py`:
+
+```py
+import nighthawk as nh
+
+step_executor = nh.AgentStepExecutor.from_configuration(
+    configuration=nh.StepExecutorConfiguration(model="openai-responses:gpt-5-mini")
+)
+
+with nh.run(step_executor):
+
+    @nh.natural_function
+    def calculate_total(items: str) -> int:
+        total = 0
+        """natural
+        Read <items> and set <:total> to the sum of all quantities mentioned.
+        """
+        return total
+
+    print(calculate_total("three apples, a dozen eggs, and 5 oranges"))
+```
+
+Run with your API key:
+
+```bash
+export OPENAI_API_KEY=sk-xxxxxxxxx
+python quickstart.py
+# => 20
+```
+
+For backends, credentials, model identifiers, and detailed guidance, see the [documentation site](https://kurusugawa-computer.github.io/nighthawk-python/).
+
+## Development
+
+Run tests:
+
+```bash
+uv run pytest -q
+```
+
+Run an OTel collector UI (otel-tui) for observability:
+
+```bash
+docker run --rm -it -p 4318:4318 --name otel-tui ymtdzzz/otel-tui:latest
+```
+
+Then run integration tests with `OTEL_EXPORTER_OTLP_ENDPOINT` set:
+
+```bash
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 uv run pytest -q tests/integration/test_llm_integration.py
+```
+
+## References
+
+- Nightjar (upstream concept): https://github.com/psg-mit/nightjarpy

nighthawk_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+nighthawk/__init__.py,sha256=4Yt9le9-Nh0xZ9Ty9t5XNZY8_KBTUZtKz7zBe8UadHA,1296
+nighthawk/configuration.py,sha256=igHa9H1eaHT4D8jtpd1i28O3f_CRc8zkwtxQ93WsQyY,7241
+nighthawk/errors.py,sha256=CSw_VfIoppCE2SdN2zMtVbMGu_wFwD628v8ZAVxeHIY,602
+nighthawk/identifier_path.py,sha256=Io3VcT8BlxAASHQUSUclrRcCwnRKTtMDPSR1bpaDN6s,984
+nighthawk/json_renderer.py,sha256=ixpUYTsVVKOp-iMdHldw7-6I3JxelXOQD8vK2KVXwbw,7640
+nighthawk/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nighthawk/backends/base.py,sha256=HicDmOFN_CChCDs532dHtiGAiw1wKOsWCx0185u1Dz8,3869
+nighthawk/backends/claude_code_cli.py,sha256=g1Jy1JtBaETyL1lMSSUfwwnPV_ojJTCokdVlG8EQn5A,14436
+nighthawk/backends/claude_code_sdk.py,sha256=-EtGp5J5x8wncWaPJ-REBvtZVfsKQpYv5-F9lTGN-ck,13176
+nighthawk/backends/codex.py,sha256=nSRt6gsssGi-xQ9tD7xvkC8aYH98itYzhIbw4K0Klis,14739
+nighthawk/backends/mcp_boundary.py,sha256=DjBgYI32bRne3d91XxSV56xBrxOjcnJi2nyxGcy613E,4186
+nighthawk/backends/mcp_server.py,sha256=Vw1iRRhrMgFlX5umSLIc0XGlRAljOm9xqoTYBNpbjxI,8142
+nighthawk/backends/tool_bridge.py,sha256=yv4WbxT7OQQaR3OsHuNIPfKhNjsaIIfRFbqv2hNtMro,9288
+nighthawk/natural/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nighthawk/natural/blocks.py,sha256=U6VhskMuEVUdWiPqFUBavFlvHgDkDbCYOKeQpdXxXMY,9717
+nighthawk/natural/decorator.py,sha256=3bx4PQ85Odh5sN3_S3N9wNdDmFUWxUgzF_YbfpNS-LM,11134
+nighthawk/natural/transform.py,sha256=_Uctcz65kI7yN_uuWmG-qIujQzgd7sqq-IGdlzEAopg,14950
+nighthawk/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nighthawk/runtime/async_bridge.py,sha256=k1s7e5dJEMNZJd0xHqkqAY7VkE7tOBzJf6nAEJH_Xh0,1478
+nighthawk/runtime/prompt.py,sha256=Q5IfNCj0II415uevGkNJyRZPvEBz16_BRk6KMIxOve4,12254
+nighthawk/runtime/runner.py,sha256=B20ZHt4DCvqsYwicVsKPc9cmitcNUMIzW1zzYRfLwgY,17946
+nighthawk/runtime/scoping.py,sha256=yKYjgSXRp4kXvmOE3ai34_dbAkFhc1VGbwyvri81BmU,9474
+nighthawk/runtime/step_context.py,sha256=CPfCOOc1KWvF_9nzmKOmm2NssL5-FXoDhzI4iWwcomg,5489
+nighthawk/runtime/step_contract.py,sha256=DFKH8wuEA6ZY9MKHw6lwQhD6-cgq6sJAjUBSfOw1_-Y,7312
+nighthawk/runtime/step_executor.py,sha256=7b9mYA-NqkR9CXNyHbZWCYb1q6k8cr_UXoy0CyhZXVY,13028
+nighthawk/runtime/tool_calls.py,sha256=Hepb71WF_k51_PSnXtyiAoSm53kDBbqLsqd7Lh-5nWE,3056
+nighthawk/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nighthawk/tools/assignment.py,sha256=Mh-WLK7U5pE3IBoyzXVJfFW5SdAxqUL0O1NSFkiX4ds,8823
+nighthawk/tools/contracts.py,sha256=lLfBue1VF8NMd76GMIp6y71cCx1p4MlVQyNhd4Ju2qk,2096
+nighthawk/tools/execution.py,sha256=e1uv09MWOkCoZ5uQu9myUXyhQzM_UziR9yE0raFYtQI,2740
+nighthawk/tools/provided.py,sha256=6vIBnT33m0KUNQ40xgnhm52wAtV1afPEYVrgIc-ZiUk,2773
+nighthawk/tools/registry.py,sha256=9obdHJmocr9b_DGBVzq8unDQA1jy-OfMWRky0UGsLQA,6141
+nighthawk_python-0.1.0.dist-info/METADATA,sha256=K2XHWwrdiSZ_aVssgQdKLWaTjoPuXqIRYJko4AtK3R4,3967
+nighthawk_python-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+nighthawk_python-0.1.0.dist-info/licenses/LICENSE,sha256=R8tjrX79o5Pbi_l_aFPPWDbTZkmz4is0CxmzMMs3f0A,1076
+nighthawk_python-0.1.0.dist-info/RECORD,,

nighthawk_python-0.1.0.dist-info/WHEEL

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

nighthawk_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright 2026 Kurusugawa Computer Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.