funapi-sciencedb 1.0.1__py3-none-any.whl

sciencedb/models/counter_dataset_contributors.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.counter_dataset_contributors_type import COUNTERDatasetContributorsType
+
+T = TypeVar("T", bound="COUNTERDatasetContributors")
+
+
+@_attrs_define
+class COUNTERDatasetContributors:
+    """
+    Attributes:
+        type (COUNTERDatasetContributorsType):  Example: name.
+        value (str): Value of the contributor identifier Example: John Smith.
+    """
+
+    type: COUNTERDatasetContributorsType
+    value: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        type = self.type.value
+
+        value = self.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "Type": type,
+                "Value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        type = COUNTERDatasetContributorsType(d.pop("Type"))
+
+        value = d.pop("Value")
+
+        counter_dataset_contributors = cls(
+            type=type,
+            value=value,
+        )
+
+        counter_dataset_contributors.additional_properties = d
+        return counter_dataset_contributors
+
+    @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/counter_dataset_contributors_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class COUNTERDatasetContributorsType(str, Enum):
+    ISNI = "isni"
+    NAME = "name"
+    ORCID = "orcid"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/counter_dataset_dates.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.counter_dataset_dates_type import COUNTERDatasetDatesType
+
+T = TypeVar("T", bound="COUNTERDatasetDates")
+
+
+@_attrs_define
+class COUNTERDatasetDates:
+    """
+    Attributes:
+        type (COUNTERDatasetDatesType):  Example: pub-date.
+        value (str): Value of the dataset date Example: 2002-01-15.
+    """
+
+    type: COUNTERDatasetDatesType
+    value: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        type = self.type.value
+
+        value = self.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type,
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        type = COUNTERDatasetDatesType(d.pop("type"))
+
+        value = d.pop("value")
+
+        counter_dataset_dates = cls(
+            type=type,
+            value=value,
+        )
+
+        counter_dataset_dates.additional_properties = d
+        return counter_dataset_dates
+
+    @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/counter_dataset_dates_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class COUNTERDatasetDatesType(str, Enum):
+    FIRST_ACCESSED_ONLINE = "first-accessed-online"
+    PROPRIETARY = "proprietary"
+    PUB_DATE = "pub-date"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/counter_dataset_identifiers.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.counter_dataset_identifiers_type import COUNTERDatasetIdentifiersType
+
+T = TypeVar("T", bound="COUNTERDatasetIdentifiers")
+
+
+@_attrs_define
+class COUNTERDatasetIdentifiers:
+    """
+    Attributes:
+        type (COUNTERDatasetIdentifiersType):  Example: doi.
+        value (str): Value of the dataset identifier Example: 0931-865.
+    """
+
+    type: COUNTERDatasetIdentifiersType
+    value: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        type = self.type.value
+
+        value = self.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type,
+                "value": value,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        type = COUNTERDatasetIdentifiersType(d.pop("type"))
+
+        value = d.pop("value")
+
+        counter_dataset_identifiers = cls(
+            type=type,
+            value=value,
+        )
+
+        counter_dataset_identifiers.additional_properties = d
+        return counter_dataset_identifiers
+
+    @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/counter_dataset_identifiers_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class COUNTERDatasetIdentifiersType(str, Enum):
+    DOI = "doi"
+    PROPRIETARY = "proprietary"
+    URI = "uri"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/counter_dataset_instance.py

