ivcap_service 0.3.0__py3-none-any.whl

ivcap_service/__init__.py

@@ -0,0 +1,12 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+""" A library for building services for the IVCAP platform"""
+
+from .version import __version__
+from .logger import getLogger, logging_init
+from .service import start_batch_service
+from .service_definition import create_service_definition
+from .tool_definition import create_tool_definition, print_tool_definition

ivcap_service/ivcap.py

@@ -0,0 +1,145 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+from dataclasses import Field, dataclass
+import json
+import os
+import traceback
+from typing import Any, Callable, Generic, List, Optional, TypeVar, Union, BinaryIO
+
+from time import sleep
+from urllib.parse import urlparse, urlunparse
+import httpx
+from pydantic import BaseModel, HttpUrl
+from ivcap_fastapi import getLogger
+
+from .types import BinaryResult, ExecutionError, IvcapResult
+
+logger = getLogger("ivcap")
+
+# Number of attempt to deliver job result before giving up
+MAX_DELIVER_RESULT_ATTEMPTS = 4
+
+
+def verify_result(result: any, job_id: str, logger) -> any:
+    if isinstance(result, ExecutionError):
+        return result
+    if isinstance(result, BaseModel):
+        try:
+            return IvcapResult(
+                content=result.model_dump_json(by_alias=True),
+                content_type="application/json",
+                raw=result,
+            )
+        except Exception as ex:
+            msg = f"{job_id}: cannot json serialise pydantic isntance - {str(ex)}"
+            logger.warning(msg)
+            return ExecutionError(
+                error=msg,
+                type=type(ex).__name__,
+                traceback=traceback.format_exc()
+            )
+    if isinstance(result, BinaryResult):
+        return IvcapResult(content=result.content, content_type=result.content_type)
+    if isinstance(result, str):
+        return IvcapResult(content=result, content_type="text/plain", raw=result)
+    if isinstance(result, bytes):
+        # If it's a byte array, return it as is
+        return IvcapResult(
+            content=result,
+            content_type="application/octet-stream",
+            raw=result,
+        )
+    if isinstance(result, BinaryIO):
+        # If it's a file handler, return it as is
+        return IvcapResult(
+            content=result,
+            content_type="application/octet-stream",
+            raw=result
+        )
+    # normal model which should be serialisable
+    try:
+        result = IvcapResult(
+            content=json.dumps(result),
+            content_type="application/json"
+        )
+    except Exception as ex:
+        msg = f"{job_id}: cannot json serialise result - {str(ex)}"
+        logger.warning(msg)
+        result = ExecutionError(
+            error=msg,
+            type=type(ex).__name__,
+        )
+
+def push_result(result: Union[IvcapResult, ExecutionError], job_id: str, authorization: Optional[str]=None):
+    """Actively push result to sidecar, fail quietly."""
+    ivcap_url = get_ivcap_url()
+    if ivcap_url is None:
+        logger.warning(f"{job_id}: no ivcap url found - cannot push result")
+        return
+    url = urlunparse(ivcap_url._replace(path=f"/results/{job_id}"))
+
+    content_type="text/plain"
+    content="SOMETHING WENT WRONG _ PLEASE REPORT THIS ERROR"
+    is_error = False
+    if not (isinstance(result, ExecutionError) or isinstance(result, IvcapResult)):
+        msg = f"{job_id}: expected 'IvcapResult' or 'ExecutionError' but got {type(result)}"
+        logger.warning(msg)
+        result = ExecutionError(
+            error=msg,
+            type='InternalError',
+        )
+
+    if isinstance(result, IvcapResult):
+        content = result.content
+        content_type = result.content_type
+    else:
+        is_error = True
+        if not isinstance(result, ExecutionError):
+            # this should never happen
+            logger.error(f"{job_id}: expected 'ExecutionError' but got {type(result)}")
+            result = ExecutionError(
+                error="please report unexpected internal error - expected 'ExecutionError' but got {type(result)}",
+                type="internal_error",
+            )
+        content = result.model_dump_json(by_alias=True)
+        content_type = "application/json"
+
+
+    wait_time = 1
+    attempt = 0
+    headers = {
+        "Content-Type": content_type,
+        "Is-Error": str(is_error),
+    }
+    if not (authorization == None or authorization == ""):
+        headers["Authorization"] = authorization
+
+    while attempt < MAX_DELIVER_RESULT_ATTEMPTS:
+        try:
+            response = httpx.post(
+                url=url,
+                headers=headers,
+                data=content,
+            )
+            response.raise_for_status()
+            return
+        except Exception as e:
+            attempt += 1
+            logger.info(f"{job_id}: attempt #{attempt} failed to push result - will try again in {wait_time} sec - {type(e)}: {e}")
+            sleep(wait_time)
+            wait_time *= 2
+
+    logger.warning(f"{job_id}: giving up pushing result after {attempt} attempts")
+
+
+def get_ivcap_url() -> HttpUrl:
+    """
+    Returns the sidecar URL from the request headers.
+    """
+    base = os.getenv("IVCAP_BASE_URL")
+    if base == "" or base is None:
+        return None
+    return urlparse(base)

ivcap_service/logger.py

@@ -0,0 +1,27 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import json
+import logging
+from logging.config import dictConfig
+import os
+
+LOGGING_CONFIG={}
+
+def getLogger(name: str) -> logging.Logger:
+    return logging.getLogger(name)
+
+def service_log_config():
+    return LOGGING_CONFIG
+
+def logging_init(cfg_path: str=None):
+    if not cfg_path:
+        script_dir = os.path.dirname(__file__)
+        cfg_path = os.path.join(script_dir, "logging.json")
+
+    with open(cfg_path, 'r') as file:
+        global LOGGING_CONFIG
+        LOGGING_CONFIG = json.load(file)
+        dictConfig(LOGGING_CONFIG)

