perceptic-core-client 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

perceptic_core_client/perceptic_core_client/models/progress_event.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ProgressEvent(BaseModel):
+    """
+    ProgressEvent
+    """ # noqa: E501
+    sequence: Optional[StrictInt] = None
+    payload: Optional[Dict[str, Any]] = None
+    type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["sequence", "payload", "type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProgressEvent from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProgressEvent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "sequence": obj.get("sequence"),
+            "payload": obj.get("payload"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

perceptic_core_client/perceptic_core_client/models/remote_file_system_api_dto.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from perceptic_core_client.models.file_system_root_metadata_api_dto import FileSystemRootMetadataApiDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteFileSystemApiDto(BaseModel):
+    """
+    RemoteFileSystemApiDto
+    """ # noqa: E501
+    rid: Optional[StrictStr] = None
+    name: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    metadata: Optional[FileSystemRootMetadataApiDto] = None
+    connection_rid: Optional[StrictStr] = Field(default=None, alias="connectionRid")
+    type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["rid", "name", "description", "metadata", "connectionRid", "type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RemoteFileSystemApiDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of metadata
+        if self.metadata:
+            _dict['metadata'] = self.metadata.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RemoteFileSystemApiDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rid": obj.get("rid"),
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "metadata": FileSystemRootMetadataApiDto.from_dict(obj["metadata"]) if obj.get("metadata") is not None else None,
+            "connectionRid": obj.get("connectionRid"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

perceptic_core_client/perceptic_core_client/models/request_for_input_event.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RequestForInputEvent(BaseModel):
+    """
+    RequestForInputEvent
+    """ # noqa: E501
+    sequence: Optional[StrictInt] = None
+    requested_data: Optional[Dict[str, Any]] = Field(default=None, alias="requestedData")
+    provided_data: Optional[Dict[str, Any]] = Field(default=None, alias="providedData")
+    type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["sequence", "requestedData", "providedData", "type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RequestForInputEvent from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if provided_data (nullable) is None
+        # and model_fields_set contains the field
+        if self.provided_data is None and "provided_data" in self.model_fields_set:
+            _dict['providedData'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RequestForInputEvent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "sequence": obj.get("sequence"),
+            "requestedData": obj.get("requestedData"),
+            "providedData": obj.get("providedData"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

perceptic_core_client/perceptic_core_client/models/resource_entry_dto.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from perceptic_core_client.models.resource_metadata_dto import ResourceMetadataDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResourceEntryDto(BaseModel):
+    """
+    ResourceEntryDto
+    """ # noqa: E501
+    resource_id: Optional[StrictStr] = Field(default=None, alias="resourceId")
+    metadata: Optional[ResourceMetadataDto] = None
+    __properties: ClassVar[List[str]] = ["resourceId", "metadata"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ResourceEntryDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of metadata
+        if self.metadata:
+            _dict['metadata'] = self.metadata.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResourceEntryDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "resourceId": obj.get("resourceId"),
+            "metadata": ResourceMetadataDto.from_dict(obj["metadata"]) if obj.get("metadata") is not None else None
+        })
+        return _obj
+
+

perceptic_core_client/perceptic_core_client/models/resource_id.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResourceId(BaseModel):
+    """
+    ResourceId
+    """ # noqa: E501
+    id: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ResourceId from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResourceId from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id")
+        })
+        return _obj
+
+

perceptic_core_client/perceptic_core_client/models/resource_identifier.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResourceIdentifier(BaseModel):
+    """
+    ResourceIdentifier
+    """ # noqa: E501
+    resource_identifier: Optional[StrictStr] = Field(default=None, alias="resourceIdentifier")
+    service_index: Optional[StrictInt] = Field(default=None, alias="serviceIndex")
+    instance_index: Optional[StrictInt] = Field(default=None, alias="instanceIndex")
+    type_index: Optional[StrictInt] = Field(default=None, alias="typeIndex")
+    service: Optional[StrictStr] = None
+    instance: Optional[StrictStr] = None
+    type: Optional[StrictStr] = None
+    locator: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["resourceIdentifier", "serviceIndex", "instanceIndex", "typeIndex", "service", "instance", "type", "locator"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ResourceIdentifier from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResourceIdentifier from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "resourceIdentifier": obj.get("resourceIdentifier"),
+            "serviceIndex": obj.get("serviceIndex"),
+            "instanceIndex": obj.get("instanceIndex"),
+            "typeIndex": obj.get("typeIndex"),
+            "service": obj.get("service"),
+            "instance": obj.get("instance"),
+            "type": obj.get("type"),
+            "locator": obj.get("locator")
+        })
+        return _obj
+
+

perceptic_core_client/perceptic_core_client/models/resource_metadata_dto.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    perceptic-core-server API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.0.1-SNAPSHOT
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from perceptic_core_client.models.resource_type_dto import ResourceTypeDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResourceMetadataDto(BaseModel):
+    """
+    ResourceMetadataDto
+    """ # noqa: E501
+    files_system_rid: Optional[StrictStr] = Field(default=None, alias="filesSystemRid")
+    resource_id: Optional[StrictStr] = Field(default=None, alias="resourceId")
+    uri: Optional[StrictStr] = None
+    name: Optional[StrictStr] = None
+    type: Optional[ResourceTypeDto] = None
+    path: Optional[StrictStr] = None
+    extension: Optional[StrictStr] = None
+    size_in_bytes: Optional[StrictInt] = Field(default=None, alias="sizeInBytes")
+    last_modified: Optional[datetime] = Field(default=None, alias="lastModified")
+    etag: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["filesSystemRid", "resourceId", "uri", "name", "type", "path", "extension", "sizeInBytes", "lastModified", "etag"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ResourceMetadataDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if extension (nullable) is None
+        # and model_fields_set contains the field
+        if self.extension is None and "extension" in self.model_fields_set:
+            _dict['extension'] = None
+
+        # set to None if size_in_bytes (nullable) is None
+        # and model_fields_set contains the field
+        if self.size_in_bytes is None and "size_in_bytes" in self.model_fields_set:
+            _dict['sizeInBytes'] = None
+
+        # set to None if etag (nullable) is None
+        # and model_fields_set contains the field
+        if self.etag is None and "etag" in self.model_fields_set:
+            _dict['etag'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResourceMetadataDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "filesSystemRid": obj.get("filesSystemRid"),
+            "resourceId": obj.get("resourceId"),
+            "uri": obj.get("uri"),
+            "name": obj.get("name"),
+            "type": obj.get("type"),
+            "path": obj.get("path"),
+            "extension": obj.get("extension"),
+            "sizeInBytes": obj.get("sizeInBytes"),
+            "lastModified": obj.get("lastModified"),
+            "etag": obj.get("etag")
+        })
+        return _obj
+
+