octostar-python-client 0.1.759__py3-none-any.whl

octostar/api/pipeline/get_processing_status.py

@@ -0,0 +1,185 @@
+"""Get processing status endpoint - POST /api/v1/pipeline/processing-status/get
+
+Requires x-ontology header to specify which ontology/index to query.
+"""
+
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional
+from warnings import warn
+
+import httpx
+
+from ...client import Client, get_default_client
+from ...types import Response
+from ... import errors
+
+
+client_missing_msg = """No client was passed to this function. The default admin client will be used, but this is deprecated and will be removed soon.
+Please create a client using octostar.client.make_client() and run the function via client.execute()."""
+
+
+def _get_kwargs(
+    *,
+    client: Client = None,
+    entity_ids: List[str],
+) -> Dict[str, Any]:
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    base_url = client.get_base_url_v1()
+    url = "{}/api/v1/pipeline/processing-status/get".format(base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    json_body: Dict[str, Any] = {
+        "entity_ids": entity_ids,
+    }
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+        "json": json_body,
+    }
+
+
+def _parse_response(
+    *, client: Client = None, response: httpx.Response
+) -> Optional[Dict[str, Any]]:
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    if response.status_code == HTTPStatus.OK:
+        return response.json()
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    return None
+
+
+def _build_response(
+    *, client: Client = None, response: httpx.Response
+) -> Response[Dict[str, Any]]:
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client = None,
+    entity_ids: List[str],
+) -> Response[Dict[str, Any]]:
+    """Get processing status for entities.
+
+    Note: Requires x-ontology header to be set on the client.
+
+    The persisted recursive rollup is always returned in-line as
+    ``detailed_status`` per entity (when the debounced rollup job has
+    written it). There is no separate "ask for recursive numbers" knob.
+
+    Args:
+        client: The client to use for the request (must have x-ontology header set).
+        entity_ids: List of entity IDs to retrieve status for.
+
+    Returns:
+        Response with status and data dict mapping entity_id -> status or None.
+    """
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    kwargs = _get_kwargs(client=client, entity_ids=entity_ids)
+    response = httpx.request(verify=client.verify_ssl, **kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Client = None,
+    entity_ids: List[str],
+) -> Optional[Dict[str, Any]]:
+    """Get processing status for entities.
+
+    Note: Requires x-ontology header to be set on the client.
+
+    The persisted recursive rollup is always returned in-line as
+    ``detailed_status`` per entity (when the debounced rollup job has
+    written it). There is no separate "ask for recursive numbers" knob.
+
+    Args:
+        client: The client to use for the request (must have x-ontology header set).
+        entity_ids: List of entity IDs to retrieve status for.
+
+    Returns:
+        Response dict with status and data.
+    """
+    return sync_detailed(client=client, entity_ids=entity_ids).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client = None,
+    entity_ids: List[str],
+) -> Response[Dict[str, Any]]:
+    """Get processing status for entities (async).
+
+    Note: Requires x-ontology header to be set on the client.
+
+    The persisted recursive rollup is always returned in-line as
+    ``detailed_status`` per entity (when the debounced rollup job has
+    written it). There is no separate "ask for recursive numbers" knob.
+
+    Args:
+        client: The client to use for the request (must have x-ontology header set).
+        entity_ids: List of entity IDs to retrieve status for.
+
+    Returns:
+        Response with status and data dict.
+    """
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    kwargs = _get_kwargs(client=client, entity_ids=entity_ids)
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Client = None,
+    entity_ids: List[str],
+) -> Optional[Dict[str, Any]]:
+    """Get processing status for entities (async).
+
+    Note: Requires x-ontology header to be set on the client.
+
+    The persisted recursive rollup is always returned in-line as
+    ``detailed_status`` per entity (when the debounced rollup job has
+    written it). There is no separate "ask for recursive numbers" knob.
+
+    Args:
+        client: The client to use for the request (must have x-ontology header set).
+        entity_ids: List of entity IDs to retrieve status for.
+
+    Returns:
+        Response dict with status and data.
+    """
+    return (await asyncio_detailed(client=client, entity_ids=entity_ids)).parsed

octostar/api/pipeline/update_processing_status.py