@@ -0,0 +1,98 @@
+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.counter_dataset_instance_access_method import (
+    COUNTERDatasetInstanceAccessMethod,
+)
+from ..models.counter_dataset_instance_metric_type import (
+    COUNTERDatasetInstanceMetricType,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="COUNTERDatasetInstance")
+
+
+@_attrs_define
+class COUNTERDatasetInstance:
+    """
+    Attributes:
+        access_method (Union[Unset, COUNTERDatasetInstanceAccessMethod]): Identifies if the usage activity was 'Regular'
+            usage - a user doing research on a content site, or if the usage activity was 'Machine' - for the purpose of
+            retrieving content for Text and Data Mining (TDM) Example: regular.
+        count (Union[Unset, int]):
+        metric_type (Union[Unset, COUNTERDatasetInstanceMetricType]):
+    """
+
+    access_method: Union[Unset, COUNTERDatasetInstanceAccessMethod] = UNSET
+    count: Union[Unset, int] = UNSET
+    metric_type: Union[Unset, COUNTERDatasetInstanceMetricType] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        access_method: Union[Unset, str] = UNSET
+        if not isinstance(self.access_method, Unset):
+            access_method = self.access_method.value
+
+        count = self.count
+
+        metric_type: Union[Unset, str] = UNSET
+        if not isinstance(self.metric_type, Unset):
+            metric_type = self.metric_type.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if access_method is not UNSET:
+            field_dict["access-method"] = access_method
+        if count is not UNSET:
+            field_dict["count"] = count
+        if metric_type is not UNSET:
+            field_dict["metric-type"] = metric_type
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        _access_method = d.pop("access-method", UNSET)
+        access_method: Union[Unset, COUNTERDatasetInstanceAccessMethod]
+        if isinstance(_access_method, Unset):
+            access_method = UNSET
+        else:
+            access_method = COUNTERDatasetInstanceAccessMethod(_access_method)
+
+        count = d.pop("count", UNSET)
+
+        _metric_type = d.pop("metric-type", UNSET)
+        metric_type: Union[Unset, COUNTERDatasetInstanceMetricType]
+        if isinstance(_metric_type, Unset):
+            metric_type = UNSET
+        else:
+            metric_type = COUNTERDatasetInstanceMetricType(_metric_type)
+
+        counter_dataset_instance = cls(
+            access_method=access_method,
+            count=count,
+            metric_type=metric_type,
+        )
+
+        counter_dataset_instance.additional_properties = d
+        return counter_dataset_instance
+
+    @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/counter_dataset_instance_access_method.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class COUNTERDatasetInstanceAccessMethod(str, Enum):
+    MACHINE = "machine"
+    REGULAR = "regular"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/counter_dataset_instance_metric_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class COUNTERDatasetInstanceMetricType(str, Enum):
+    TOTAL_DATASET_INVESTIGATIONS = "total-dataset-investigations"
+    TOTAL_DATASET_REQUESTS = "total-dataset-requests"
+    UNIQUE_DATASET_INVESTIGATIONS = "unique-dataset-investigations"
+    UNIQUE_DATASET_REQUESTS = "unique-dataset-requests"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/counter_dataset_performance.py

@@ -0,0 +1,82 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.counter_dataset_instance import COUNTERDatasetInstance
+    from ..models.counter_dataset_period import COUNTERDatasetPeriod
+
+
+T = TypeVar("T", bound="COUNTERDatasetPerformance")
+
+
+@_attrs_define
+class COUNTERDatasetPerformance:
+    """
+    Attributes:
+        instance (List['COUNTERDatasetInstance']):
+        period (COUNTERDatasetPeriod):
+    """
+
+    instance: List["COUNTERDatasetInstance"]
+    period: "COUNTERDatasetPeriod"
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        instance = []
+        for instance_item_data in self.instance:
+            instance_item = instance_item_data.to_dict()
+            instance.append(instance_item)
+
+        period = self.period.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "instance": instance,
+                "period": period,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.counter_dataset_instance import COUNTERDatasetInstance
+        from ..models.counter_dataset_period import COUNTERDatasetPeriod
+
+        d = src_dict.copy()
+        instance = []
+        _instance = d.pop("instance")
+        for instance_item_data in _instance:
+            instance_item = COUNTERDatasetInstance.from_dict(instance_item_data)
+
+            instance.append(instance_item)
+
+        period = COUNTERDatasetPeriod.from_dict(d.pop("period"))
+
+        counter_dataset_performance = cls(
+            instance=instance,
+            period=period,
+        )
+
+        counter_dataset_performance.additional_properties = d
+        return counter_dataset_performance
+
+    @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/counter_dataset_period.py

