osdu-python-client 0.6.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

osdu_python_client/generated/storage/_facade.pyi

@@ -10,6 +10,8 @@ from .types import Unset
 from .models.datastore_query_result import DatastoreQueryResult
 from .models.multi_record_ids import MultiRecordIds
 from .models.multi_record_info import MultiRecordInfo
+from .models.multi_record_headers_info import MultiRecordHeadersInfo
+from .models.multi_record_headers_request import MultiRecordHeadersRequest
 from .models.delete_records_exception import DeleteRecordsException
 from .models.copy_record_references_model import CopyRecordReferencesModel
 from .models.create_update_records_response import CreateUpdateRecordsResponse
@@ -61,6 +63,14 @@ class _GetRecordsAsync:
     async def __call__(self, *, body: MultiRecordIds, x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> MultiRecordInfo | None: ...
     async def detailed(self, *, body: MultiRecordIds, x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> Response[AppError | MultiRecordInfo]: ...
 
+class _GetRecordsHeaders:
+    def __call__(self, *, body: MultiRecordHeadersRequest, x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> MultiRecordHeadersInfo | None: ...
+    def detailed(self, *, body: MultiRecordHeadersRequest, x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> Response[AppError | MultiRecordHeadersInfo]: ...
+
+class _GetRecordsHeadersAsync:
+    async def __call__(self, *, body: MultiRecordHeadersRequest, x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> MultiRecordHeadersInfo | None: ...
+    async def detailed(self, *, body: MultiRecordHeadersRequest, x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> Response[AppError | MultiRecordHeadersInfo]: ...
+
 class _BulkDeleteRecords:
     def __call__(self, *, body: list[str], x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> Any | None: ...
     def detailed(self, *, body: list[str], x_collaboration: str | Unset = ..., data_partition_id: str = ...) -> Response[Any | AppError | DeleteRecordsException]: ...
@@ -171,6 +181,7 @@ class StorageFacade:
     fetch_records: _FetchRecords
     get_all_records_1: _GetAllRecords1
     get_records: _GetRecords
+    get_records_headers: _GetRecordsHeaders
     bulk_delete_records: _BulkDeleteRecords
     copy_record_references_between_namespaces: _CopyRecordReferencesBetweenNamespaces
     create_or_update_records: _CreateOrUpdateRecords
@@ -192,6 +203,7 @@ class AsyncStorageFacade:
     fetch_records: _FetchRecordsAsync
     get_all_records_1: _GetAllRecords1Async
     get_records: _GetRecordsAsync
+    get_records_headers: _GetRecordsHeadersAsync
     bulk_delete_records: _BulkDeleteRecordsAsync
     copy_record_references_between_namespaces: _CopyRecordReferencesBetweenNamespacesAsync
     create_or_update_records: _CreateOrUpdateRecordsAsync

osdu_python_client/generated/storage/api/query/get_records_headers.py

@@ -0,0 +1,238 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.app_error import AppError
+from ...models.multi_record_headers_info import MultiRecordHeadersInfo
+from ...models.multi_record_headers_request import MultiRecordHeadersRequest
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    body: MultiRecordHeadersRequest,
+    x_collaboration: str | Unset = UNSET,
+    data_partition_id: str,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+    if not isinstance(x_collaboration, Unset):
+        headers["x-collaboration"] = x_collaboration
+
+    headers["data-partition-id"] = data_partition_id
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/query/records/headers",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> AppError | MultiRecordHeadersInfo | None:
+    if response.status_code == 200:
+        response_200 = MultiRecordHeadersInfo.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = AppError.from_dict(response.json())
+
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = AppError.from_dict(response.json())
+
+        return response_401
+
+    if response.status_code == 403:
+        response_403 = AppError.from_dict(response.json())
+
+        return response_403
+
+    if response.status_code == 404:
+        response_404 = AppError.from_dict(response.json())
+
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = AppError.from_dict(response.json())
+
+        return response_500
+
+    if response.status_code == 502:
+        response_502 = AppError.from_dict(response.json())
+
+        return response_502
+
+    if response.status_code == 503:
+        response_503 = AppError.from_dict(response.json())
+
+        return response_503
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[AppError | MultiRecordHeadersInfo]:
+    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: AuthenticatedClient,
+    body: MultiRecordHeadersRequest,
+    x_collaboration: str | Unset = UNSET,
+    data_partition_id: str,
+) -> Response[AppError | MultiRecordHeadersInfo]:
+    """Fetch multiple records' headers by ID
+
+     The API fetches administrative headers (system-managed fields) for multiple records at once,
+    completely omitting the heavy data payload. Allows up to 1000 IDs.
+
+    Args:
+        x_collaboration (str | Unset):
+        data_partition_id (str):
+        body (MultiRecordHeadersRequest): Record headers query request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[AppError | MultiRecordHeadersInfo]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+        x_collaboration=x_collaboration,
+        data_partition_id=data_partition_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: MultiRecordHeadersRequest,
+    x_collaboration: str | Unset = UNSET,
+    data_partition_id: str,
+) -> AppError | MultiRecordHeadersInfo | None:
+    """Fetch multiple records' headers by ID
+
+     The API fetches administrative headers (system-managed fields) for multiple records at once,
+    completely omitting the heavy data payload. Allows up to 1000 IDs.
+
+    Args:
+        x_collaboration (str | Unset):
+        data_partition_id (str):
+        body (MultiRecordHeadersRequest): Record headers query request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        AppError | MultiRecordHeadersInfo
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+        x_collaboration=x_collaboration,
+        data_partition_id=data_partition_id,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: MultiRecordHeadersRequest,
+    x_collaboration: str | Unset = UNSET,
+    data_partition_id: str,
+) -> Response[AppError | MultiRecordHeadersInfo]:
+    """Fetch multiple records' headers by ID
+
+     The API fetches administrative headers (system-managed fields) for multiple records at once,
+    completely omitting the heavy data payload. Allows up to 1000 IDs.
+
+    Args:
+        x_collaboration (str | Unset):
+        data_partition_id (str):
+        body (MultiRecordHeadersRequest): Record headers query request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[AppError | MultiRecordHeadersInfo]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+        x_collaboration=x_collaboration,
+        data_partition_id=data_partition_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: MultiRecordHeadersRequest,
+    x_collaboration: str | Unset = UNSET,
+    data_partition_id: str,
+) -> AppError | MultiRecordHeadersInfo | None:
+    """Fetch multiple records' headers by ID
+
+     The API fetches administrative headers (system-managed fields) for multiple records at once,
+    completely omitting the heavy data payload. Allows up to 1000 IDs.
+
+    Args:
+        x_collaboration (str | Unset):
+        data_partition_id (str):
+        body (MultiRecordHeadersRequest): Record headers query request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        AppError | MultiRecordHeadersInfo
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+            x_collaboration=x_collaboration,
+            data_partition_id=data_partition_id,
+        )
+    ).parsed

osdu_python_client/generated/storage/models/__init__.py

@@ -32,6 +32,11 @@ from .feature_flag_state import FeatureFlagState
 from .get_all_records_sort_order import GetAllRecordsSortOrder
 from .legal import Legal
 from .legal_status import LegalStatus
+from .multi_record_headers_info import MultiRecordHeadersInfo
+from .multi_record_headers_request import MultiRecordHeadersRequest
+from .multi_record_headers_request_attributes_item import (
+    MultiRecordHeadersRequestAttributesItem,
+)
 from .multi_record_ids import MultiRecordIds
 from .multi_record_info import MultiRecordInfo
 from .multi_record_request import MultiRecordRequest
@@ -44,6 +49,8 @@ from .record import Record
 from .record_ancestry import RecordAncestry
 from .record_bulk_update_param import RecordBulkUpdateParam
 from .record_data import RecordData
+from .record_headers_dto import RecordHeadersDTO
+from .record_headers_dto_tags import RecordHeadersDTOTags
 from .record_merge_patch_request import RecordMergePatchRequest
 from .record_merge_patch_request_data import RecordMergePatchRequestData
 from .record_merge_patch_request_data_additional_property import (
@@ -84,6 +91,9 @@ __all__ = (
     "GetAllRecordsSortOrder",
     "Legal",
     "LegalStatus",
+    "MultiRecordHeadersInfo",
+    "MultiRecordHeadersRequest",
+    "MultiRecordHeadersRequestAttributesItem",
     "MultiRecordIds",
     "MultiRecordInfo",
     "MultiRecordRequest",
@@ -96,6 +106,8 @@ __all__ = (
     "RecordAncestry",
     "RecordBulkUpdateParam",
     "RecordData",
+    "RecordHeadersDTO",
+    "RecordHeadersDTOTags",
     "RecordMergePatchRequest",
     "RecordMergePatchRequestData",
     "RecordMergePatchRequestDataAdditionalProperty",

osdu_python_client/generated/storage/models/multi_record_headers_info.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.record_headers_dto import RecordHeadersDTO
+
+
+T = TypeVar("T", bound="MultiRecordHeadersInfo")
+
+
+@_attrs_define
+class MultiRecordHeadersInfo:
+    """
+    Attributes:
+        records (list[RecordHeadersDTO] | Unset):
+        not_found (list[str] | Unset):
+        invalid_records (list[str] | Unset):
+    """
+
+    records: list[RecordHeadersDTO] | Unset = UNSET
+    not_found: list[str] | Unset = UNSET
+    invalid_records: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        records: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.records, Unset):
+            records = []
+            for records_item_data in self.records:
+                records_item = records_item_data.to_dict()
+                records.append(records_item)
+
+        not_found: list[str] | Unset = UNSET
+        if not isinstance(self.not_found, Unset):
+            not_found = self.not_found
+
+        invalid_records: list[str] | Unset = UNSET
+        if not isinstance(self.invalid_records, Unset):
+            invalid_records = self.invalid_records
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if records is not UNSET:
+            field_dict["records"] = records
+        if not_found is not UNSET:
+            field_dict["notFound"] = not_found
+        if invalid_records is not UNSET:
+            field_dict["invalidRecords"] = invalid_records
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.record_headers_dto import RecordHeadersDTO
+
+        d = dict(src_dict)
+        _records = d.pop("records", UNSET)
+        records: list[RecordHeadersDTO] | Unset = UNSET
+        if _records is not UNSET:
+            records = []
+            for records_item_data in _records:
+                records_item = RecordHeadersDTO.from_dict(records_item_data)
+
+                records.append(records_item)
+
+        not_found = cast(list[str], d.pop("notFound", UNSET))
+
+        invalid_records = cast(list[str], d.pop("invalidRecords", UNSET))
+
+        multi_record_headers_info = cls(
+            records=records,
+            not_found=not_found,
+            invalid_records=invalid_records,
+        )
+
+        multi_record_headers_info.additional_properties = d
+        return multi_record_headers_info
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

osdu_python_client/generated/storage/models/multi_record_headers_request.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.multi_record_headers_request_attributes_item import (
+    MultiRecordHeadersRequestAttributesItem,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MultiRecordHeadersRequest")
+
+
+@_attrs_define
+class MultiRecordHeadersRequest:
+    """Record headers query request
+
+    Attributes:
+        records (list[str]):
+        attributes (list[MultiRecordHeadersRequestAttributesItem] | Unset): Filter/projection: list of record header
+            attributes to return. If specified, only these attributes (plus 'id') will be returned. If omitted or empty, all
+            record header fields are returned.
+    """
+
+    records: list[str]
+    attributes: list[MultiRecordHeadersRequestAttributesItem] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        records = self.records
+
+        attributes: list[str] | Unset = UNSET
+        if not isinstance(self.attributes, Unset):
+            attributes = []
+            for attributes_item_data in self.attributes:
+                attributes_item = attributes_item_data.value
+                attributes.append(attributes_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "records": records,
+            }
+        )
+        if attributes is not UNSET:
+            field_dict["attributes"] = attributes
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        records = cast(list[str], d.pop("records"))
+
+        _attributes = d.pop("attributes", UNSET)
+        attributes: list[MultiRecordHeadersRequestAttributesItem] | Unset = UNSET
+        if _attributes is not UNSET:
+            attributes = []
+            for attributes_item_data in _attributes:
+                attributes_item = MultiRecordHeadersRequestAttributesItem(
+                    attributes_item_data
+                )
+
+                attributes.append(attributes_item)
+
+        multi_record_headers_request = cls(
+            records=records,
+            attributes=attributes,
+        )
+
+        multi_record_headers_request.additional_properties = d
+        return multi_record_headers_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

osdu_python_client/generated/storage/models/multi_record_headers_request_attributes_item.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class MultiRecordHeadersRequestAttributesItem(str, Enum):
+    ACL = "acl"
+    ANCESTRY = "ancestry"
+    CREATETIME = "createTime"
+    CREATEUSER = "createUser"
+    KIND = "kind"
+    LEGAL = "legal"
+    MODIFYTIME = "modifyTime"
+    MODIFYUSER = "modifyUser"
+    TAGS = "tags"
+    VERSION = "version"
+
+    def __str__(self) -> str:
+        return str(self.value)