latticeflow-go-sdk 0.18.0__tar.gz

latticeflow_go_sdk-0.18.0/.gitignore

@@ -0,0 +1,7 @@
+latticeflow/go/_generated
+latticeflow/go/_drop_folder
+latticeflow/go/base.py
+latticeflow/go/client.py
+latticeflow/go/models/__init__.py
+tests/generated/tests
+tests/generated/conftest.py

latticeflow_go_sdk-0.18.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: latticeflow-go-sdk
+Version: 0.18.0
+Summary: Latticeflow AI GO! SDK.
+Project-URL: Homepage, https://latticeflow.ai/
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.9
+Requires-Dist: attrs>=22.2.0
+Requires-Dist: click==8.1.7
+Requires-Dist: httpx<0.29.0,>=0.20.0
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: python-dateutil~=2.9.0
+Requires-Dist: pyyaml>=5.0.0
+Requires-Dist: tomli; python_version < '3.11'
+Requires-Dist: typer==0.19.2
+Provides-Extra: eval
+Requires-Dist: questionary; extra == 'eval'
+Requires-Dist: types-tqdm==4.67.0.20250417; extra == 'eval'
+Provides-Extra: test
+Requires-Dist: jinja2~=3.1.5; extra == 'test'
+Requires-Dist: mypy==1.18.1; extra == 'test'
+Requires-Dist: polyfactory; extra == 'test'
+Requires-Dist: pytest-extra-durations~=0.1.3; extra == 'test'
+Requires-Dist: pytest~=8.3.5; extra == 'test'
+Requires-Dist: ruff==0.11.6; extra == 'test'
+Requires-Dist: types-jinja2; extra == 'test'
+Requires-Dist: types-pyyaml==6.0.12.20250402; extra == 'test'
+Requires-Dist: types-requests; extra == 'test'