@@ -0,0 +1,83 @@
+import datetime
+from typing import 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
+
+T = TypeVar("T", bound="COUNTERDatasetPeriod")
+
+
+@_attrs_define
+class COUNTERDatasetPeriod:
+    """
+    Attributes:
+        begin_date (Union[Unset, datetime.datetime]):
+        end_date (Union[Unset, datetime.datetime]):
+    """
+
+    begin_date: Union[Unset, datetime.datetime] = UNSET
+    end_date: Union[Unset, datetime.datetime] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        begin_date: Union[Unset, str] = UNSET
+        if not isinstance(self.begin_date, Unset):
+            begin_date = self.begin_date.isoformat()
+
+        end_date: Union[Unset, str] = UNSET
+        if not isinstance(self.end_date, Unset):
+            end_date = self.end_date.isoformat()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if begin_date is not UNSET:
+            field_dict["begin-date"] = begin_date
+        if end_date is not UNSET:
+            field_dict["end-date"] = end_date
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        _begin_date = d.pop("begin-date", UNSET)
+        begin_date: Union[Unset, datetime.datetime]
+        if isinstance(_begin_date, Unset):
+            begin_date = UNSET
+        else:
+            begin_date = isoparse(_begin_date)
+
+        _end_date = d.pop("end-date", UNSET)
+        end_date: Union[Unset, datetime.datetime]
+        if isinstance(_end_date, Unset):
+            end_date = UNSET
+        else:
+            end_date = isoparse(_end_date)
+
+        counter_dataset_period = cls(
+            begin_date=begin_date,
+            end_date=end_date,
+        )
+
+        counter_dataset_period.additional_properties = d
+        return counter_dataset_period
+
+    @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/counter_dataset_report.py

@@ -0,0 +1,106 @@
+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_usage import COUNTERDatasetUsage
+    from ..models.sushi_report_header import SUSHIReportHeader
+
+
+T = TypeVar("T", bound="COUNTERDatasetReport")
+
+
+@_attrs_define
+class COUNTERDatasetReport:
+    """Describes the formatting needs for the COUNTER Dataset Report. Response may include the Report_Header (optional),
+    Report_Datasets (usage stats).
+
+        Attributes:
+            id (Union[Unset, str]): id of report.
+            report_header (Union[Unset, SUSHIReportHeader]): Generalized report header that defines the requested report,
+                the requestor, the customer, filters applied, reportAttributes applied and any exceptions.
+            report_datasets (Union[Unset, List['COUNTERDatasetUsage']]): list of datasets .
+    """
+
+    id: Union[Unset, str] = UNSET
+    report_header: Union[Unset, "SUSHIReportHeader"] = UNSET
+    report_datasets: Union[Unset, List["COUNTERDatasetUsage"]] = 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()
+
+        report_datasets: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.report_datasets, Unset):
+            report_datasets = []
+            for report_datasets_item_data in self.report_datasets:
+                report_datasets_item = report_datasets_item_data.to_dict()
+                report_datasets.append(report_datasets_item)
+
+        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
+        if report_datasets is not UNSET:
+            field_dict["report-datasets"] = report_datasets
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.counter_dataset_usage import COUNTERDatasetUsage
+        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)
+
+        report_datasets = []
+        _report_datasets = d.pop("report-datasets", UNSET)
+        for report_datasets_item_data in _report_datasets or []:
+            report_datasets_item = COUNTERDatasetUsage.from_dict(
+                report_datasets_item_data
+            )
+
+            report_datasets.append(report_datasets_item)
+
+        counter_dataset_report = cls(
+            id=id,
+            report_header=report_header,
+            report_datasets=report_datasets,
+        )
+
+        counter_dataset_report.additional_properties = d
+        return counter_dataset_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