funapi-sciencedb 1.0.1__py3-none-any.whl

sciencedb/models/sushi_error_model.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.sushi_error_model_severity import SUSHIErrorModelSeverity
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SUSHIErrorModel")
+
+
+@_attrs_define
+class SUSHIErrorModel:
+    """Generalized format for presenting errors and exceptions.
+
+    Attributes:
+        code (int): Error number. See table of error. Example: 3040.
+        message (str): Text describing the error. Example: Partial Data Returned..
+        severity (SUSHIErrorModelSeverity): Severity of the error. Example: Warning.
+        data (Union[Unset, str]): Additional data provided by the server to clarify the error. Example: Usage data has
+            not been processed for all requested months..
+        help_url (Union[Unset, str]): URL describing error details.
+    """
+
+    code: int
+    message: str
+    severity: SUSHIErrorModelSeverity
+    data: Union[Unset, str] = UNSET
+    help_url: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        code = self.code
+
+        message = self.message
+
+        severity = self.severity.value
+
+        data = self.data
+
+        help_url = self.help_url
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "Code": code,
+                "Message": message,
+                "Severity": severity,
+            }
+        )
+        if data is not UNSET:
+            field_dict["Data"] = data
+        if help_url is not UNSET:
+            field_dict["Help_URL"] = help_url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        code = d.pop("Code")
+
+        message = d.pop("Message")
+
+        severity = SUSHIErrorModelSeverity(d.pop("Severity"))
+
+        data = d.pop("Data", UNSET)
+
+        help_url = d.pop("Help_URL", UNSET)
+
+        sushi_error_model = cls(
+            code=code,
+            message=message,
+            severity=severity,
+            data=data,
+            help_url=help_url,
+        )
+
+        sushi_error_model.additional_properties = d
+        return sushi_error_model
+
+    @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_error_model_severity.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SUSHIErrorModelSeverity(str, Enum):
+    DEBUG = "Debug"
+    FATAL = "Fatal"
+    INFO = "Info"
+    WARNING = "Warning"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/sushi_page_meta.py

@@ -0,0 +1,77 @@
+from typing import 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
+
+T = TypeVar("T", bound="SUSHIPageMeta")
+
+
+@_attrs_define
+class SUSHIPageMeta:
+    """page wrapper of reports
+
+    Attributes:
+        page (Union[Unset, int]): page number. Example: 1.
+        total (Union[Unset, int]): count of reports. Example: 100.
+        total_pages (Union[Unset, int]): count of pages. Example: 10.
+    """
+
+    page: Union[Unset, int] = UNSET
+    total: Union[Unset, int] = UNSET
+    total_pages: Union[Unset, int] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        page = self.page
+
+        total = self.total
+
+        total_pages = self.total_pages
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if page is not UNSET:
+            field_dict["page"] = page
+        if total is not UNSET:
+            field_dict["total"] = total
+        if total_pages is not UNSET:
+            field_dict["totalPages"] = total_pages
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        page = d.pop("page", UNSET)
+
+        total = d.pop("total", UNSET)
+
+        total_pages = d.pop("totalPages", UNSET)
+
+        sushi_page_meta = cls(
+            page=page,
+            total=total,
+            total_pages=total_pages,
+        )
+
+        sushi_page_meta.additional_properties = d
+        return sushi_page_meta
+
+    @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_report.py

@@ -0,0 +1,72 @@
+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.counter_dataset_report import COUNTERDatasetReport
+
+
+T = TypeVar("T", bound="SUSHIReport")
+
+
+@_attrs_define
+class SUSHIReport:
+    """
+    Attributes:
+        report (Union[Unset, COUNTERDatasetReport]): Describes the formatting needs for the COUNTER Dataset Report.
+            Response may include the Report_Header (optional), Report_Datasets (usage stats).
+    """
+
+    report: Union[Unset, "COUNTERDatasetReport"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        report: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.report, Unset):
+            report = self.report.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if report is not UNSET:
+            field_dict["report"] = report
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.counter_dataset_report import COUNTERDatasetReport
+
+        d = src_dict.copy()
+        _report = d.pop("report", UNSET)
+        report: Union[Unset, COUNTERDatasetReport]
+        if isinstance(_report, Unset):
+            report = UNSET
+        else:
+            report = COUNTERDatasetReport.from_dict(_report)
+
+        sushi_report = cls(
+            report=report,
+        )
+
+        sushi_report.additional_properties = d
+        return sushi_report
+
+    @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_report_header.py

