funapi-sciencedb 1.0.1__py3-none-any.whl

sciencedb/models/sushi_report_page.py

@@ -0,0 +1,93 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sushi_page_meta import SUSHIPageMeta
+    from ..models.sushi_report_list import SUSHIReportList
+
+
+T = TypeVar("T", bound="SUSHIReportPage")
+
+
+@_attrs_define
+class SUSHIReportPage:
+    """page wrapper of reports
+
+    Attributes:
+        reports (Union[Unset, List['SUSHIReportList']]): list of reports
+        meta (Union[Unset, SUSHIPageMeta]): page wrapper of reports
+    """
+
+    reports: Union[Unset, List["SUSHIReportList"]] = UNSET
+    meta: Union[Unset, "SUSHIPageMeta"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        reports: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.reports, Unset):
+            reports = []
+            for reports_item_data in self.reports:
+                reports_item = reports_item_data.to_dict()
+                reports.append(reports_item)
+
+        meta: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.meta, Unset):
+            meta = self.meta.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if reports is not UNSET:
+            field_dict["reports"] = reports
+        if meta is not UNSET:
+            field_dict["meta"] = meta
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.sushi_page_meta import SUSHIPageMeta
+        from ..models.sushi_report_list import SUSHIReportList
+
+        d = src_dict.copy()
+        reports = []
+        _reports = d.pop("reports", UNSET)
+        for reports_item_data in _reports or []:
+            reports_item = SUSHIReportList.from_dict(reports_item_data)
+
+            reports.append(reports_item)
+
+        _meta = d.pop("meta", UNSET)
+        meta: Union[Unset, SUSHIPageMeta]
+        if isinstance(_meta, Unset):
+            meta = UNSET
+        else:
+            meta = SUSHIPageMeta.from_dict(_meta)
+
+        sushi_report_page = cls(
+            reports=reports,
+            meta=meta,
+        )
+
+        sushi_report_page.additional_properties = d
+        return sushi_report_page
+
+    @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

sciencedb/models/sushi_service_status.py

@@ -0,0 +1,118 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sushi_service_status_alerts_item import SUSHIServiceStatusAlertsItem
+
+
+T = TypeVar("T", bound="SUSHIServiceStatus")
+
+
+@_attrs_define
+class SUSHIServiceStatus:
+    """
+    Attributes:
+        service_active (bool): Indicator if the service is currently able to deliver reports. Example: True.
+        alerts (Union[Unset, List['SUSHIServiceStatusAlertsItem']]): Any alerts related to service interuptions and
+            status.
+        description (Union[Unset, str]): Description of the service. Example: COUNTER Research Data Usage Reports for
+            the UK Data Service - ReShare..
+        note (Union[Unset, str]): A general note about the service. Example: A given customer can request a maximum of 5
+            requests per day for a given report.
+        registry_url (Union[Unset, str]): If available, the URL separate registry with additional information about the
+            service. Example: https://www.projectcounter.org/counter-user/ebsco-database/.
+    """
+
+    service_active: bool
+    alerts: Union[Unset, List["SUSHIServiceStatusAlertsItem"]] = UNSET
+    description: Union[Unset, str] = UNSET
+    note: Union[Unset, str] = UNSET
+    registry_url: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        service_active = self.service_active
+
+        alerts: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.alerts, Unset):
+            alerts = []
+            for alerts_item_data in self.alerts:
+                alerts_item = alerts_item_data.to_dict()
+                alerts.append(alerts_item)
+
+        description = self.description
+
+        note = self.note
+
+        registry_url = self.registry_url
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ServiceActive": service_active,
+            }
+        )
+        if alerts is not UNSET:
+            field_dict["Alerts"] = alerts
+        if description is not UNSET:
+            field_dict["Description"] = description
+        if note is not UNSET:
+            field_dict["Note"] = note
+        if registry_url is not UNSET:
+            field_dict["RegistryURL"] = registry_url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.sushi_service_status_alerts_item import (
+            SUSHIServiceStatusAlertsItem,
+        )
+
+        d = src_dict.copy()
+        service_active = d.pop("ServiceActive")
+
+        alerts = []
+        _alerts = d.pop("Alerts", UNSET)
+        for alerts_item_data in _alerts or []:
+            alerts_item = SUSHIServiceStatusAlertsItem.from_dict(alerts_item_data)
+
+            alerts.append(alerts_item)
+
+        description = d.pop("Description", UNSET)
+
+        note = d.pop("Note", UNSET)
+
+        registry_url = d.pop("RegistryURL", UNSET)
+
+        sushi_service_status = cls(
+            service_active=service_active,
+            alerts=alerts,
+            description=description,
+            note=note,
+            registry_url=registry_url,
+        )
+
+        sushi_service_status.additional_properties = d
+        return sushi_service_status
+
+    @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

sciencedb/models/sushi_service_status_alerts_item.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SUSHIServiceStatusAlertsItem")
+
+
+@_attrs_define
+class SUSHIServiceStatusAlertsItem:
+    """ """
+
+    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: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        sushi_service_status_alerts_item = cls()
+
+        sushi_service_status_alerts_item.additional_properties = d
+        return sushi_service_status_alerts_item
+
+    @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

sciencedb/types.py

@@ -0,0 +1,53 @@
+"""Contains some shared types for properties"""
+
+from http import HTTPStatus
+from typing import (
+    BinaryIO,
+    Generic,
+    Literal,
+    MutableMapping,
+    Optional,
+    Tuple,
+    TypeVar,
+)
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+FileJsonType = Tuple[Optional[str], BinaryIO, Optional[str]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileJsonType:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["File", "Response", "FileJsonType", "Unset", "UNSET"]