opentool-python 0.1.0__py3-none-any.whl

opentool_python/server/opentool_server.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+import json
+import threading
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+from urllib.parse import urlparse
+
+from ..dto import (
+    CLI_ARGUMENT_APIKEYS,
+    CLI_ARGUMENT_HOST,
+    CLI_ARGUMENT_PORT,
+    CLI_ARGUMENT_TAG,
+    DEFAULT_PREFIX,
+    DEFAULT_TOOL_HOST,
+    DEFAULT_TOOL_PORT,
+    DEFAULT_TOOL_TAG,
+    JSONRPC_VERSION,
+    LOAD_METADATA_NOT_FOUND_CODE,
+    LOAD_METADATA_NOT_FOUND_MESSAGE,
+    JsonRPCHttpRequestBody,
+    JsonRPCHttpResponseBody,
+    JsonRPCHttpResponseBodyError,
+    StatusInfo,
+    StatusType,
+    Version,
+)
+from ..tool.model import EventType
+from .cli_arguments import CliArguments
+from .cli_tool import CliTool
+from .exceptions import InvalidJsonPayloadException, JsonParseException, ServerException
+
+
+class Server(ABC):
+    def __init__(self, cli_tool: CliTool) -> None:
+        self.cli_tool = cli_tool
+
+    @abstractmethod
+    def start(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def stop(self) -> None:
+        raise NotImplementedError
+
+
+class OpenToolServer(Server):
+    def __init__(self, cli_tool: CliTool, cli_arguments: CliArguments | None = None) -> None:
+        super().__init__(cli_tool=cli_tool)
+        self.cli_arguments = cli_arguments
+        self.version = DEFAULT_TOOL_TAG
+        self.host = DEFAULT_TOOL_HOST
+        self.port = DEFAULT_TOOL_PORT
+        self.prefix = DEFAULT_PREFIX
+        self.api_keys: list[str] = []
+        self._server: ThreadingHTTPServer | None = None
+
+    def init_cli(self) -> None:
+        cli_args = self.cli_arguments.parse() if self.cli_arguments else {}
+        cli_args = self.cli_tool.init_args(cli_args) or cli_args
+
+        self.version = str(cli_args.get(CLI_ARGUMENT_TAG, DEFAULT_TOOL_TAG))
+        self.host = str(cli_args.get(CLI_ARGUMENT_HOST, DEFAULT_TOOL_HOST))
+
+        raw_port = cli_args.get(CLI_ARGUMENT_PORT)
+        if raw_port is not None:
+            self.port = int(raw_port)
+
+        api_keys = cli_args.get(CLI_ARGUMENT_APIKEYS)
+        self.api_keys = list(api_keys) if isinstance(api_keys, list) else []
+
+    def start(self) -> None:
+        self.init_cli()
+        self.cli_tool.init()
+
+        server = self
+
+        class Handler(BaseHTTPRequestHandler):
+            protocol_version = "HTTP/1.1"
+
+            def log_message(self, fmt: str, *args: Any) -> None:
+                return None
+
+            def do_GET(self) -> None:  # noqa: N802
+                if not self._authorize():
+                    return
+                path = self._path_without_query()
+                if path == f"{server.prefix}/version":
+                    self._respond_json(HTTPStatus.OK, Version(version=server.version).to_json())
+                    return
+                if path == f"{server.prefix}/load":
+                    try:
+                        open_tool = server.cli_tool.load()
+                        if open_tool is None:
+                            self._respond_json(
+                                HTTPStatus.NOT_FOUND,
+                                {"code": LOAD_METADATA_NOT_FOUND_CODE, "message": LOAD_METADATA_NOT_FOUND_MESSAGE},
+                            )
+                        else:
+                            self._respond_json(HTTPStatus.OK, open_tool.to_json())
+                    except Exception as exc:
+                        self._respond_json(
+                            HTTPStatus.INTERNAL_SERVER_ERROR,
+                            {"error": str(exc)},
+                        )
+                    return
+                self._respond_json(HTTPStatus.NOT_FOUND, {"error": "Not found"})
+
+            def do_POST(self) -> None:  # noqa: N802
+                if not self._authorize():
+                    return
+                path = self._path_without_query()
+                if path == f"{server.prefix}/call":
+                    self._handle_call()
+                    return
+                if path == f"{server.prefix}/streamCall":
+                    self._handle_stream_call()
+                    return
+                if path == f"{server.prefix}/stop":
+                    self._handle_stop()
+                    return
+                self._respond_json(HTTPStatus.NOT_FOUND, {"error": "Not found"})
+
+            def _handle_call(self) -> None:
+                payload_result = self._read_json_payload()
+                if isinstance(payload_result, tuple):
+                    self._respond_json(payload_result[0], payload_result[1])
+                    return
+
+                payload = payload_result
+                try:
+                    body = JsonRPCHttpRequestBody.from_json(payload)
+                except Exception as exc:
+                    self._respond_json(
+                        HTTPStatus.BAD_REQUEST,
+                        _json_parse_error_response(
+                            JsonParseException(message=str(exc)),
+                            id=str(payload.get("id", "")),
+                        ),
+                    )
+                    return
+
+                try:
+                    result = server.cli_tool.call(body.method, body.params)
+                    response_body = JsonRPCHttpResponseBody(result=result, id=body.id)
+                    self._respond_json(HTTPStatus.OK, response_body.to_json())
+                except Exception as exc:
+                    response_body = JsonRPCHttpResponseBody(
+                        result={},
+                        id=body.id,
+                        error=JsonRPCHttpResponseBodyError(code=500, message=str(exc)),
+                    )
+                    self._respond_json(HTTPStatus.OK, response_body.to_json())
+
+            def _handle_stream_call(self) -> None:
+                payload_result = self._read_json_payload()
+                if isinstance(payload_result, tuple):
+                    self._respond_json(payload_result[0], payload_result[1])
+                    return
+
+                payload = payload_result
+                try:
+                    body = JsonRPCHttpRequestBody.from_json(payload)
+                except Exception as exc:
+                    self._respond_json(
+                        HTTPStatus.BAD_REQUEST,
+                        _json_parse_error_response(JsonParseException(message=str(exc))),
+                    )
+                    return
+
+                self.send_response(HTTPStatus.OK)
+                self.send_header("Content-Type", "text/event-stream")
+                self.send_header("Cache-Control", "no-cache, no-store")
+                self.send_header("Connection", "close")
+                self.end_headers()
+
+                self._push_data(EventType.START, json.dumps({EventType.START: body.method}))
+
+                failed = False
+                try:
+                    def send_event(event: str, data: dict[str, Any]) -> None:
+                        nonlocal failed
+                        if failed:
+                            return
+                        if event == EventType.DATA:
+                            response_body = JsonRPCHttpResponseBody(result=data, id=body.id)
+                            self._push_data(event, json.dumps(response_body.to_json()))
+                        elif event == EventType.ERROR:
+                            error = JsonRPCHttpResponseBodyError(
+                                code=int(data.get("code", 500)),
+                                message=str(data.get("message", data)),
+                            )
+                            response_body = JsonRPCHttpResponseBody(result={}, id=body.id, error=error)
+                            self._push_data(event, json.dumps(response_body.to_json()))
+                            failed = True
+
+                    server.cli_tool.stream_call(body.method, body.params, send_event)
+                except (BrokenPipeError, ConnectionResetError):
+                    return
+                except Exception as exc:
+                    if not failed:
+                        self._push_data(
+                            EventType.ERROR,
+                            json.dumps({"code": 500, "message": str(exc), "id": body.id}),
+                        )
+                else:
+                    if not failed:
+                        self._push_data(EventType.DONE, json.dumps({EventType.DONE: body.method}))
+
+            def _handle_stop(self) -> None:
+                try:
+                    server.cli_tool.dispose()
+                    self._respond_json(HTTPStatus.OK, StatusInfo(status=StatusType.STOPPED).to_json())
+
+                    def shutdown_async() -> None:
+                        server.stop()
+
+                    threading.Thread(target=shutdown_async, daemon=True).start()
+                except Exception as exc:
+                    self._respond_json(
+                        HTTPStatus.INTERNAL_SERVER_ERROR,
+                        {"error": str(exc)},
+                    )
+
+            def _read_json_payload(self) -> dict[str, Any] | tuple[int, dict[str, Any]]:
+                content_type = self.headers.get("Content-Type", "")
+                if "application/json" not in content_type:
+                    return HTTPStatus.BAD_REQUEST, {"error": "Content-Type must be application/json"}
+
+                content_length = int(self.headers.get("Content-Length", "0"))
+                body = self.rfile.read(content_length).decode("utf-8") if content_length > 0 else ""
+
+                try:
+                    payload = json.loads(body)
+                except json.JSONDecodeError as exc:
+                    return (
+                        HTTPStatus.BAD_REQUEST,
+                        _json_parse_error_response(JsonParseException(message=str(exc))),
+                    )
+
+                if not isinstance(payload, dict):
+                    return (
+                        HTTPStatus.BAD_REQUEST,
+                        _json_parse_error_response(InvalidJsonPayloadException()),
+                    )
+                return payload
+
+            def _path_without_query(self) -> str:
+                return urlparse(self.path).path
+
+            def _authorize(self) -> bool:
+                if not server.api_keys:
+                    return True
+                authorization = self.headers.get("Authorization")
+                token_prefix = "Bearer "
+                if authorization is None or not authorization.startswith(token_prefix):
+                    self._respond_text(HTTPStatus.UNAUTHORIZED, "Missing or malformed authorization header")
+                    return False
+                token = authorization[len(token_prefix) :]
+                if token not in server.api_keys:
+                    self._respond_text(HTTPStatus.UNAUTHORIZED, "Invalid authorization token")
+                    return False
+                return True
+
+            def _respond_json(self, status: int, body: dict[str, Any]) -> None:
+                payload = json.dumps(body).encode("utf-8")
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Cache-Control", "no-cache")
+                self.send_header("Connection", "keep-alive")
+                self.send_header("Content-Length", str(len(payload)))
+                self.end_headers()
+                self.wfile.write(payload)
+
+            def _respond_text(self, status: int, body: str) -> None:
+                payload = body.encode("utf-8")
+                self.send_response(status)
+                self.send_header("Content-Type", "text/plain; charset=utf-8")
+                self.send_header("Content-Length", str(len(payload)))
+                self.end_headers()
+                self.wfile.write(payload)
+
+            def _push_data(self, event_type: str, data_string: str) -> None:
+                payload = f"event:{event_type}\\ndata:{data_string}\\n\\n".encode("utf-8")
+                self.wfile.write(payload)
+                self.wfile.flush()
+
+        self._server = ThreadingHTTPServer((self.host, self.port), Handler)
+        print(f"Start Server: http://{self.host}:{self.port}{self.prefix}")
+        self._server.serve_forever(poll_interval=0.1)
+
+    def stop(self) -> None:
+        server = self._server
+        if server is None:
+            return
+        server.shutdown()
+        server.server_close()
+        self._server = None
+
+
+def _json_parse_error_response(exception: ServerException, id: str | None = None) -> dict[str, Any]:
+    return {
+        "jsonrpc": JSONRPC_VERSION,
+        "result": {},
+        "error": exception.to_json(),
+        "id": id,
+    }

opentool_python/tool/__init__.py

@@ -0,0 +1,18 @@
+from .exceptions import (
+    FunctionNotSupportedException,
+    InvalidArgumentsException,
+    JsonParserException,
+    ToolBreakException,
+)
+from .model import Event, EventType
+from .tool import Tool
+
+__all__ = [
+    "Tool",
+    "Event",
+    "EventType",
+    "FunctionNotSupportedException",
+    "InvalidArgumentsException",
+    "ToolBreakException",
+    "JsonParserException",
+]

opentool_python/tool/exceptions.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class FunctionNotSupportedException(Exception):
+    function_name: str
+    code: int = 405
+
+    @property
+    def message(self) -> str:
+        return f"Function Not Supported: {self.function_name}"
+
+    def to_json(self) -> dict[str, Any]:
+        return {"code": self.code, "message": self.message}
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_json(), ensure_ascii=False)
+
+
+@dataclass
+class InvalidArgumentsException(Exception):
+    arguments: dict[str, Any] | None
+    code: int = 400
+
+    @property
+    def message(self) -> str:
+        return f"Invalid Arguments: {json.dumps(self.arguments, ensure_ascii=False)}"
+
+    def to_json(self) -> dict[str, Any]:
+        return {"code": self.code, "message": self.message}
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_json(), ensure_ascii=False)
+
+
+@dataclass
+class ToolBreakException(Exception):
+    message: str | None
+    code: int = 500
+
+    def to_json(self) -> dict[str, Any]:
+        return {"code": self.code, "message": self.message}
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_json(), ensure_ascii=False)
+
+
+@dataclass
+class JsonParserException(Exception):
+    code: int = 404
+    message: str = "Json Parser NOT implement"
+
+    def to_json(self) -> dict[str, Any]:
+        return {"code": self.code, "message": self.message}
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_json(), ensure_ascii=False)