@@ -0,0 +1,189 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sushi_error_model import SUSHIErrorModel
+    from ..models.sushi_report_header_report_attributes_item import (
+        SUSHIReportHeaderReportAttributesItem,
+    )
+    from ..models.sushi_report_header_report_filters_item import (
+        SUSHIReportHeaderReportFiltersItem,
+    )
+
+
+T = TypeVar("T", bound="SUSHIReportHeader")
+
+
+@_attrs_define
+class SUSHIReportHeader:
+    """Generalized report header that defines the requested report, the requestor, the customer, filters applied,
+    reportAttributes applied and any exceptions.
+
+        Attributes:
+            release (str): The release or version of the report. Example: RD1.
+            report_id (str): The report ID or code or shortname. Typically this will be the same code provided in the Report
+                parameter of the request. Example: DSR.
+            report_name (str): The long name of the report. Example: Dataset Report.
+            created (Union[Unset, datetime.datetime]): Time the report was prepared
+            created_by (Union[Unset, str]): Name of the organization producing the report. Example: Science Data Bank.
+            exceptions (Union[Unset, List['SUSHIErrorModel']]): Series of exceptions encounted when preparing the report.
+            report_attributes (Union[Unset, List['SUSHIReportHeaderReportAttributesItem']]): Zero or more additional
+                attributes applied to the report. Attributes inform the level of detail in the report.
+            report_filters (Union[Unset, List['SUSHIReportHeaderReportFiltersItem']]): Zero or more report filters used for
+                this report.  Typically  reflect filters provided on the Request.  Filters limit the data to be reported on.
+    """
+
+    release: str
+    report_id: str
+    report_name: str
+    created: Union[Unset, datetime.datetime] = UNSET
+    created_by: Union[Unset, str] = UNSET
+    exceptions: Union[Unset, List["SUSHIErrorModel"]] = UNSET
+    report_attributes: Union[Unset, List["SUSHIReportHeaderReportAttributesItem"]] = (
+        UNSET
+    )
+    report_filters: Union[Unset, List["SUSHIReportHeaderReportFiltersItem"]] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        release = self.release
+
+        report_id = self.report_id
+
+        report_name = self.report_name
+
+        created: Union[Unset, str] = UNSET
+        if not isinstance(self.created, Unset):
+            created = self.created.isoformat()
+
+        created_by = self.created_by
+
+        exceptions: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.exceptions, Unset):
+            exceptions = []
+            for exceptions_item_data in self.exceptions:
+                exceptions_item = exceptions_item_data.to_dict()
+                exceptions.append(exceptions_item)
+
+        report_attributes: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.report_attributes, Unset):
+            report_attributes = []
+            for report_attributes_item_data in self.report_attributes:
+                report_attributes_item = report_attributes_item_data.to_dict()
+                report_attributes.append(report_attributes_item)
+
+        report_filters: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.report_filters, Unset):
+            report_filters = []
+            for report_filters_item_data in self.report_filters:
+                report_filters_item = report_filters_item_data.to_dict()
+                report_filters.append(report_filters_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "release": release,
+                "report-id": report_id,
+                "report-name": report_name,
+            }
+        )
+        if created is not UNSET:
+            field_dict["created"] = created
+        if created_by is not UNSET:
+            field_dict["created-by"] = created_by
+        if exceptions is not UNSET:
+            field_dict["exceptions"] = exceptions
+        if report_attributes is not UNSET:
+            field_dict["report-attributes"] = report_attributes
+        if report_filters is not UNSET:
+            field_dict["report-filters"] = report_filters
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.sushi_error_model import SUSHIErrorModel
+        from ..models.sushi_report_header_report_attributes_item import (
+            SUSHIReportHeaderReportAttributesItem,
+        )
+        from ..models.sushi_report_header_report_filters_item import (
+            SUSHIReportHeaderReportFiltersItem,
+        )
+
+        d = src_dict.copy()
+        release = d.pop("release")
+
+        report_id = d.pop("report-id")
+
+        report_name = d.pop("report-name")
+
+        _created = d.pop("created", UNSET)
+        created: Union[Unset, datetime.datetime]
+        if isinstance(_created, Unset):
+            created = UNSET
+        else:
+            created = isoparse(_created)
+
+        created_by = d.pop("created-by", UNSET)
+
+        exceptions = []
+        _exceptions = d.pop("exceptions", UNSET)
+        for exceptions_item_data in _exceptions or []:
+            exceptions_item = SUSHIErrorModel.from_dict(exceptions_item_data)
+
+            exceptions.append(exceptions_item)
+
+        report_attributes = []
+        _report_attributes = d.pop("report-attributes", UNSET)
+        for report_attributes_item_data in _report_attributes or []:
+            report_attributes_item = SUSHIReportHeaderReportAttributesItem.from_dict(
+                report_attributes_item_data
+            )
+
+            report_attributes.append(report_attributes_item)
+
+        report_filters = []
+        _report_filters = d.pop("report-filters", UNSET)
+        for report_filters_item_data in _report_filters or []:
+            report_filters_item = SUSHIReportHeaderReportFiltersItem.from_dict(
+                report_filters_item_data
+            )
+
+            report_filters.append(report_filters_item)
+
+        sushi_report_header = cls(
+            release=release,
+            report_id=report_id,
+            report_name=report_name,
+            created=created,
+            created_by=created_by,
+            exceptions=exceptions,
+            report_attributes=report_attributes,
+            report_filters=report_filters,
+        )
+
+        sushi_report_header.additional_properties = d
+        return sushi_report_header
+
+    @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_report_header_report_attributes_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="SUSHIReportHeaderReportAttributesItem")
+
+
+@_attrs_define
+class SUSHIReportHeaderReportAttributesItem:
+    """ """
+
+    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_report_header_report_attributes_item = cls()
+
+        sushi_report_header_report_attributes_item.additional_properties = d
+        return sushi_report_header_report_attributes_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/models/sushi_report_header_report_filters_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="SUSHIReportHeaderReportFiltersItem")
+
+
+@_attrs_define
+class SUSHIReportHeaderReportFiltersItem:
+    """ """
+
+    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_report_header_report_filters_item = cls()
+
+        sushi_report_header_report_filters_item.additional_properties = d
+        return sushi_report_header_report_filters_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/models/sushi_report_list.py

