osdu-python-client 0.4.1__py3-none-any.whl

osdu_python_client/generated/file/models/legal_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LegalStatus(str, Enum):
+    COMPLIANT = "compliant"
+    INCOMPLIANT = "incompliant"
+
+    def __str__(self) -> str:
+        return str(self.value)

osdu_python_client/generated/file/models/location_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.location_response_location import LocationResponseLocation
+
+
+T = TypeVar("T", bound="LocationResponse")
+
+
+@_attrs_define
+class LocationResponse:
+    """
+    Attributes:
+        file_id (str | Unset):
+        location (LocationResponseLocation | Unset):
+    """
+
+    file_id: str | Unset = UNSET
+    location: LocationResponseLocation | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        file_id = self.file_id
+
+        location: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.location, Unset):
+            location = self.location.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if file_id is not UNSET:
+            field_dict["FileID"] = file_id
+        if location is not UNSET:
+            field_dict["Location"] = location
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.location_response_location import LocationResponseLocation
+
+        d = dict(src_dict)
+        file_id = d.pop("FileID", UNSET)
+
+        _location = d.pop("Location", UNSET)
+        location: LocationResponseLocation | Unset
+        if isinstance(_location, Unset):
+            location = UNSET
+        else:
+            location = LocationResponseLocation.from_dict(_location)
+
+        location_response = cls(
+            file_id=file_id,
+            location=location,
+        )
+
+        location_response.additional_properties = d
+        return location_response
+
+    @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/file/models/location_response_location.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="LocationResponseLocation")
+
+
+@_attrs_define
+class LocationResponseLocation:
+    """ """
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        location_response_location = cls()
+
+        location_response_location.additional_properties = d
+        return location_response_location
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/file/models/record_version.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.acl import Acl
+    from ..models.ancestry import Ancestry
+    from ..models.file_data import FileData
+    from ..models.legal import Legal
+    from ..models.record_version_meta_item import RecordVersionMetaItem
+    from ..models.record_version_tags import RecordVersionTags
+
+
+T = TypeVar("T", bound="RecordVersion")
+
+
+@_attrs_define
+class RecordVersion:
+    """Metadata record
+
+    Attributes:
+        kind (str): Kind of data being ingested. Must follow the naming
+              convention:data-Partition-Id}:dataset-name}:record-type}:version}. Example: osdu:wks:dataset--
+            File.Generic:1.0.0.
+        legal (Legal):
+        data (FileData): The file data container containing all necessary details of the file record
+        acl (Acl): Access control lists defining which groups can view or own a record.
+        id (str | Unset): Unique identifier generated by the system for the file metadata record.
+        ancestry (Ancestry | Unset): A named list of entities in the data lake as a dictionary item.
+        version (int | Unset): The version number of this OSDU resource; set by the framework. Example:
+            1831253916104085.
+        meta (list[RecordVersionMetaItem] | Unset):
+        tags (RecordVersionTags | Unset):
+    """
+
+    kind: str
+    legal: Legal
+    data: FileData
+    acl: Acl
+    id: str | Unset = UNSET
+    ancestry: Ancestry | Unset = UNSET
+    version: int | Unset = UNSET
+    meta: list[RecordVersionMetaItem] | Unset = UNSET
+    tags: RecordVersionTags | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        kind = self.kind
+
+        legal = self.legal.to_dict()
+
+        data = self.data.to_dict()
+
+        acl = self.acl.to_dict()
+
+        id = self.id
+
+        ancestry: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.ancestry, Unset):
+            ancestry = self.ancestry.to_dict()
+
+        version = self.version
+
+        meta: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.meta, Unset):
+            meta = []
+            for meta_item_data in self.meta:
+                meta_item = meta_item_data.to_dict()
+                meta.append(meta_item)
+
+        tags: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "kind": kind,
+                "legal": legal,
+                "data": data,
+                "acl": acl,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if ancestry is not UNSET:
+            field_dict["ancestry"] = ancestry
+        if version is not UNSET:
+            field_dict["version"] = version
+        if meta is not UNSET:
+            field_dict["meta"] = meta
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.acl import Acl
+        from ..models.ancestry import Ancestry
+        from ..models.file_data import FileData
+        from ..models.legal import Legal
+        from ..models.record_version_meta_item import RecordVersionMetaItem
+        from ..models.record_version_tags import RecordVersionTags
+
+        d = dict(src_dict)
+        kind = d.pop("kind")
+
+        legal = Legal.from_dict(d.pop("legal"))
+
+        data = FileData.from_dict(d.pop("data"))
+
+        acl = Acl.from_dict(d.pop("acl"))
+
+        id = d.pop("id", UNSET)
+
+        _ancestry = d.pop("ancestry", UNSET)
+        ancestry: Ancestry | Unset
+        if isinstance(_ancestry, Unset):
+            ancestry = UNSET
+        else:
+            ancestry = Ancestry.from_dict(_ancestry)
+
+        version = d.pop("version", UNSET)
+
+        _meta = d.pop("meta", UNSET)
+        meta: list[RecordVersionMetaItem] | Unset = UNSET
+        if _meta is not UNSET:
+            meta = []
+            for meta_item_data in _meta:
+                meta_item = RecordVersionMetaItem.from_dict(meta_item_data)
+
+                meta.append(meta_item)
+
+        _tags = d.pop("tags", UNSET)
+        tags: RecordVersionTags | Unset
+        if isinstance(_tags, Unset):
+            tags = UNSET
+        else:
+            tags = RecordVersionTags.from_dict(_tags)
+
+        record_version = cls(
+            kind=kind,
+            legal=legal,
+            data=data,
+            acl=acl,
+            id=id,
+            ancestry=ancestry,
+            version=version,
+            meta=meta,
+            tags=tags,
+        )
+
+        record_version.additional_properties = d
+        return record_version
+
+    @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/file/models/record_version_meta_item.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.record_version_meta_item_additional_property import (
+        RecordVersionMetaItemAdditionalProperty,
+    )
+
+
+T = TypeVar("T", bound="RecordVersionMetaItem")
+
+
+@_attrs_define
+class RecordVersionMetaItem:
+    """ """
+
+    additional_properties: dict[str, RecordVersionMetaItemAdditionalProperty] = (
+        _attrs_field(init=False, factory=dict)
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.record_version_meta_item_additional_property import (
+            RecordVersionMetaItemAdditionalProperty,
+        )
+
+        d = dict(src_dict)
+        record_version_meta_item = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = RecordVersionMetaItemAdditionalProperty.from_dict(
+                prop_dict
+            )
+
+            additional_properties[prop_name] = additional_property
+
+        record_version_meta_item.additional_properties = additional_properties
+        return record_version_meta_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> RecordVersionMetaItemAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(
+        self, key: str, value: RecordVersionMetaItemAdditionalProperty
+    ) -> 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/file/models/record_version_meta_item_additional_property.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RecordVersionMetaItemAdditionalProperty")
+
+
+@_attrs_define
+class RecordVersionMetaItemAdditionalProperty:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        record_version_meta_item_additional_property = cls()
+
+        record_version_meta_item_additional_property.additional_properties = d
+        return record_version_meta_item_additional_property
+
+    @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/file/models/record_version_tags.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RecordVersionTags")
+
+
+@_attrs_define
+class RecordVersionTags:
+    """ """
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        record_version_tags = cls()
+
+        record_version_tags.additional_properties = d
+        return record_version_tags
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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/file/models/revoke_url_body.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RevokeURLBody")
+
+
+@_attrs_define
+class RevokeURLBody:
+    """ """
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        revoke_url_body = cls()
+
+        revoke_url_body.additional_properties = d
+        return revoke_url_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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