ivcap_service/logging.json

@@ -0,0 +1,46 @@
+{
+  "version": 1,
+  "formatters": {
+    "default": {
+      "format": "%(asctime)s %(levelname)s (%(name)s): %(message)s",
+      "datefmt": "%Y-%m-%dT%H:%M:%S%z"
+    },
+    "access": {
+      "()": "uvicorn.logging.AccessFormatter",
+      "fmt": "%(asctime)s %(levelname)s (access): \"%(request_line)s\" %(status_code)s",
+      "datefmt": "%Y-%m-%dT%H:%M:%S%z"
+    }
+  },
+  "handlers": {
+    "default": {
+      "class": "logging.StreamHandler",
+      "level": "DEBUG",
+      "formatter": "default",
+      "stream": "ext://sys.stderr"
+    },
+    "access": {
+      "formatter": "access",
+      "class": "logging.StreamHandler",
+      "stream": "ext://sys.stdout"
+    }
+  },
+  "root": {
+    "level": "INFO",
+    "handlers": [
+      "default"
+    ]
+  },
+  "loggers": {
+    "app": {
+      "level": "DEBUG"
+    },
+    "uvicorn.access": {
+      "handlers": [
+        "access"
+      ],
+      "level": "INFO",
+      "propagate": false
+    }
+  },
+  "disable_existing_loggers": false
+}

ivcap_service/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

ivcap_service/service.py

@@ -0,0 +1,166 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+
+import time
+import traceback
+from typing import Callable
+import argparse
+from logging import Logger
+from typing import Any, Callable, Dict, Optional
+from urllib.parse import urlunparse
+
+import os
+import sys
+from pydantic import BaseModel
+import requests
+
+
+from .ivcap import get_ivcap_url, push_result, verify_result
+from .logger import getLogger
+from .types import ExecutionError
+from .utils import _get_function_return_type, _get_input_type, get_version
+from .tool_definition import print_tool_definition  # Import the requests library
+
+# Number of attempt to request a new job before giving up
+MAX_REQUEST_JOB_ATTEMPTS = 4
+
+def wait_for_work(worker_fn: Callable, input_model: type[BaseModel], output_model: type[BaseModel], logger: Logger):
+    ivcap_url = get_ivcap_url()
+    if ivcap_url is None:
+        logger.warning(f"no ivcap url found - cannot request work")
+        return
+    url = urlunparse(ivcap_url._replace(path=f"/next_job"))
+    logger.info(f"... checking for work at '{url}'")
+    try:
+
+        while True:
+            result = None
+            try:
+                response = fetch_job(url, logger)
+                job = response.json()
+                schema = job.get("$schema", "")
+                if schema.startswith("urn:ivcap:schema.service.batch.done"):
+                    logger.info("no more jobs - we are done")
+                    sys.exit(0)
+
+                job_id = job.get("id", "unknown_job_id")  # Provide a default value if "id" is missing
+                result = do_job(job, worker_fn, input_model, output_model, logger)
+                result = verify_result(result, job_id, logger)
+            except Exception as e:
+                result = ExecutionError(
+                    error=str(e),
+                    type=type(e).__name__,
+                    traceback=traceback.format_exc()
+                )
+                logger.warning(f"job {job_id} failed - {result.error}")
+            finally:
+                if result is not None:
+                    logger.info(f"job {job_id} finished, sending result message")
+                    push_result(result, job_id, None, logger)
+
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"Error during request: {e}")
+    except Exception as e:
+        logger.warning(f"Error processing job: {e}")
+
+def fetch_job(url: str, logger: Logger) -> Any:
+    wait_time = 1
+    attempt = 0
+    while attempt < MAX_REQUEST_JOB_ATTEMPTS:
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            return response
+        except Exception as e:
+            attempt += 1
+            logger.info(f"attempt #{attempt} failed to fetch new job - will try again in {wait_time} sec - {type(e)}: {e}")
+            time.sleep(wait_time)
+            wait_time *= 2
+    logger.info("cannot contact sidecar - bailing out")
+    sys.exit(255)
+
+def do_job(
+    job: Any,
+    worker_fn: Callable,
+    input_model: type[BaseModel],
+    output_model: type[BaseModel],
+    logger: Logger
+):
+    job_id = job.get("id", "unknown_job_id")  # Provide a default value if "id" is missing
+    ct = job["in-content-type"]
+    if ct != "application/json":
+        raise Exception(f"cannot handle content-type '{ct}'")
+    jc = job["in-content"]
+    mreq = input_model(**jc)
+    logger.info(f"{job_id}: calling worker with - {mreq}")
+    try:
+        resp = worker_fn(mreq)
+        logger.info(f"{job_id}: worker finished with - {resp}")
+        if type(resp) != output_model:
+            logger.warning(f"{job_id}: result is of type '{type(resp)}' but expected '{output_model}'")
+
+    except BaseException as ex:
+        logger.warning(f"{job_id}: failed - '{ex}'")
+        resp = ExecutionError(
+                        error=str(ex),
+                        type=type(ex).__name__,
+                        traceback=traceback.format_exc()
+                    )
+    return resp
+
+def start_batch_service(
+    title: str,
+    worker_fn: Callable,
+    *,
+    custom_args: Optional[Callable[[argparse.ArgumentParser], argparse.Namespace]] = None,
+    run_opts: Optional[Dict[str, Any]] = None,
+    with_telemetry: Optional[bool] = None,
+):
+    """A helper function to start a batch service
+
+    Args:
+        title (str): the tile
+        tool_fn (Callable[..., Any]): _description_
+        logger (Logger): _description_
+        custom_args (Optional[Callable[[argparse.ArgumentParser], argparse.Namespace]], optional): _description_. Defaults to None.
+        run_opts (Optional[Dict[str, Any]], optional): _description_. Defaults to None.
+        with_telemetry: (Optional[bool]): Instantiate or block use of OpenTelemetry tracing
+    """
+    logger = getLogger("server")
+
+    parser = argparse.ArgumentParser(description=title)
+    parser.add_argument('--with-telemetry', action="store_true", help='Initialise OpenTelemetry')
+    parser.add_argument('--print-service-description', action="store_true", help='Print service description to stdout')
+    parser.add_argument('--print-tool-description', action="store_true", help='Print tool description to stdout')
+    parser.add_argument('--test-file', type=str, help='path to job file for testing service')
+
+    if custom_args is not None:
+        args = custom_args(parser)
+    else:
+        args = parser.parse_args()
+
+    if args.print_service_description:
+        from .service_definition import print_batch_service_definition
+        print_batch_service_definition(worker_fn)
+        sys.exit(0)
+
+    if args.print_tool_description:
+        print_tool_definition(worker_fn)
+        sys.exit(0)
+
+    logger.info(f"{title} - {os.getenv('VERSION')} - v{get_version()}")
+
+    input_model, _ = _get_input_type(worker_fn)
+    output_model = _get_function_return_type(worker_fn)
+    # summary, description = (worker_fn.__doc__.lstrip() + "\n").split("\n", 1)
+
+    if args.test_file is not None:
+        from .testing import file_to_json
+        job = file_to_json(args.test_file)
+        resp = do_job(job, worker_fn, input_model, output_model, logger)
+        print(resp.model_dump_json(indent=2, by_alias=True))
+    else:
+        wait_for_work(worker_fn, input_model, output_model, logger)