latticeflow_go_sdk-0.18.0/hatch_build.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import inspect
+import os
+import shutil
+import subprocess  # nosec
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+LOG_FILE_PATH = Path("build.log")
+DROP_FOLDER_PATH = Path("_drop_folder")
+
+
+def build_log(messages: list[str], nesting_level: int = 1) -> None:
+    frame = inspect.currentframe()
+    if nesting_level == 1:
+        caller_name = (
+            frame.f_back.f_code.co_name if frame and frame.f_back else "unknown"
+        )
+    elif nesting_level == 2:
+        caller_name = (
+            frame.f_back.f_back.f_code.co_name
+            if frame and frame.f_back and frame.f_back.f_back
+            else "unknown"
+        )
+    else:
+        raise ValueError(
+            f"Invalid nesting level for build_log (provided {nesting_level})"
+        )
+    LOG_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with LOG_FILE_PATH.open("a", encoding="utf-8") as log:
+        log.write("*" * 100 + "\n")
+        for message in messages:
+            log.write(f"[build] [{caller_name}]: {message}\n")
+        log.write("*" * 100 + "\n\n")
+
+
+def lowercase_first_letter(string: str) -> str:
+    return string[0].lower() + string[1:] if string else string
+
+
+def run_subprocess_with_log_and_error_handling(
+    subprocess_descriptive_message: str,
+    commands: list[str],
+    cwd: str | None = None,
+    env: subprocess._ENV | None = None,
+) -> None:
+    build_log([subprocess_descriptive_message], nesting_level=2)
+    result = subprocess.run(
+        commands,
+        cwd=cwd,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=env,  # nosec B603
+    )
+
+    if result.returncode == 0:
+        build_log(
+            [
+                f"Finished {lowercase_first_letter(subprocess_descriptive_message)}:",
+                f"[stdout] = {result.stdout}",
+            ],
+            nesting_level=2,
+        )
+    else:
+        build_log(
+            [
+                f"Failed while {lowercase_first_letter(subprocess_descriptive_message)}:",
+                f"[status code] = {result.returncode}",
+                f"[stdout] = {result.stdout}",
+                f"[stderr] = {result.stderr}",
+            ],
+            nesting_level=2,
+        )
+        raise RuntimeError("Build failed!")
+
+
+def create_git_version_file(cwd: str, version: str) -> None:
+    build_log(["Creating git version file..."])
+    try:
+        # Safe usage of `subprocess`, read-only and no user input.
+        sha = (
+            subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=cwd)  # nosec
+            .decode("ascii")
+            .strip()
+        )
+    except Exception:  # nosec: B110 # noqa
+        sha = "unknown"
+
+    version_path = Path(cwd) / "latticeflow" / "go" / "version.py"
+    with open(version_path, "w") as f:
+        f.write(f"__version__ = '{version}'\n")
+        f.write(f"git_version = {repr(sha)}\n")
+
+
+def create_py_typed_file(cwd: str) -> None:
+    build_log(["Creating py.typed marker file..."])
+    # Marker file for PEP 561
+    py_typed_path = Path(cwd) / "latticeflow" / "go" / "py.typed"
+    open(py_typed_path, "w")
+
+
+def clean_files_before_generation() -> None:
+    for path in [
+        Path("latticeflow/go/base.py"),
+        Path("latticeflow/go/client.py"),
+        Path("latticeflow/go/version.py"),
+        Path("latticeflow/go/py.typed"),
+    ]:
+        build_log([f"Deleting file at {path}..."])
+        path.unlink(missing_ok=True)
+
+    for folder in ["latticeflow/go/models", "latticeflow/go/_generated"]:
+        build_log([f"Deleting folder at {folder}..."])
+        shutil.rmtree(folder, ignore_errors=True)
+
+
+def bundle_openapi_spec() -> None:
+    run_subprocess_with_log_and_error_handling(
+        "Bundling OpenAPI spec",
+        ["./bundle_public_openapi_spec.sh"],
+        cwd="../openapi/assessment",
+    )
+
+
+def generate_sdk() -> None:
+    # NOTE: This requires redocly to be installed (npm i -g @redocly/cli@latest)
+    # NOTE: The code is generated in a `_drop_folder`` because openapi-python-client
+    # otherwise touches our handwritten files if we generate directly into
+    # `assessment_sdk/latticeflow/go`. After that, we immediately move it from
+    # `assessment_sdk/latticeflow/go/_drop_folder` to `assessment_sdk/latticeflow/go`
+    # and delete `_drop_folder`
+    base = Path("latticeflow/go")
+    drop_folder = base / DROP_FOLDER_PATH
+    drop_folder.mkdir(parents=True, exist_ok=True)
+    run_subprocess_with_log_and_error_handling(
+        "Generating the SDK with openapi-python-client",
+        [
+            "openapi-python-client",
+            "generate",
+            "--path",
+            "openapi/assessment/openapi-merged.yaml",
+            "--output-path",
+            f"assessment_sdk/latticeflow/go/{str(DROP_FOLDER_PATH)}",
+            "--overwrite",
+            "--config",
+            "assessment_sdk/config.yaml",
+            "--custom-template-path",
+            "assessment_sdk/templates/overrides",
+        ],
+        cwd="..",
+    )
+
+    build_log(
+        [
+            (
+                f"Move generated SDK from `assessment_sdk/latticeflow/go/{str(DROP_FOLDER_PATH)}` "
+                "to `assessment_sdk/latticeflow/go`..."
+            )
+        ]
+    )
+    for item in drop_folder.iterdir():
+        target = base / item.name
+        if target.exists():
+            if target.is_dir():
+                shutil.rmtree(target)
+            else:
+                target.unlink()
+        shutil.move(str(item), str(base))
+
+    build_log([f"Delete `assessment_sdk/latticeflow/go/{str(DROP_FOLDER_PATH)}`."])
+    shutil.rmtree(drop_folder, ignore_errors=True)
+
+    project_root = Path(__file__).resolve().parent.parent  # top-level project dir
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(project_root)
+    run_subprocess_with_log_and_error_handling(
+        "Running the custom_generator_pipeline",
+        ["python", "-m", "assessment_sdk.utils.custom_sdk_generator_pipeline"],
+        env=env,
+    )
+
+
+def cleanup_after_generation() -> None:
+    build_log(["Removing unnecessary generated files..."])
+    for path in [
+        Path("latticeflow/go/.gitignore"),
+        Path("latticeflow/go/pyproject.toml"),
+        Path("latticeflow/go/README.md"),
+    ]:
+        build_log([f"Deleting file at {path}..."])
+        path.unlink(missing_ok=True)
+    run_subprocess_with_log_and_error_handling(
+        "Formatting with Ruff",
+        ["ruff", "format", "latticeflow", "--config", "./ruff.toml"],
+    )
+    run_subprocess_with_log_and_error_handling(
+        "Checking with Ruff",
+        ["ruff", "check", "latticeflow", "--fix", "--config", "./ruff.toml"],
+    )
+
+
+class CustomHook(BuildHookInterface):
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        if self.target_name not in ["wheel", "sdist"]:
+            return
+
+        clean_files_before_generation()
+        create_git_version_file(self.root, version)
+        create_py_typed_file(self.root)
+        bundle_openapi_spec()
+        generate_sdk()
+        cleanup_after_generation()
+
+    def finalize(
+        self, version: str, build_data: dict[str, Any], artifact_path: str
+    ) -> None:
+        LOG_FILE_PATH.unlink(missing_ok=True)

