python-alfresco-api 1.0.0__py3-none-any.whl

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/__init__.py

@@ -0,0 +1,25 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from .discovery_entry import DiscoveryEntry
+from .entitlements_info import EntitlementsInfo
+from .error import Error
+from .error_error import ErrorError
+from .license_info import LicenseInfo
+from .module_info import ModuleInfo
+from .repository_entry import RepositoryEntry
+from .repository_info import RepositoryInfo
+from .status_info import StatusInfo
+from .version_info import VersionInfo
+
+__all__ = (
+    "DiscoveryEntry",
+    "EntitlementsInfo",
+    "Error",
+    "ErrorError",
+    "LicenseInfo",
+    "ModuleInfo",
+    "RepositoryEntry",
+    "RepositoryInfo",
+    "StatusInfo",
+    "VersionInfo",
+)

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/discovery_entry.py

@@ -0,0 +1,65 @@
+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.repository_entry import RepositoryEntry
+
+
+T = TypeVar("T", bound="DiscoveryEntry")
+
+
+@_attrs_define
+class DiscoveryEntry:
+    """
+    Attributes:
+        entry (RepositoryEntry):
+    """
+
+    entry: "RepositoryEntry"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entry = self.entry.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entry": entry,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.repository_entry import RepositoryEntry
+
+        d = dict(src_dict)
+        entry = RepositoryEntry.from_dict(d.pop("entry"))
+
+        discovery_entry = cls(
+            entry=entry,
+        )
+
+        discovery_entry.additional_properties = d
+        return discovery_entry
+
+    @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

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/entitlements_info.py

@@ -0,0 +1,86 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="EntitlementsInfo")
+
+
+@_attrs_define
+class EntitlementsInfo:
+    """
+    Attributes:
+        is_cluster_enabled (Union[Unset, bool]):  Default: False.
+        is_cryptodoc_enabled (Union[Unset, bool]):  Default: False.
+        max_docs (Union[Unset, int]):
+        max_users (Union[Unset, int]):
+    """
+
+    is_cluster_enabled: Union[Unset, bool] = False
+    is_cryptodoc_enabled: Union[Unset, bool] = False
+    max_docs: Union[Unset, int] = UNSET
+    max_users: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        is_cluster_enabled = self.is_cluster_enabled
+
+        is_cryptodoc_enabled = self.is_cryptodoc_enabled
+
+        max_docs = self.max_docs
+
+        max_users = self.max_users
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if is_cluster_enabled is not UNSET:
+            field_dict["isClusterEnabled"] = is_cluster_enabled
+        if is_cryptodoc_enabled is not UNSET:
+            field_dict["isCryptodocEnabled"] = is_cryptodoc_enabled
+        if max_docs is not UNSET:
+            field_dict["maxDocs"] = max_docs
+        if max_users is not UNSET:
+            field_dict["maxUsers"] = max_users
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        is_cluster_enabled = d.pop("isClusterEnabled", UNSET)
+
+        is_cryptodoc_enabled = d.pop("isCryptodocEnabled", UNSET)
+
+        max_docs = d.pop("maxDocs", UNSET)
+
+        max_users = d.pop("maxUsers", UNSET)
+
+        entitlements_info = cls(
+            is_cluster_enabled=is_cluster_enabled,
+            is_cryptodoc_enabled=is_cryptodoc_enabled,
+            max_docs=max_docs,
+            max_users=max_users,
+        )
+
+        entitlements_info.additional_properties = d
+        return entitlements_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

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/error.py

@@ -0,0 +1,65 @@
+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.error_error import ErrorError
+
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """
+    Attributes:
+        error (ErrorError):
+    """
+
+    error: "ErrorError"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.error_error import ErrorError
+
+        d = dict(src_dict)
+        error = ErrorError.from_dict(d.pop("error"))
+
+        error = cls(
+            error=error,
+        )
+
+        error.additional_properties = d
+        return error
+
+    @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

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/error_error.py

@@ -0,0 +1,104 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ErrorError")
+
+
+@_attrs_define
+class ErrorError:
+    """
+    Attributes:
+        brief_summary (Union[Unset, str]):
+        description_url (Union[Unset, str]):
+        error_key (Union[Unset, str]):
+        log_id (Union[Unset, str]):
+        stack_trace (Union[Unset, str]):
+        status_code (Union[Unset, int]):
+    """
+
+    brief_summary: Union[Unset, str] = UNSET
+    description_url: Union[Unset, str] = UNSET
+    error_key: Union[Unset, str] = UNSET
+    log_id: Union[Unset, str] = UNSET
+    stack_trace: Union[Unset, str] = UNSET
+    status_code: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        brief_summary = self.brief_summary
+
+        description_url = self.description_url
+
+        error_key = self.error_key
+
+        log_id = self.log_id
+
+        stack_trace = self.stack_trace
+
+        status_code = self.status_code
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if brief_summary is not UNSET:
+            field_dict["briefSummary"] = brief_summary
+        if description_url is not UNSET:
+            field_dict["descriptionURL"] = description_url
+        if error_key is not UNSET:
+            field_dict["errorKey"] = error_key
+        if log_id is not UNSET:
+            field_dict["logId"] = log_id
+        if stack_trace is not UNSET:
+            field_dict["stackTrace"] = stack_trace
+        if status_code is not UNSET:
+            field_dict["statusCode"] = status_code
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        brief_summary = d.pop("briefSummary", UNSET)
+
+        description_url = d.pop("descriptionURL", UNSET)
+
+        error_key = d.pop("errorKey", UNSET)
+
+        log_id = d.pop("logId", UNSET)
+
+        stack_trace = d.pop("stackTrace", UNSET)
+
+        status_code = d.pop("statusCode", UNSET)
+
+        error_error = cls(
+            brief_summary=brief_summary,
+            description_url=description_url,
+            error_key=error_key,
+            log_id=log_id,
+            stack_trace=stack_trace,
+            status_code=status_code,
+        )
+
+        error_error.additional_properties = d
+        return error_error
+
+    @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

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/license_info.py