ivcap_service/service_definition.py

@@ -0,0 +1,116 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+
+import os
+import sys
+from typing import Callable, Dict, List, Any, Optional
+from pydantic import BaseModel, Field
+
+from .utils import file_to_json
+from .tool_definition import SERVICE_ID_PLACEHOLDER
+from .logger import getLogger
+
+SERVICE_SCHEMA = "urn:ivcap:schema.service.2"
+BATCH_CONTROLLER_SCHEMA = "urn:ivcap:schema.service.batch.1"
+DEF_POLICY = "urn:ivcap:policy:ivcap.open.service"
+DEF_RESOURCE_FILE = "resources.json"
+
+IMAGE_PLACEHOLDER = "#DOCKER_IMG#"
+
+logger = getLogger("service-defintion")
+
+class ResourceRequirements(BaseModel):
+    cpu: str = Field(default="500m")
+    memory: str = Field(default="1Gi")
+    ephemeral_storage: Optional[str] = None # Field(default="1Gi")
+
+class Resources(BaseModel):
+    limits: ResourceRequirements = Field(default_factory=ResourceRequirements)
+    requests: ResourceRequirements = Field(default_factory=ResourceRequirements)
+
+class BatchController(BaseModel):
+    jschema: str = Field(default=BATCH_CONTROLLER_SCHEMA, alias="$schema")
+    image: str
+    command: List[str]
+    resources: Resources = Field(default_factory=Resources)
+
+class ServiceDefinition(BaseModel):
+    jschema: str = Field(default=SERVICE_SCHEMA, alias="$schema")
+    id: str = Field(alias="$id")
+    name: str
+    description: str
+    parameters: List[Any] = []
+    policy: str = Field(default=DEF_POLICY)
+    controller_schema: str = Field(default=BATCH_CONTROLLER_SCHEMA)
+    controller: Any
+
+def print_batch_service_definition(
+    fn: Callable[..., Any],
+    service_id: Optional[str] = None,
+    description: Optional[str] = None,
+):
+    sd = create_batch_service_definition(
+        fn,
+        service_id=service_id,
+        description=description,
+    )
+    print(sd.model_dump_json(indent=2, by_alias=True, exclude_none=True))
+
+def create_batch_service_definition(
+    fn: Callable[..., Any],
+    service_id: Optional[str] = None,
+    description: Optional[str] = None,
+) -> ServiceDefinition:
+    # controller
+    image = os.getenv("DOCKER_IMG", IMAGE_PLACEHOLDER)
+    service_file_name = fn.__code__.co_filename
+    service_dir = os.path.dirname(service_file_name)
+    service_file_name = os.path.basename(service_file_name)
+    command = ["python", f"/app/{service_file_name}"]
+
+    using_def_resource_file = False
+    resource_file = os.getenv("IVCAP_RESOURCES_FILE")
+    if resource_file == None:
+        using_def_resource_file = True
+        resource_file = os.path.join(service_dir, DEF_RESOURCE_FILE)
+    if os.path.exists(resource_file) and os.access(resource_file, os.R_OK):
+        rd = file_to_json(resource_file)
+        resources = Resources(**rd)
+    else:
+        if using_def_resource_file:
+            logger.info(f"Using default resources as I can't find resources def '{resource_file}'")
+            resources = Resources()
+        else:
+            logger.warning(f"Cannot open resources definition file '{resource_file}'")
+            sys.exit(-1)
+
+    controller = BatchController(image=image, command=command, resources=resources)
+    return create_service_definition(fn, controller, service_id, description)
+
+def create_service_definition(
+    fn: Callable[..., Any],
+    controller: Any,
+    service_id: Optional[str] = None,
+    description: Optional[str] = None,
+) -> ServiceDefinition:
+    name = os.getenv("IVCAP_SERVICE_NAME", fn.__name__)
+    if service_id == None:
+        service_id = os.getenv("IVCAP_SERVICE_ID", SERVICE_ID_PLACEHOLDER)
+    if description == None:
+        description = fn.__doc__ or "no description available"
+    policy = os.getenv("IVCAP_POLICY_URN", DEF_POLICY)
+
+
+    sd_data = {
+        "$id": service_id,
+        "name": name,
+        "description": description,
+        "policy": policy,
+        "controller": controller,
+    }
+
+    sd = ServiceDefinition(**sd_data)
+    return sd