@@ -0,0 +1,164 @@
+"""Update processing status endpoint - POST /api/v1/pipeline/processing-status
+
+Requires x-ontology header to specify which ontology/index to update.
+"""
+
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional, Union
+from warnings import warn
+
+import httpx
+
+from ...client import Client, get_default_client
+from ...types import Response, UNSET, Unset
+from ... import errors
+
+
+client_missing_msg = """No client was passed to this function. The default admin client will be used, but this is deprecated and will be removed soon.
+Please create a client using octostar.client.make_client() and run the function via client.execute()."""
+
+
+def _get_kwargs(
+    *,
+    client: Client = None,
+    json_body: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    base_url = client.get_base_url_v1()
+    url = "{}/api/v1/pipeline/processing-status".format(base_url)
+
+    headers: Dict[str, str] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+        "json": json_body,
+    }
+
+
+def _parse_response(
+    *, client: Client = None, response: httpx.Response
+) -> Optional[Dict[str, Any]]:
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    if response.status_code == HTTPStatus.OK:
+        return response.json()
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    return None
+
+
+def _build_response(
+    *, client: Client = None, response: httpx.Response
+) -> Response[Dict[str, Any]]:
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client = None,
+    json_body: List[Dict[str, Any]],
+) -> Response[Dict[str, Any]]:
+    """Update processing status for entities.
+
+    Note: Requires x-ontology header to be set on the client.
+
+    Args:
+        client: The client to use for the request (must have x-ontology header set).
+        json_body: List of processing status updates. Each must contain:
+            - entity_id (str): The entity ID (required)
+            - status_code (str, optional): RUNNING, COMPLETED, FAILED, STALE, UNKNOWN
+            - entity_type (str, optional): The entity type
+            - reason (str, optional): Reason for the status
+            - timeout (int, optional): Redis cache TTL in seconds
+
+    Returns:
+        Response with status and count of updated entities.
+    """
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    kwargs = _get_kwargs(client=client, json_body=json_body)
+    response = httpx.request(verify=client.verify_ssl, **kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Client = None,
+    json_body: List[Dict[str, Any]],
+) -> Optional[Dict[str, Any]]:
+    """Update processing status for entities.
+
+    Args:
+        client: The client to use for the request.
+        json_body: List of processing status updates.
+
+    Returns:
+        Response dict with status, message, and count.
+    """
+    return sync_detailed(client=client, json_body=json_body).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client = None,
+    json_body: List[Dict[str, Any]],
+) -> Response[Dict[str, Any]]:
+    """Update processing status for entities (async).
+
+    Args:
+        client: The client to use for the request.
+        json_body: List of processing status updates.
+
+    Returns:
+        Response with status and count of updated entities.
+    """
+    if not client:
+        warn(client_missing_msg, FutureWarning, stacklevel=2)
+        client = get_default_client()
+
+    kwargs = _get_kwargs(client=client, json_body=json_body)
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Client = None,
+    json_body: List[Dict[str, Any]],
+) -> Optional[Dict[str, Any]]:
+    """Update processing status for entities (async).
+
+    Args:
+        client: The client to use for the request.
+        json_body: List of processing status updates.
+
+    Returns:
+        Response dict with status, message, and count.
+    """
+    return (await asyncio_detailed(client=client, json_body=json_body)).parsed

octostar/api/search/get_annotations.py

@@ -0,0 +1,153 @@
+"""SDK endpoint module for POST /v1/search_api/{ontology}/annotations."""
+
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from ...client import Client, get_default_client
+from ...types import Response
+from ... import errors
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: Dict[str, Any],
+    ontology: str,
+) -> Dict[str, Any]:
+    base_url = client.get_base_url_v1()
+    url = f"{base_url}/api/v1/search_api/{ontology}/annotations"
+
+    headers: Dict[str, str] = client.get_headers()
+    headers["Content-Type"] = "application/json"
+
+    return {
+        "method": "post",
+        "url": url,
+        "headers": headers,
+        "cookies": client.get_cookies(),
+        "timeout": client.get_timeout(),
+        "follow_redirects": client.follow_redirects,
+        "json": json_body,
+    }
+
+
+def _parse_response(
+    *, client: Client, response: httpx.Response
+) -> Optional[Dict[str, Any]]:
+    if response.status_code == HTTPStatus.OK:
+        return response.json()
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Client, response: httpx.Response
+) -> Response[Dict[str, Any]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def _build_body(
+    os_entity_uids: List[str],
+    fields: Optional[List[str]],
+    recurse: bool,
+    merge: bool,
+    max_fragments: Optional[int],
+    fragment_filter: Optional[Dict[str, Any]],
+    include_record: bool = False,
+    collapse: bool = True,
+    merge_kwargs: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    body: Dict[str, Any] = {
+        "os_entity_uids": os_entity_uids,
+        "recurse": recurse,
+        "merge": merge,
+        "max_fragments": max_fragments,
+    }
+    if fields is not None:
+        body["fields"] = fields
+    if fragment_filter is not None:
+        body["fragment_filter"] = fragment_filter
+    if include_record:
+        body["include_record"] = True
+    if not collapse:
+        body["collapse"] = False
+    if merge_kwargs:
+        body["merge_kwargs"] = dict(merge_kwargs)
+    return body
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    os_entity_uids: List[str],
+    fields: Optional[List[str]] = None,
+    recurse: bool = True,
+    merge: bool = True,
+    max_fragments: Optional[int] = 10_000,
+    fragment_filter: Optional[Dict[str, Any]] = None,
+    include_record: bool = False,
+    collapse: bool = True,
+    merge_kwargs: Optional[Dict[str, Any]] = None,
+    timeout: Optional[float] = 30.0,
+) -> Response[Dict[str, Any]]:
+    json_body = _build_body(
+        os_entity_uids,
+        fields,
+        recurse,
+        merge,
+        max_fragments,
+        fragment_filter,
+        include_record,
+        collapse,
+        merge_kwargs,
+    )
+    kwargs = _get_kwargs(client=client, json_body=json_body, ontology=client.ontology)
+    if timeout is not None:
+        kwargs["timeout"] = timeout
+
+    response = httpx.request(verify=client.verify_ssl, **kwargs)
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    os_entity_uids: List[str],
+    fields: Optional[List[str]] = None,
+    recurse: bool = True,
+    merge: bool = True,
+    max_fragments: Optional[int] = 10_000,
+    fragment_filter: Optional[Dict[str, Any]] = None,
+    include_record: bool = False,
+    collapse: bool = True,
+    merge_kwargs: Optional[Dict[str, Any]] = None,
+    timeout: Optional[float] = 30.0,
+) -> Response[Dict[str, Any]]:
+    json_body = _build_body(
+        os_entity_uids,
+        fields,
+        recurse,
+        merge,
+        max_fragments,
+        fragment_filter,
+        include_record,
+        collapse,
+        merge_kwargs,
+    )
+    kwargs = _get_kwargs(client=client, json_body=json_body, ontology=client.ontology)
+    if timeout is not None:
+        kwargs["timeout"] = timeout
+
+    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
+        response = await _client.request(**kwargs)
+
+    return _build_response(client=client, response=response)