latticeflow_go_sdk-0.18.0/latticeflow/go/__init__.py

@@ -0,0 +1,5 @@
+from latticeflow.go.client import AsyncClient
+from latticeflow.go.client import Client
+
+
+__all__ = ("AsyncClient", "Client")

latticeflow_go_sdk-0.18.0/latticeflow/go/_generated/__init__.py

@@ -0,0 +1,7 @@
+"""A client library for accessing AI GO! API"""
+
+from .client import AuthenticatedClient
+from .client import Client
+
+
+__all__ = ("AuthenticatedClient", "Client")

latticeflow_go_sdk-0.18.0/latticeflow/go/_generated/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

latticeflow_go_sdk-0.18.0/latticeflow/go/_generated/api/ai_systems/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

latticeflow_go_sdk-0.18.0/latticeflow/go/_generated/api/ai_systems/create_ai_system.py

@@ -0,0 +1,156 @@
+# Based on our override (see README.md) of openapi-python-client's Jinja template
+# (https://github.com/openapi-generators/openapi-python-client/blob/main/openapi_python_client/templates/endpoint_module.py.jinja)
+
+from http import HTTPStatus
+from typing import Any
+from typing import Union
+
+import httpx
+from pydantic import ValidationError
+
+from ... import errors
+from ...client import AuthenticatedClient
+from ...client import Client
+from ...models.model import AISystem
+from ...models.model import Error
+from ...models.model import StoredAISystem
+from ...types import Response
+
+
+def _get_kwargs(body: AISystem) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {"method": "post", "url": "/ai-systems"}
+
+    _kwargs["json"] = body.model_dump(mode="json")
+
+    headers["Content-Type"] = "application/json"
+
+    if headers:
+        _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Union[Error, StoredAISystem]:
+    if response.status_code == 201:
+        response_201 = StoredAISystem.model_validate(response.json())
+
+        return response_201
+
+    if response.status_code == 401:
+        response_401 = Error.model_validate(response.json())
+
+        return response_401
+
+    if response.status_code == 409:
+        response_409 = Error.model_validate(response.json())
+
+        return response_409
+
+    # NOTE: We always try to parse the response as an error if all previous parsing has failed,
+    # because the client generator only adds handling for status codes defined in the OpenAPI spec,
+    # which does not always cover all possible error codes. This code was added by the Jinja template
+    # located at `templates/overrides/endpoint_module.py.jinja`.
+    try:
+        return Error.model_validate(response.json())
+    except ValidationError as e:
+        raise errors.ErrorParsingException(
+            "Could not parse the API-returned object as `Error`", e
+        )
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, StoredAISystem]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    body: AISystem, *, client: Union[AuthenticatedClient, Client]
+) -> Response[Union[Error, StoredAISystem]]:
+    """Create an AI System
+
+    Args:
+        body (AISystem): An AI System defines a collection of datasets and models that solve a
+            target use case.
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, StoredAISystem]]
+    """
+    kwargs = _get_kwargs(body=body)
+
+    response = client.get_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    body: AISystem, *, client: Union[AuthenticatedClient, Client]
+) -> Union[Error, StoredAISystem]:
+    """Create an AI System
+
+    Args:
+        body (AISystem): An AI System defines a collection of datasets and models that solve a
+            target use case.
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, StoredAISystem]
+    """
+    return sync_detailed(client=client, body=body).parsed
+
+
+async def asyncio_detailed(
+    body: AISystem, *, client: Union[AuthenticatedClient, Client]
+) -> Response[Union[Error, StoredAISystem]]:
+    """Create an AI System
+
+    Args:
+        body (AISystem): An AI System defines a collection of datasets and models that solve a
+            target use case.
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, StoredAISystem]]
+    """
+    kwargs = _get_kwargs(body=body)
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    body: AISystem, *, client: Union[AuthenticatedClient, Client]
+) -> Union[Error, StoredAISystem]:
+    """Create an AI System
+
+    Args:
+        body (AISystem): An AI System defines a collection of datasets and models that solve a
+            target use case.
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, StoredAISystem]
+    """
+    return (await asyncio_detailed(client=client, body=body)).parsed