ivcap_service/testing.py

@@ -0,0 +1,63 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import os
+from typing import Optional, Dict, Any
+from http import HTTPStatus
+import httpx
+import json
+
+def file_to_http_response(
+    file_path: str,
+    headers: Optional[Dict[str, str]] = None,
+    status_code: int = 200,
+) -> httpx.Response:
+    """
+    Reads data from a file and returns it as an httpx.Response object.
+
+    Args:
+        file_path: The path to the file to read.
+        headers: Optional dictionary of HTTP headers to include in the response.
+        status_code: The HTTP status code to return (e.g., 200, 404, 500).
+        status_message: Optional HTTP status message. If None, the default
+            message for the status_code is used.
+
+    Returns:
+        An httpx.Response object containing the file data and response information.
+    """
+    # Sanity checks
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+    if not os.path.isfile(file_path):
+        raise ValueError(f"Not a file: {file_path}")
+    if status_code < 100 or status_code > 599:
+        raise ValueError(f"Invalid HTTP status code: {status_code}")
+
+    # Default headers
+    default_headers = {
+        "Content-Type": "application/octet-stream",  # Default content type
+        "Content-Length": str(os.path.getsize(file_path)),
+    }
+
+    # Combine default and user-provided headers
+    combined_headers = default_headers.copy()
+    if headers:
+        combined_headers.update(headers) # Use update for simpler merging
+
+    # Read the file data
+    try:
+        with open(file_path, "rb") as file:
+            file_data = file.read()
+    except Exception as e:
+        raise IOError(f"Error reading file: {file_path}: {e}")
+
+    # Create an httpx.Response object
+    response = httpx.Response(
+        status_code=status_code,
+        content=file_data,
+        headers=combined_headers,
+    )
+
+    return response

ivcap_service/tool_definition.py