@@ -0,0 +1,82 @@
+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_report_header import SUSHIReportHeader
+
+
+T = TypeVar("T", bound="SUSHIReportList")
+
+
+@_attrs_define
+class SUSHIReportList:
+    """list wrapper of reports
+
+    Attributes:
+        id (Union[Unset, str]): report id. Example: sciencedb-2022-01.
+        report_header (Union[Unset, SUSHIReportHeader]): Generalized report header that defines the requested report,
+            the requestor, the customer, filters applied, reportAttributes applied and any exceptions.
+    """
+
+    id: Union[Unset, str] = UNSET
+    report_header: Union[Unset, "SUSHIReportHeader"] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        id = self.id
+
+        report_header: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.report_header, Unset):
+            report_header = self.report_header.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if id is not UNSET:
+            field_dict["id"] = id
+        if report_header is not UNSET:
+            field_dict["report-header"] = report_header
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.sushi_report_header import SUSHIReportHeader
+
+        d = src_dict.copy()
+        id = d.pop("id", UNSET)
+
+        _report_header = d.pop("report-header", UNSET)
+        report_header: Union[Unset, SUSHIReportHeader]
+        if isinstance(_report_header, Unset):
+            report_header = UNSET
+        else:
+            report_header = SUSHIReportHeader.from_dict(_report_header)
+
+        sushi_report_list = cls(
+            id=id,
+            report_header=report_header,
+        )
+
+        sushi_report_list.additional_properties = d
+        return sushi_report_list
+
+    @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