latticeflow_go_sdk-0.18.0/latticeflow/go/_generated/api/ai_systems/delete_ai_system.py

@@ -0,0 +1,143 @@
+# Based on our override (see README.md) of openapi-python-client's Jinja template
+# (https://github.com/openapi-generators/openapi-python-client/blob/main/openapi_python_client/templates/endpoint_module.py.jinja)
+
+from http import HTTPStatus
+from typing import Any
+from typing import Union
+
+import httpx
+from pydantic import ValidationError
+
+from ... import errors
+from ...client import AuthenticatedClient
+from ...client import Client
+from ...models.model import Error
+from ...models.model import Success
+from ...types import Response
+
+
+def _get_kwargs(ai_system_id: str) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {"method": "delete", "url": f"/ai-systems/{ai_system_id}"}
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Union[Error, Success]:
+    if response.status_code == 200:
+        response_200 = Success.model_validate(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = Error.model_validate(response.json())
+
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = Error.model_validate(response.json())
+
+        return response_404
+
+    # NOTE: We always try to parse the response as an error if all previous parsing has failed,
+    # because the client generator only adds handling for status codes defined in the OpenAPI spec,
+    # which does not always cover all possible error codes. This code was added by the Jinja template
+    # located at `templates/overrides/endpoint_module.py.jinja`.
+    try:
+        return Error.model_validate(response.json())
+    except ValidationError as e:
+        raise errors.ErrorParsingException(
+            "Could not parse the API-returned object as `Error`", e
+        )
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, Success]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ai_system_id: str, *, client: Union[AuthenticatedClient, Client]
+) -> Response[Union[Error, Success]]:
+    """Delete an AI system
+
+    Args:
+        ai_system_id (str):
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Success]]
+    """
+    kwargs = _get_kwargs(ai_system_id=ai_system_id)
+
+    response = client.get_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    ai_system_id: str, *, client: Union[AuthenticatedClient, Client]
+) -> Union[Error, Success]:
+    """Delete an AI system
+
+    Args:
+        ai_system_id (str):
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Success]
+    """
+    return sync_detailed(ai_system_id=ai_system_id, client=client).parsed
+
+
+async def asyncio_detailed(
+    ai_system_id: str, *, client: Union[AuthenticatedClient, Client]
+) -> Response[Union[Error, Success]]:
+    """Delete an AI system
+
+    Args:
+        ai_system_id (str):
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, Success]]
+    """
+    kwargs = _get_kwargs(ai_system_id=ai_system_id)
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    ai_system_id: str, *, client: Union[AuthenticatedClient, Client]
+) -> Union[Error, Success]:
+    """Delete an AI system
+
+    Args:
+        ai_system_id (str):
+
+    Raises:
+        errors.ErrorParsingException: If the server returns an unparseable entity instead of an ``Error``.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, Success]
+    """
+    return (await asyncio_detailed(ai_system_id=ai_system_id, client=client)).parsed