@@ -0,0 +1,406 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+
+import inspect
+import os
+from typing import Any, Callable, Optional, get_type_hints
+from typing import (
+    Any,
+    Callable,
+    Optional,
+    Tuple,
+    Union,
+)
+from pydantic import BaseModel, Field
+
+from .types import ExecutionContext
+from .utils import _get_input_type
+
+TOOL_SCHEMA = "urn:sd-core:schema.ai-tool.1"
+
+SERVICE_ID_PLACEHOLDER = "#SERVICE_ID#"
+
+class ToolDefinition(BaseModel):
+    jschema: str = Field(default=TOOL_SCHEMA, alias="$schema")
+    id: str
+
+    model_config = {
+        "populate_by_name": True,
+    }
+    name: str
+    service_id: str = Field(alias="service-id")
+    description: str
+    fn_signature: str
+    fn_schema: dict
+
+def print_tool_definition(
+    fn: Callable[..., Any],
+    *,
+    service_id: Optional[str] = None,
+    description: Optional[str] = None,
+    id_prefix: str = "urn:sd-core:ai-tool",
+):
+    td = create_tool_definition(fn, service_id=service_id, description=description, id_prefix=id_prefix)
+    print(td.model_dump_json(indent=2, by_alias=True))
+
+def create_tool_definition(
+    fn: Callable[..., Any], *,
+    service_id: Optional[str] = None,
+    description: Optional[str] = None,
+    id_prefix: str = "urn:sd-core:ai-tool",
+) -> ToolDefinition:
+    name = os.getenv("IVCAP_SERVICE_NAME", fn.__name__)
+    signature, description = _generate_function_description(fn, name, exclude_types=[ExecutionContext])
+
+    if service_id == None:
+        service_id = os.getenv("IVCAP_SERVICE_ID", SERVICE_ID_PLACEHOLDER)
+
+    #fn_sig = inspect.signature(fn)
+    input_type, _ = _get_input_type(fn)
+
+    td = ToolDefinition(
+        id=f"{id_prefix}.{name}",
+        name=name,
+        service_id=service_id,
+        description=description,
+        fn_signature=signature,
+        fn_schema=input_type.model_json_schema(),
+    )
+    return td
+
+def _generate_function_description(func: Callable, name: Optional[str] = None, exclude_types: Optional[list] = None) -> Tuple[str, str]:
+    """Generates a function description with argument descriptions and return values from a function with a Pydantic argument.
+
+    The function description assumes that all fields in the Pydantic argument are provided as "normal" function arguments.
+    This is useful for generating documentation for functions that use Pydantic models, as it makes the function signature
+    more readable by showing the individual fields of the Pydantic model as separate arguments.
+
+    Args:
+        func: The function to generate a description for. The function should have at least one Pydantic model as an argument.
+        name: Optional name to override the function's actual name.
+        exclude_types: Optional list of types to exclude from the function description. Any subtypes of these types will also be excluded.
+
+    Returns:
+        A tuple containing:
+        - The function signature as a string.
+        - The rest of the function description, including the docstring, argument descriptions, and return type.
+    """
+    if exclude_types is None:
+        exclude_types = []
+
+    def is_excluded_type(param_type):
+        """Check if a type should be excluded based on the exclude_types list."""
+        if not exclude_types:
+            return False
+
+        # Check if the type is in the exclude_types list
+        if param_type in exclude_types:
+            return True
+
+        # Check if the type is a subclass of any type in the exclude_types list
+        for exclude_type in exclude_types:
+            # Only check issubclass if both types are classes
+            if (isinstance(param_type, type) and isinstance(exclude_type, type) and
+                issubclass(param_type, exclude_type)):
+                return True
+
+        return False
+    signature = inspect.signature(func)
+    type_hints = get_type_hints(func)
+
+    # Get the Pydantic model class
+    pydantic_model_class = None
+    pydantic_param_name = None
+    for param_name, param in signature.parameters.items():
+        if hasattr(param.annotation, '__mro__') and BaseModel in param.annotation.__mro__:
+            pydantic_model_class = param.annotation
+            pydantic_param_name = param_name
+            break
+
+    if not pydantic_model_class:
+        error_msg = "Function does not have a Pydantic model as an argument."
+        return ("", error_msg)
+
+    model_schema = pydantic_model_class.schema()
+
+    # Start with the function's docstring
+    description = func.__doc__ or ""
+
+    # Create a new function signature with the Pydantic fields as arguments
+    function_name = name if name is not None else func.__name__
+    new_signature = f"{function_name}("
+
+    # Collect all parameters
+    all_params = []
+
+    # Add non-Pydantic parameters first
+    for param_name, param in signature.parameters.items():
+        if param_name != pydantic_param_name:
+            param_type = type_hints.get(param_name, Any)
+            # Skip if the type is in the exclude_types list or is a subtype of an excluded type
+            if is_excluded_type(param_type) or param_name in exclude_types:
+                continue
+            param_type_name = param_type.__name__ if hasattr(param_type, '__name__') else str(param_type)
+            all_params.append(f"{param_name}: {param_type_name}")
+
+    # Add Pydantic fields
+    for field_name, field_info in model_schema['properties'].items():
+        # Skip if the field name is "$schema"
+        if field_name == "$schema":
+            continue
+        # Skip if the field name is in the exclude_types list
+        if field_name in exclude_types:
+            continue
+        # Get the correct type from the Pydantic model
+        field_type = field_info.get('type', None)
+
+        # If type is not available in the schema, try to get it from the model's __annotations__
+        if field_type is None and hasattr(pydantic_model_class, '__annotations__'):
+            annotation = pydantic_model_class.__annotations__.get(field_name)
+            if annotation is not None:
+                if hasattr(annotation, '__origin__') and annotation.__origin__ is Union:
+                    # Handle Optional types (Union[type, NoneType])
+                    args = annotation.__args__
+                    if len(args) == 2 and args[1] is type(None):
+                        field_type = args[0].__name__
+                        is_optional = True
+                    else:
+                        field_type = str(annotation).replace('typing.', '')
+                else:
+                    field_type = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+            else:
+                field_type = 'Any'
+        else:
+            # Handle optional fields
+            is_optional = False
+            if 'default' in field_info or field_name not in model_schema.get('required', []):
+                is_optional = True
+
+            # Map JSON schema types to Python types
+            if field_type == 'string':
+                field_type = 'str'
+            elif field_type == 'integer':
+                field_type = 'int'
+            elif field_type == 'number':
+                field_type = 'float'
+            elif field_type == 'boolean':
+                field_type = 'bool'
+            elif field_type == 'array':
+                # Handle array types with their item types
+                items = field_info.get('items', {})
+                item_type = items.get('type', 'Any')
+                # Map item type to Python types
+                if item_type == 'string':
+                    item_type = 'str'
+                elif item_type == 'integer':
+                    item_type = 'int'
+                elif item_type == 'number':
+                    item_type = 'float'
+                elif item_type == 'boolean':
+                    item_type = 'bool'
+                field_type = f"array[{item_type}]"
+            elif field_type is None:
+                field_type = 'Any'
+
+        # Add Optional[] for optional fields
+        if is_optional and not field_type.startswith('Optional['):
+            field_type = f"Optional[{field_type}]"
+
+        all_params.append(f"{field_name}: {field_type}")
+
+    # Join all parameters with commas
+    new_signature += ", ".join(all_params)
+    new_signature += ")"
+
+    # Add return type
+    return_type = type_hints.get('return', 'unknown')
+    if hasattr(return_type, '__name__'):
+        return_type_str = return_type.__name__
+    else:
+        return_type_str = str(return_type)
+    new_signature += f" -> {return_type_str}"
+
+    description = f"{new_signature}\n\n{description}\n\nArguments:\n"
+
+    # Add non-Pydantic parameters first with their descriptions
+    for param_name, param in signature.parameters.items():
+        if param_name == "$schema":
+            continue
+        if param_name != pydantic_param_name:
+            param_type = type_hints.get(param_name, Any)
+            # Skip if the type is in the exclude_types list or is a subtype of an excluded type
+            if is_excluded_type(param_type) or param_name in exclude_types:
+                continue
+            param_type_name = param_type.__name__ if hasattr(param_type, '__name__') else str(param_type)
+            description += f"  {param_name}: {param_type_name}\n"
+
+    # Add Pydantic fields with their descriptions
+    for field_name, field_info in model_schema['properties'].items():
+        if field_name == "$schema":
+            continue
+        # Skip if the field name is in the exclude_types list
+        if field_name in exclude_types:
+            continue
+        # Get the correct type from the Pydantic model
+        field_type = field_info.get('type', None)
+
+        # If type is not available in the schema, try to get it from the model's __annotations__
+        if field_type is None and hasattr(pydantic_model_class, '__annotations__'):
+            annotation = pydantic_model_class.__annotations__.get(field_name)
+            if annotation is not None:
+                if hasattr(annotation, '__origin__') and annotation.__origin__ is Union:
+                    # Handle Optional types (Union[type, NoneType])
+                    args = annotation.__args__
+                    if len(args) == 2 and args[1] is type(None):
+                        field_type = args[0].__name__
+                        is_optional = True
+                    else:
+                        field_type = str(annotation).replace('typing.', '')
+                else:
+                    field_type = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+            else:
+                field_type = 'Any'
+        else:
+            # Handle optional fields
+            is_optional = False
+            if 'default' in field_info or field_name not in model_schema.get('required', []):
+                is_optional = True
+
+            # Map JSON schema types to Python types
+            if field_type == 'string':
+                field_type = 'str'
+            elif field_type == 'integer':
+                field_type = 'int'
+            elif field_type == 'number':
+                field_type = 'float'
+            elif field_type == 'boolean':
+                field_type = 'bool'
+            elif field_type == 'array':
+                # Handle array types with their item types
+                items = field_info.get('items', {})
+                item_type = items.get('type', 'Any')
+                # Map item type to Python types
+                if item_type == 'string':
+                    item_type = 'str'
+                elif item_type == 'integer':
+                    item_type = 'int'
+                elif item_type == 'number':
+                    item_type = 'float'
+                elif item_type == 'boolean':
+                    item_type = 'bool'
+                field_type = f"array[{item_type}]"
+            elif field_type is None:
+                field_type = 'Any'
+
+        # Add Optional[] for optional fields
+        if is_optional and not field_type.startswith('Optional['):
+            field_type = f"Optional[{field_type}]"
+
+        description += f"  {field_name}: {field_type}"
+        if 'description' in field_info:
+            description += f" - {field_info['description']}"
+        # Add default value information if available
+        if 'default' in field_info:
+            default_value = field_info['default']
+            description += f" (Defaults to {default_value})"
+        description += "\n"
+
+    # Add a note about the return type
+    description += f"\nReturns: {return_type_str}"
+
+    # Split the description into signature and the rest
+    signature_part = new_signature
+    rest_part = description.replace(new_signature, "", 1).strip()
+
+    return (signature_part, rest_part)
+
+# def create_tool_definition(
+#     fn: Callable[..., Any],
+#     name: Optional[str] = None,
+#     description: Optional[str] = None
+# ) -> ToolDefinition:
+#     fn_to_parse = fn
+#     name = name or fn_to_parse.__name__
+#     description = description or fn_to_parse.__doc__
+
+#     fn_sig = inspect.signature(fn_to_parse)
+
+#     # Handle FieldInfo defaults
+#     def r(param):
+#         if isinstance(param.default, FieldInfo):
+#             return param.replace(default=inspect.Parameter.empty)
+#         else:
+#             return param
+#     fn_sig = fn_sig.replace(parameters=[r(param) for param in fn_sig.parameters.values()])
+
+#     fn_signature = f"{name}{fn_sig}"
+#     fn_schema = create_schema_from_function(name, fn_to_parse)
+#     return ToolDefinition(
+#         id=f"urn:sd-core:ai-tool:{name}",
+#         name=name,
+#         description=description,
+#         fn_signature=fn_signature,
+#         fn_schema=fn_schema.model_json_schema(by_alias=False))
+
+# def create_schema_from_function(
+#     name: str,
+#     func: Union[Callable[..., Any], Callable[..., Awaitable[Any]]],
+#     additional_fields: Optional[
+#         List[Union[Tuple[str, Type, Any], Tuple[str, Type]]]
+#     ] = None,
+#     ignore_fields: Optional[List[str]] = None,
+# ) -> Type[BaseModel]:
+#     """Create schema from function."""
+#     fields = {}
+#     ignore_fields = ignore_fields or []
+#     params = inspect.signature(func).parameters
+#     for param_name in params:
+#         if param_name in ignore_fields:
+#             continue
+
+#         param_type = params[param_name].annotation
+#         param_default = params[param_name].default
+#         description = None
+
+#         if get_origin(param_type) is typing.Annotated:
+#             args = get_args(param_type)
+#             param_type = args[0]
+#             if isinstance(args[1], str):
+#                 description = args[1]
+
+#         if param_type is params[param_name].empty:
+#             param_type = Any
+
+#         if param_default is params[param_name].empty:
+#             # Required field
+#             fields[param_name] = (param_type, FieldInfo(description=description))
+#         elif isinstance(param_default, FieldInfo):
+#             # Field with pydantic.Field as default value
+#             fields[param_name] = (param_type, param_default)
+#         else:
+#             fields[param_name] = (
+#                 param_type,
+#                 FieldInfo(default=param_default, description=description),
+#             )
+
+#     additional_fields = additional_fields or []
+#     for field_info in additional_fields:
+#         if len(field_info) == 3:
+#             field_info = cast(Tuple[str, Type, Any], field_info)
+#             field_name, field_type, field_default = field_info
+#             fields[field_name] = (field_type, FieldInfo(default=field_default))
+#         elif len(field_info) == 2:
+#             # Required field has no default value
+#             field_info = cast(Tuple[str, Type], field_info)
+#             field_name, field_type = field_info
+#             fields[field_name] = (field_type, FieldInfo())
+#         else:
+#             raise ValueError(
+#                 f"Invalid additional field info: {field_info}. "
+#                 "Must be a tuple of length 2 or 3."
+#             )
+
+#     return create_model(name, **fields)  # type: ignore