@@ -0,0 +1,117 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.entitlements_info import EntitlementsInfo
+
+
+T = TypeVar("T", bound="LicenseInfo")
+
+
+@_attrs_define
+class LicenseInfo:
+    """
+    Attributes:
+        expires_at (datetime.datetime):
+        holder (str):
+        issued_at (datetime.datetime):
+        mode (str):
+        remaining_days (int):
+        entitlements (Union[Unset, EntitlementsInfo]):
+    """
+
+    expires_at: datetime.datetime
+    holder: str
+    issued_at: datetime.datetime
+    mode: str
+    remaining_days: int
+    entitlements: Union[Unset, "EntitlementsInfo"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        expires_at = self.expires_at.isoformat()
+
+        holder = self.holder
+
+        issued_at = self.issued_at.isoformat()
+
+        mode = self.mode
+
+        remaining_days = self.remaining_days
+
+        entitlements: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.entitlements, Unset):
+            entitlements = self.entitlements.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expiresAt": expires_at,
+                "holder": holder,
+                "issuedAt": issued_at,
+                "mode": mode,
+                "remainingDays": remaining_days,
+            }
+        )
+        if entitlements is not UNSET:
+            field_dict["entitlements"] = entitlements
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.entitlements_info import EntitlementsInfo
+
+        d = dict(src_dict)
+        expires_at = isoparse(d.pop("expiresAt"))
+
+        holder = d.pop("holder")
+
+        issued_at = isoparse(d.pop("issuedAt"))
+
+        mode = d.pop("mode")
+
+        remaining_days = d.pop("remainingDays")
+
+        _entitlements = d.pop("entitlements", UNSET)
+        entitlements: Union[Unset, EntitlementsInfo]
+        if isinstance(_entitlements, Unset):
+            entitlements = UNSET
+        else:
+            entitlements = EntitlementsInfo.from_dict(_entitlements)
+
+        license_info = cls(
+            expires_at=expires_at,
+            holder=holder,
+            issued_at=issued_at,
+            mode=mode,
+            remaining_days=remaining_days,
+            entitlements=entitlements,
+        )
+
+        license_info.additional_properties = d
+        return license_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

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/module_info.py

@@ -0,0 +1,131 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ModuleInfo")
+
+
+@_attrs_define
+class ModuleInfo:
+    """
+    Attributes:
+        description (Union[Unset, str]):
+        id (Union[Unset, str]):
+        install_date (Union[Unset, datetime.datetime]):
+        install_state (Union[Unset, str]):
+        title (Union[Unset, str]):
+        version (Union[Unset, str]):
+        version_max (Union[Unset, str]):
+        version_min (Union[Unset, str]):
+    """
+
+    description: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    install_date: Union[Unset, datetime.datetime] = UNSET
+    install_state: Union[Unset, str] = UNSET
+    title: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    version_max: Union[Unset, str] = UNSET
+    version_min: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        description = self.description
+
+        id = self.id
+
+        install_date: Union[Unset, str] = UNSET
+        if not isinstance(self.install_date, Unset):
+            install_date = self.install_date.isoformat()
+
+        install_state = self.install_state
+
+        title = self.title
+
+        version = self.version
+
+        version_max = self.version_max
+
+        version_min = self.version_min
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if description is not UNSET:
+            field_dict["description"] = description
+        if id is not UNSET:
+            field_dict["id"] = id
+        if install_date is not UNSET:
+            field_dict["installDate"] = install_date
+        if install_state is not UNSET:
+            field_dict["installState"] = install_state
+        if title is not UNSET:
+            field_dict["title"] = title
+        if version is not UNSET:
+            field_dict["version"] = version
+        if version_max is not UNSET:
+            field_dict["versionMax"] = version_max
+        if version_min is not UNSET:
+            field_dict["versionMin"] = version_min
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        description = d.pop("description", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        _install_date = d.pop("installDate", UNSET)
+        install_date: Union[Unset, datetime.datetime]
+        if isinstance(_install_date, Unset):
+            install_date = UNSET
+        else:
+            install_date = isoparse(_install_date)
+
+        install_state = d.pop("installState", UNSET)
+
+        title = d.pop("title", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        version_max = d.pop("versionMax", UNSET)
+
+        version_min = d.pop("versionMin", UNSET)
+
+        module_info = cls(
+            description=description,
+            id=id,
+            install_date=install_date,
+            install_state=install_state,
+            title=title,
+            version=version,
+            version_max=version_max,
+            version_min=version_min,
+        )
+
+        module_info.additional_properties = d
+        return module_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

python_alfresco_api/raw_clients/alfresco_discovery_client/discovery_client/models/repository_entry.py

@@ -0,0 +1,65 @@
+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.repository_info import RepositoryInfo
+
+
+T = TypeVar("T", bound="RepositoryEntry")
+
+
+@_attrs_define
+class RepositoryEntry:
+    """
+    Attributes:
+        repository (RepositoryInfo):
+    """
+
+    repository: "RepositoryInfo"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        repository = self.repository.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "repository": repository,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.repository_info import RepositoryInfo
+
+        d = dict(src_dict)
+        repository = RepositoryInfo.from_dict(d.pop("repository"))
+
+        repository_entry = cls(
+            repository=repository,
+        )
+
+        repository_entry.additional_properties = d
+        return repository_entry
+
+    @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