opentool_python/tool/model.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+class EventType:
+    START = "start"
+    DATA = "data"
+    ERROR = "error"
+    DONE = "done"
+
+
+@dataclass
+class Event:
+    name: str
+    data: dict[str, Any]
+
+    @classmethod
+    def from_json(cls, payload: dict[str, Any]) -> "Event":
+        return cls(name=str(payload["name"]), data=payload.get("data") or {})
+
+    def to_json(self) -> dict[str, Any]:
+        return {"name": self.name, "data": self.data}

opentool_python/tool/tool.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import Any
+
+from ..model.opentool import OpenTool
+
+
+class Tool(ABC):
+    def init(self) -> None:
+        return None
+
+    @abstractmethod
+    def call(self, name: str, arguments: dict[str, Any] | None) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def stream_call(
+        self,
+        name: str,
+        arguments: dict[str, Any] | None,
+        on_event: Callable[[str, dict[str, Any]], None],
+    ) -> None:
+        return None
+
+    def load(self) -> OpenTool | None:
+        return None
+
+    def dispose(self) -> None:
+        return None

opentool_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: opentool-python
+Version: 0.1.0
+Summary: Python SDK for OpenTool-compatible clients and servers
+Author: OpenTool Hub
+License-Expression: MIT
+Project-URL: Repository, https://github.com/opentool-hub/opentool-python
+Project-URL: Issues, https://github.com/opentool-hub/opentool-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema[format]<5,>=4.22
+Requires-Dist: referencing<1,>=0.30
+Dynamic: license-file
+
+# OpenTool SDK for Python
+
+English | [中文](README-zh_CN.md)
+
+OpenTool SDK for Python provides the core building blocks to host or consume OpenTool-compatible tools in Python: an HTTP/JSON-RPC server runtime, an HTTP client with unary + SSE streaming calls, and a JSON schema loader. This project is designed to align with [opentool-dart](https://github.com/opentool-hub/opentool-dart) so multi-language SDK behavior stays consistent.
+
+## Library Entrypoints
+
+- `opentool_python.opentool_server` - server runtime, CLI argument helper, and Tool base class.
+- `opentool_python.opentool_client` - HTTP/JSON-RPC client plus DTO/LLM models.
+- `opentool_python.opentool_schema` - JSON specification models and loader.
+
+## Features
+
+- `OpenToolServer` mounts `/opentool` JSON-RPC endpoints backed by your `Tool` implementation, with optional Bearer API-key auth.
+- `OpenToolClient` supports version lookup, unary `call`, SSE `stream_call`, metadata `load`, and remote `stop`.
+- `OpenToolJsonLoader` parses OpenTool JSON specs and resolves `$ref` schema references.
+- End-to-end examples in `example/server.py` and `example/client.py` demonstrate CRUD + streaming usage.
+
+## Requirements
+
+- Python `>=3.10`
+- Schema validation uses `jsonschema` and `referencing`, installed with the SDK.
+
+## Installation
+
+Install from PyPI:
+
+```sh
+python -m pip install opentool-python
+```
+
+Install as editable package in local development:
+
+```sh
+pip install -e .
+```
+
+Or install with source path from another project:
+
+```sh
+pip install /absolute/path/to/opentool-python
+```
+
+## Quick Start
+
+### Implement a Tool
+
+```python
+from pathlib import Path
+from opentool_python.json_loader import OpenToolJsonLoader
+from opentool_python.opentool_server import (
+    CliTool,
+    EventType,
+    FunctionNotSupportedException,
+    OpenTool,
+)
+
+
+class MockTool(CliTool):
+    def call(self, name, arguments):
+        if name == "count":
+            return {"count": 1}
+        return FunctionNotSupportedException(function_name=name).to_json()
+
+    def stream_call(self, name, arguments, on_event):
+        if name == "sequentiallyRead":
+            on_event(EventType.DATA, {"data": "Hello"})
+        else:
+            on_event(
+                EventType.ERROR,
+                FunctionNotSupportedException(function_name=name).to_json(),
+            )
+
+    def load(self) -> OpenTool | None:
+        return OpenToolJsonLoader().load_from_file(
+            str(Path("example/mock_tool.json"))
+        )
+```
+
+### Launch the server
+
+```sh
+PYTHONPATH=src python example/server.py
+```
+
+`CliArguments` can pass built-in and custom CLI switches into your `CliTool.init_args`, so you can preload state before handlers accept requests.
+
+### Call the tool from Python
+
+```python
+from opentool_python.opentool_client import FunctionCall, HostType, OpenToolClient
+
+client = OpenToolClient(
+    tool_host=HostType.LOCALHOST,
+    tool_port=17002,
+    tool_api_key="your-key",
+)
+
+print(client.version().to_json())
+print(client.call(FunctionCall(id="call-0", name="count", arguments={})).to_json())
+
+client.stream_call(
+    FunctionCall(id="call-1", name="sequentiallyRead", arguments={}),
+    lambda event, tool_return: print(event, tool_return.result),
+)
+
+print(client.load().to_json())
+print(client.stop().to_json())
+```
+
+## CLI and HTTP Reference
+
+- Base path defaults to `/opentool`.
+- Endpoints:
+  - `GET /version`
+  - `POST /call`
+  - `POST /streamCall`
+  - `GET /load` returns HTTP 404 with code `TOOL_NOT_FOUND` when metadata is unavailable.
+  - `POST /stop`
+- Built-in CLI flags (via `CliArguments`):
+  - `--opentoolServerTag`
+  - `--opentoolServerHost`
+  - `--opentoolServerPort`
+  - repeatable `--opentoolServerApiKeys`
+- Streaming protocol is Server-Sent Events with event names `start`, `data`, `error`, and `done`.
+
+## JSON Specification Loader
+
+- Import `opentool_python.opentool_schema` if you only need spec models and parsing.
+- `OpenToolJsonLoader().load_from_file(path)` loads local files and resolves `$ref` entries under `#/schemas/*`.
+- `OpenToolJsonLoader().load(json_string)` loads from raw JSON strings.
+- Specification reference: [OpenTool Spec](https://github.com/opentool-hub/opentool-spec).
+
+Schemas default to JSON Schema Draft 2020-12. A recognized `$schema` selects its declared draft. `Schema.to_json()` returns a dictionary or boolean and preserves references, annotations, and extension keywords. Named `#/schemas/...` references are scoped to each OpenTool document, including documents loaded over HTTP.
+
+```python
+from opentool_python.opentool_schema import Schema
+
+schema = Schema.from_json({"type": "string", "minLength": 3})
+result = schema.validate("ab")
+print(result.is_valid, result.errors)
+```
+
+Use `validate_formats=True` to assert formats. To supply external schemas, pass a synchronous `schema_reference_resolver` callback to `OpenTool.from_json`, `OpenToolJsonLoader`, or `OpenToolClient`. The callback receives the resource URI and returns an object, a boolean, or `None` if unavailable.
+
+## Examples and Development
+
+- Example files:
+  - `example/server.py`
+  - `example/client.py`
+  - `example/mock_tool.json`
+- Common local workflow:
+
+```sh
+python -m compileall src example
+PYTHONPATH=src python example/server.py
+PYTHONPATH=src python example/client.py
+```
+
+## Compatibility Note
+
+This Python SDK is currently a baseline implementation focused on API shape and protocol compatibility with `opentool-dart`.

opentool_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+opentool_python/__init__.py,sha256=o6No_JnyXS_uji6WUfIAQL5fl5biCYcudoXh4EyewYw,1528
+opentool_python/dto.py,sha256=bfSkUaSDmckzPfLCjW6gFggzUx-GITVY4e-6h0lHQQ0,3547
+opentool_python/json_loader.py,sha256=7OWRgYSK-gX74HgRYi9iOJ0bgnn_6dYeT6Wqa9BjHZ8,827
+opentool_python/opentool_client.py,sha256=tpMBNmU-zY0TNSVF_D3BECFX7qzVlH-tvJghuXtT3C0,683
+opentool_python/opentool_schema.py,sha256=uWlwSAPNGt7AbBtKMgAzic85LRZ9ezqKmGQaJ0Cs9Rw,742
+opentool_python/opentool_server.py,sha256=2QAos7OsOxBsti9Wf2SDrkcZ6Rag23r33Gf7ZCjNh4c,478
+opentool_python/client/__init__.py,sha256=bJKMc95Eza--_rbFmtDC6aTq9Amvtl1hLZzECk1K3sU,465
+opentool_python/client/exceptions.py,sha256=0VfSsbfvZ-jaFR9R6CT8go-68TOptm-nqjgGq_Rzn1Y,1160
+opentool_python/client/opentool_client.py,sha256=etuAbifZGmN_1YBqvDyVwe37XctDDRnhzJVNzLre4Wc,8885
+opentool_python/llm/__init__.py,sha256=n0pyI255rPgtim_Tu5Ale0uOCSBa6R6UrSX1TZTWfSw,86
+opentool_python/llm/model.py,sha256=KI45fyu2rVzkr2sfA_6wWd3iUFkgWmz-jBDxYFdtlSA,852
+opentool_python/model/__init__.py,sha256=8KsoqayQiE13rb9mwL5cltMtwAb8swmyB9CGFZExX4I,577
+opentool_python/model/data_type.py,sha256=SQgw0ACF6oYB-NRGQ4SPGBnmVMPfdl6u3t7dYlsoZwA,174
+opentool_python/model/function_model.py,sha256=L3gY-d3FZ3sd_hTm0lEKSllidfKY_Ieglmy9J68ku1Q,2411
+opentool_python/model/info.py,sha256=0X_DdH7ObPAStsLDUOboEQDfKSmofqh0O6r3dz8lAtQ,659
+opentool_python/model/opentool.py,sha256=VK2Ddb1gF_W5NDrsjX5s7hrjtJA0G86dPOuuBkl1gHw,2121
+opentool_python/model/parameter.py,sha256=hS1Gi3_DOYimGQgbpgEYUS8wWvca9ylQmhC3sSSP05Y,1141
+opentool_python/model/return_model.py,sha256=HJ5xNUCnL98vOb18OlYI5Glx7VUBSzT-skdeB-TfjIo,799
+opentool_python/model/schema.py,sha256=iWh4XpRRpBLbCRRXeN3USCldzaj2io80K_sMIYCG94g,9525
+opentool_python/model/server.py,sha256=ghBNNa8rtN16N5ojJW6yqaJ4k1JpKrLS7SGyZ8DN99k,546
+opentool_python/server/__init__.py,sha256=1sMtmoPqqNyR2LLG4VNql65D-AxGiiBgDCnSeyg-JLA,189
+opentool_python/server/cli_arguments.py,sha256=FsM_bzjI0Z-jfJF5oGurjPz_qacw18316r1-1_7VJeU,1356
+opentool_python/server/cli_tool.py,sha256=veoJLpA0CXDuVwXSTL0QqeREOYCJCP-r_HSXQMsd4po,211
+opentool_python/server/exceptions.py,sha256=pcYmg7YmLapHIUvq1cvbgj-b70unOQAqyUJ-8J96ACg,719
+opentool_python/server/opentool_server.py,sha256=Oi5SiueRwTB8WjLjZc0awFfWkV6HonJyB5bfz3pyKdM,12698
+opentool_python/tool/__init__.py,sha256=jJV_WE3TjZP9AzeB7EPC2s1l6i4BXlWqclMIvp1sU_c,382
+opentool_python/tool/exceptions.py,sha256=LsiNkkq6nZhlDE6jhJJzN96TVOSBwuqgY9OvOQCqb9Q,1554
+opentool_python/tool/model.py,sha256=kkg0BCCPiBiubgjG-zzIysmuNUnK2O0bzDJvtcHRcpA,505
+opentool_python/tool/tool.py,sha256=Eym4TGbVuzxJQJqqaeQU7L41n55bTUNdKRpR1wG6UKg,677
+opentool_python-0.1.0.dist-info/licenses/LICENSE,sha256=gljelJoITV4eS5oP7Hbp9x4-JmznEJC0Le7Y5j4ecxM,1069
+opentool_python-0.1.0.dist-info/METADATA,sha256=WSwYa9F_iuOW-MqyYGRC77MW4nh3JpS6QFOheh2UnV4,6016
+opentool_python-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+opentool_python-0.1.0.dist-info/top_level.txt,sha256=IM2y5SZDYQ85hRxU3V_jiBOTnWzqwEV-8mXuO1ioVKM,16
+opentool_python-0.1.0.dist-info/RECORD,,

opentool_python-0.1.0.dist-info/WHEEL

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

opentool_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenTool Hub
+
+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.