ivcap_service/types.py

@@ -0,0 +1,34 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import io
+from typing import Any, Callable, Generic, List, Optional, TypeVar, Union, BinaryIO
+from dataclasses import dataclass
+from pydantic import Field, BaseModel
+
+class ExecutionContext:
+    pass
+
+@dataclass
+class BinaryResult():
+    """If the result of the tool is a non json serialisable object, return an
+    instance of this class indicating the content-type and the actual
+    result either as a byte array or a file handle to a binary content (`open(..., "rb")`)"""
+    content_type: str = Field(description="Content type of result serialised")
+    content: Union[bytes, str, io.BufferedReader] = Field(description="Content to send, either as byte array or file handle")
+
+@dataclass
+class IvcapResult(BinaryResult):
+    isError: bool = False
+    raw: Any = None
+
+class ExecutionError(BaseModel):
+    """
+    Pydantic model for execution errors.
+    """
+    jschema: str = Field("urn:ivcap:schema.ai-tool.error.1", alias="$schema")
+    error: str = Field(description="Error message")
+    type: str = Field(description="Error type")
+    traceback: Optional[str] = Field(None, description="traceback")

ivcap_service/utils.py

@@ -0,0 +1,83 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import inspect
+import json
+import os
+import re
+from typing import Optional, Type, Callable, TypeVar, Any, get_type_hints, Union, Dict, Tuple
+
+from pydantic import BaseModel, HttpUrl
+
+def get_version():
+    return "???"
+
+def _get_input_type(func: Callable) -> Tuple[Optional[Type[BaseModel]], Dict[str, Any]]:
+    """Gets the input type of a function.
+
+    Args:
+        func: The function to get the input type for.
+
+    Returns:
+        A tuple containing:
+        - The first function parameter which is a derived class of a pydantic BaseModel, or None if no such parameter exists.
+        - A dictionary of all additional parameters, where the key is the parameter name and the value is the type.
+    """
+    signature = inspect.signature(func)
+    type_hints = get_type_hints(func)
+
+    # Get the Pydantic model class
+    pydantic_model_class = None
+    pydantic_param_name = None
+    for param_name, param in signature.parameters.items():
+        if hasattr(param.annotation, '__mro__') and BaseModel in param.annotation.__mro__:
+            pydantic_model_class = param.annotation
+            pydantic_param_name = param_name
+            break
+
+    # Get all additional parameters
+    additional_params = {}
+    for param_name, param in signature.parameters.items():
+        if param_name != pydantic_param_name:
+            param_type = type_hints.get(param_name, Any)
+            additional_params[param_name] = param_type
+
+    return pydantic_model_class, additional_params
+
+def _get_function_return_type(func):
+    """Extracts the return type from a function."""
+    type_hints = get_type_hints(func)
+    # param_types = {k: v for k, v in type_hints.items() if k != 'return'}
+    return_type = type_hints.get('return')
+    # return param_types, return_type
+    return return_type
+
+def file_to_json(file_path: str) -> Dict[str, Any]:
+    """
+    Reads a file, attempts to parse it as JSON, and returns the content.
+
+    Args:
+        file_path: The path to the file to read.
+
+    Returns:
+        A dictionary containing the parsed JSON content.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        ValueError: If the file is not a valid JSON file.
+        IOError: If there is an error reading the file.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    try:
+        with open(file_path, "r") as f:
+            return json.load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"Error finding file: {file_path}: {e}")
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Error decoding JSON from file: {file_path}: {e}")
+    except Exception as e:
+        raise IOError(f"Error reading file: {file_path}: {e}")

ivcap_service/version.py

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2023 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+
+__version__ = "???"
+try:  # Python > 3.8+
+    from importlib_metadata import version
+    __version__ = version("ivcap_service")
+except ImportError:
+    try:
+        import pkg_resources
+        __version__ = pkg_resources.get_distribution('ivcap_service').version
+    except Exception:
+        pass
+
+def get_version():
+    return __version__

ivcap_service-0.3.0.dist-info/AUTHORS.md

@@ -0,0 +1,5 @@
+# Initial version authors
+
+* Max Ott <max.ott@csiro.au>
+
+# Partial list of contributors

ivcap_service-0.3.0.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Commonwealth Scientific and Industrial Research Organisation (CSIRO) ABN 41 687 119 230
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ivcap_service-0.3.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.1
+Name: ivcap_service
+Version: 0.3.0
+Summary: SDK library for building services for the IVCAP platform
+Author: Max Ott
+Author-email: max.ott@csiro.au
+Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cachetools (>=5.5.2,<6.0.0)
+Requires-Dist: opentelemetry-distro (>=0.51b0,<0.52)
+Requires-Dist: opentelemetry-exporter-otlp (>=1.30.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.51b0,<0.52)
+Requires-Dist: opentelemetry-instrumentation-httpx (>=0.51b0,<0.52)
+Requires-Dist: opentelemetry-instrumentation-requests (>=0.51b0,<0.52)
+Requires-Dist: uuid6 (==2024.7.10)
+Description-Content-Type: text/markdown
+
+# ivcap_ai_tool: A python library for building AI tools for the IVCAP platform
+
+<a href="https://scan.coverity.com/projects/ivcap-works-ivcap-ai-tool-sdk-python">
+  <img alt="Coverity Scan Build Status"
+       src="https://img.shields.io/coverity/scan/31491.svg"/>
+</a>
+
+A python library containing various helper and middleware functions
+to simplify developing AI tools to be deployed on IVCAP.
+
+> **Note:** A template git repositiory using this library can be found on github
+[ivcap-works/ivcap-python-ai-tool-template](https://github.com/ivcap-works/ivcap-python-ai-tool-template). You may clone that and start from there.
+
+## Content
+
+* [Register a Tool Function](#register)
+* [Start the Service](#start)
+* [JSON-RPC Middleware](#json-rpc)
+* [Try-Later Middleware](#try-later)
+
+### Register a Tool Function <a name="register"></a>
+
+```python
+class Request(BaseModel):
+    jschema: str = Field("urn:sd:schema:some_tool.request.1", alias="$schema")
+    ...
+
+class Result(BaseModel):
+    jschema: str = Field("urn:sd:schema:some_tool.1", alias="$schema")
+    ...
+
+def some_tool(req: Request) -> Result:
+    """
+    Here should go a quite extensive description of what the tool can be
+    used for so that an agent can work out if this tool is useful in
+    a specific context.
+
+    DO NOT ADD PARAMTER AND RETURN DECRIPTIONS -
+       DESCRIBE THEM IN THE `Request` MODEL
+    """
+    ...
+
+    return Result(...)
+
+add_tool_api_route(app, "/", some_tool, opts=ToolOptions(tags=["Great Tool"]))
+```
+
+### Start the Service <a name="start"></a>
+
+```python
+app = FastAPI(
+  ..
+)
+
+if __name__ == "__main__":
+    start_tool_server(app, some_tool)
+```
+
+### JSON-RPC Middleware <a name="json-rpc"></a>
+
+This middleware will convert any `POST /` with a payload
+following the [JSON-RPC](https://www.jsonrpc.org/specification)
+specification to an internal `POST /{method}` and will return
+the result formatted according to the JSON-RPC spec.
+
+```python
+from ivcap_fastapi import use_json_rpc_middleware
+
+app = FastAPI(
+  ..
+)
+
+use_json_rpc_middleware(app)
+```
+
+### Try-Later Middleware <a name="try-later"></a>
+
+This middleware is supporting the use case where the execution of a
+requested service is taking longer than the caller is willing to wait.
+A typical use case is where the service is itself outsourcing the execution
+to some other long-running service but may immediately receive a reference
+to the eventual result.
+
+In this case, raising a `TryLaterException` will return with a 204
+status code and additional information on how to later check back for the
+result.
+
+```python
+from ivcap_fastapi import TryLaterException, use_try_later_middleware
+use_try_later_middleware(app)
+
+@app.post("/big_job")
+def big_job(req: Request) -> Response:
+    jobID, expected_exec_time = scheduling_big_job(req)
+    raise TryLaterException(f"/big_job/jobs/{jobID}", expected_exec_time)
+
+@app.get("/big_job/jobs/{jobID}")
+def get_job(jobID: str) -> Response:
+    resp = find_result_for(job_id)
+    return resp
+```
+
+Specifically, raising `TryLaterException(location, delay)` will
+return an HTTP response with a 204 status code with the additional
+HTTP headers `Location` and `Retry-Later` set to `location` and
+`delay` respectively.
+

ivcap_service-0.3.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+ivcap_service/__init__.py,sha256=X1qbtEKDWGWWmBemuYNRotRgjgq-hxsUSpQ4KXGxtJs,579
+ivcap_service/ivcap.py,sha256=ci9v_-ye_Y14Wd-tQ62HH21I8O0QUQtUZAIRmFy6QLM,5036
+ivcap_service/logger.py,sha256=vU_xacRTJHJLpbGBzc7w5uw2HTx78SUy3AD0f5vtuJw,804
+ivcap_service/logging.json,sha256=Gsh4Xb8Cznh7h7fqaZt6riJ_jOSVYVKeY6MaUXnu91s,972
+ivcap_service/py.typed,sha256=8ZJUsxZiuOy1oJeVhsTWQhTG_6pTVHVXk5hJL79ebTk,25
+ivcap_service/service.py,sha256=OMW08IPTjxNkXTLla6ouab8bL20OJ_qcXnW6ocIMqGY,6430
+ivcap_service/service_definition.py,sha256=Kddg7ftHEwwz_0_cdGLQNiyVcIYTJESfghlslMmHR_8,4041
+ivcap_service/testing.py,sha256=L90a-T8XKVSG7USaeG2YC-AzALYrHXXMlay5DhwX-uM,2134
+ivcap_service/tool_definition.py,sha256=i8XfL0JsT6RcH1NIWu66ToFVzkRQuvZYP6n_kVBqblw,16257
+ivcap_service/types.py,sha256=i0scqE_jNyFy3mYS0UcfhAHIF5EsO7d_ljdcACA15Fw,1375
+ivcap_service/utils.py,sha256=2wNpEg9YNZlhBRwigvENhPv4v0eg_41_us1BHLQG5Oo,3008
+ivcap_service/version.py,sha256=3c3XnZLqPZ7_OmYwaMXn5Zta2IbDrJurPkMTKnpyltg,608
+ivcap_service-0.3.0.dist-info/AUTHORS.md,sha256=s9xR4_HAHQgbNlj505LViebt5AtACQmhPf92aJvNYgg,88
+ivcap_service-0.3.0.dist-info/LICENSE,sha256=dsQrDPPwW7iJs9pxahgJKDW8RNPf5FyXG70MFUlxcuk,1587
+ivcap_service-0.3.0.dist-info/METADATA,sha256=1YwWjgg3sC8gqGhNJHzDzF4mzMR_Kubeirai3DTggvw,4148
+ivcap_service-0.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ivcap_service-0.3.0.dist-info/RECORD,,

ivcap_service-0.3.0.dist-info/WHEEL

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