funapi-sciencedb 1.0.1__py3-none-any.whl

sciencedb/models/counter_dataset_usage.py

@@ -0,0 +1,230 @@
+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 ..models.counter_dataset_usage_data_type import COUNTERDatasetUsageDataType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.counter_dataset_attributes import COUNTERDatasetAttributes
+    from ..models.counter_dataset_contributors import COUNTERDatasetContributors
+    from ..models.counter_dataset_dates import COUNTERDatasetDates
+    from ..models.counter_dataset_identifiers import COUNTERDatasetIdentifiers
+    from ..models.counter_dataset_performance import COUNTERDatasetPerformance
+    from ..models.counter_publisher_identifiers import COUNTERPublisherIdentifiers
+
+
+T = TypeVar("T", bound="COUNTERDatasetUsage")
+
+
+@_attrs_define
+class COUNTERDatasetUsage:
+    """Defines the output for the Report_Datasets being returned in a Dataset Report.
+
+    Attributes:
+        data_type (COUNTERDatasetUsageDataType): Nature of the dataset being reported. Example: Dataset.
+        dataset_title (str): Name of the dataset being reported. Example: Lake Erie Fish Community Data.
+        performance (List['COUNTERDatasetPerformance']): The usage data related to the report dataset
+        platform (str): Name of the platform Example: Science Data Bank.
+        publisher (str): Name of publisher of the dataset Example: Science Data Bank.
+        publisher_id (List['COUNTERPublisherIdentifiers']): The identifier for the publisher.
+        dataset_attributes (Union[Unset, List['COUNTERDatasetAttributes']]): Other attributes related related to the
+            dataset.
+        dataset_contributors (Union[Unset, List['COUNTERDatasetContributors']]): The identifier for contributor (i.e.
+            creator) of the dataset.
+        dataset_dates (Union[Unset, List['COUNTERDatasetDates']]): Publication or other date(s)related to the dataset.
+        dataset_id (Union[Unset, List['COUNTERDatasetIdentifiers']]): The identifier for the report dataset
+        yop (Union[Unset, str]): Year of publication in the format of 'yyyy'. Use '0001' for unknown and '9999' for
+            articles in press. Example: 2010.
+    """
+
+    data_type: COUNTERDatasetUsageDataType
+    dataset_title: str
+    performance: List["COUNTERDatasetPerformance"]
+    platform: str
+    publisher: str
+    publisher_id: List["COUNTERPublisherIdentifiers"]
+    dataset_attributes: Union[Unset, List["COUNTERDatasetAttributes"]] = UNSET
+    dataset_contributors: Union[Unset, List["COUNTERDatasetContributors"]] = UNSET
+    dataset_dates: Union[Unset, List["COUNTERDatasetDates"]] = UNSET
+    dataset_id: Union[Unset, List["COUNTERDatasetIdentifiers"]] = UNSET
+    yop: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        data_type = self.data_type.value
+
+        dataset_title = self.dataset_title
+
+        performance = []
+        for performance_item_data in self.performance:
+            performance_item = performance_item_data.to_dict()
+            performance.append(performance_item)
+
+        platform = self.platform
+
+        publisher = self.publisher
+
+        publisher_id = []
+        for publisher_id_item_data in self.publisher_id:
+            publisher_id_item = publisher_id_item_data.to_dict()
+            publisher_id.append(publisher_id_item)
+
+        dataset_attributes: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.dataset_attributes, Unset):
+            dataset_attributes = []
+            for dataset_attributes_item_data in self.dataset_attributes:
+                dataset_attributes_item = dataset_attributes_item_data.to_dict()
+                dataset_attributes.append(dataset_attributes_item)
+
+        dataset_contributors: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.dataset_contributors, Unset):
+            dataset_contributors = []
+            for dataset_contributors_item_data in self.dataset_contributors:
+                dataset_contributors_item = dataset_contributors_item_data.to_dict()
+                dataset_contributors.append(dataset_contributors_item)
+
+        dataset_dates: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.dataset_dates, Unset):
+            dataset_dates = []
+            for dataset_dates_item_data in self.dataset_dates:
+                dataset_dates_item = dataset_dates_item_data.to_dict()
+                dataset_dates.append(dataset_dates_item)
+
+        dataset_id: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.dataset_id, Unset):
+            dataset_id = []
+            for dataset_id_item_data in self.dataset_id:
+                dataset_id_item = dataset_id_item_data.to_dict()
+                dataset_id.append(dataset_id_item)
+
+        yop = self.yop
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data-type": data_type,
+                "dataset-title": dataset_title,
+                "performance": performance,
+                "platform": platform,
+                "publisher": publisher,
+                "publisher-id": publisher_id,
+            }
+        )
+        if dataset_attributes is not UNSET:
+            field_dict["dataset-attributes"] = dataset_attributes
+        if dataset_contributors is not UNSET:
+            field_dict["dataset-contributors"] = dataset_contributors
+        if dataset_dates is not UNSET:
+            field_dict["dataset-dates"] = dataset_dates
+        if dataset_id is not UNSET:
+            field_dict["dataset-id"] = dataset_id
+        if yop is not UNSET:
+            field_dict["yop"] = yop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.counter_dataset_attributes import COUNTERDatasetAttributes
+        from ..models.counter_dataset_contributors import COUNTERDatasetContributors
+        from ..models.counter_dataset_dates import COUNTERDatasetDates
+        from ..models.counter_dataset_identifiers import COUNTERDatasetIdentifiers
+        from ..models.counter_dataset_performance import COUNTERDatasetPerformance
+        from ..models.counter_publisher_identifiers import COUNTERPublisherIdentifiers
+
+        d = src_dict.copy()
+        data_type = COUNTERDatasetUsageDataType(d.pop("data-type"))
+
+        dataset_title = d.pop("dataset-title")
+
+        performance = []
+        _performance = d.pop("performance")
+        for performance_item_data in _performance:
+            performance_item = COUNTERDatasetPerformance.from_dict(
+                performance_item_data
+            )
+
+            performance.append(performance_item)
+
+        platform = d.pop("platform")
+
+        publisher = d.pop("publisher")
+
+        publisher_id = []
+        _publisher_id = d.pop("publisher-id")
+        for publisher_id_item_data in _publisher_id:
+            publisher_id_item = COUNTERPublisherIdentifiers.from_dict(
+                publisher_id_item_data
+            )
+
+            publisher_id.append(publisher_id_item)
+
+        dataset_attributes = []
+        _dataset_attributes = d.pop("dataset-attributes", UNSET)
+        for dataset_attributes_item_data in _dataset_attributes or []:
+            dataset_attributes_item = COUNTERDatasetAttributes.from_dict(
+                dataset_attributes_item_data
+            )
+
+            dataset_attributes.append(dataset_attributes_item)
+
+        dataset_contributors = []
+        _dataset_contributors = d.pop("dataset-contributors", UNSET)
+        for dataset_contributors_item_data in _dataset_contributors or []:
+            dataset_contributors_item = COUNTERDatasetContributors.from_dict(
+                dataset_contributors_item_data
+            )
+
+            dataset_contributors.append(dataset_contributors_item)
+
+        dataset_dates = []
+        _dataset_dates = d.pop("dataset-dates", UNSET)
+        for dataset_dates_item_data in _dataset_dates or []:
+            dataset_dates_item = COUNTERDatasetDates.from_dict(dataset_dates_item_data)
+
+            dataset_dates.append(dataset_dates_item)
+
+        dataset_id = []
+        _dataset_id = d.pop("dataset-id", UNSET)
+        for dataset_id_item_data in _dataset_id or []:
+            dataset_id_item = COUNTERDatasetIdentifiers.from_dict(dataset_id_item_data)
+
+            dataset_id.append(dataset_id_item)
+
+        yop = d.pop("yop", UNSET)
+
+        counter_dataset_usage = cls(
+            data_type=data_type,
+            dataset_title=dataset_title,
+            performance=performance,
+            platform=platform,
+            publisher=publisher,
+            publisher_id=publisher_id,
+            dataset_attributes=dataset_attributes,
+            dataset_contributors=dataset_contributors,
+            dataset_dates=dataset_dates,
+            dataset_id=dataset_id,
+            yop=yop,
+        )
+
+        counter_dataset_usage.additional_properties = d
+        return counter_dataset_usage
+
+    @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_usage_data_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class COUNTERDatasetUsageDataType(str, Enum):
+    DATASET = "Dataset"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/counter_publisher_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_publisher_identifiers_type import COUNTERPublisherIdentifiersType
+
+T = TypeVar("T", bound="COUNTERPublisherIdentifiers")
+
+
+@_attrs_define
+class COUNTERPublisherIdentifiers:
+    """
+    Attributes:
+        type (COUNTERPublisherIdentifiersType):  Example: ORCID.
+        value (str): Value of the publisher identifier Example: 1234-1234-1234-1234.
+    """
+
+    type: COUNTERPublisherIdentifiersType
+    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 = COUNTERPublisherIdentifiersType(d.pop("Type"))
+
+        value = d.pop("Value")
+
+        counter_publisher_identifiers = cls(
+            type=type,
+            value=value,
+        )
+
+        counter_publisher_identifiers.additional_properties = d
+        return counter_publisher_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_publisher_identifiers_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class COUNTERPublisherIdentifiersType(str, Enum):
+    GRID = "GRID"
+    ISNI = "ISNI"
+    ORCID = "ORCID"
+
+    def __str__(self) -> str:
+        return str(self.value)

sciencedb/models/metrics_result.py

@@ -0,0 +1,95 @@
+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="MetricsResult")
+
+
+@_attrs_define
+class MetricsResult:
+    """wrapper of records of '/harvest' and '/search' and '/metrics' API
+
+    Attributes:
+        title_zh (Union[Unset, str]): Chinese title of dataset
+        title_en (Union[Unset, str]): English title of dataset
+        visit (Union[Unset, int]): Number of data set accesses
+        download (Union[Unset, int]): Number of data set downloads
+        ref_papers (Union[Unset, int]): The number of papers cited in the dataset
+    """
+
+    title_zh: Union[Unset, str] = UNSET
+    title_en: Union[Unset, str] = UNSET
+    visit: Union[Unset, int] = UNSET
+    download: Union[Unset, int] = UNSET
+    ref_papers: Union[Unset, int] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        title_zh = self.title_zh
+
+        title_en = self.title_en
+
+        visit = self.visit
+
+        download = self.download
+
+        ref_papers = self.ref_papers
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if title_zh is not UNSET:
+            field_dict["titleZh"] = title_zh
+        if title_en is not UNSET:
+            field_dict["titleEn"] = title_en
+        if visit is not UNSET:
+            field_dict["visit"] = visit
+        if download is not UNSET:
+            field_dict["download"] = download
+        if ref_papers is not UNSET:
+            field_dict["refPapers"] = ref_papers
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        title_zh = d.pop("titleZh", UNSET)
+
+        title_en = d.pop("titleEn", UNSET)
+
+        visit = d.pop("visit", UNSET)
+
+        download = d.pop("download", UNSET)
+
+        ref_papers = d.pop("refPapers", UNSET)
+
+        metrics_result = cls(
+            title_zh=title_zh,
+            title_en=title_en,
+            visit=visit,
+            download=download,
+            ref_papers=ref_papers,
+        )
+
+        metrics_result.additional_properties = d
+        return metrics_result
+
+    @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/search_record.py

@@ -0,0 +1,150 @@
+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="SearchRecord")
+
+
+@_attrs_define
+class SearchRecord:
+    """dataset's brief record of '/harvest' and '/search' API
+
+    Attributes:
+        clicks (Union[Unset, int]):
+        language (Union[Unset, str]):
+        reference_number (Union[Unset, int]):
+        title (Union[Unset, str]): dataset's title
+        introduction (Union[Unset, str]): dataset's introduction
+        keyword (Union[Unset, str]): dataset's keywords, put together in quotation marks Example: kw_1;kw_2;kw_3.
+        author (Union[Unset, str]): dataset's authors, put together in quotation marks Example: 2021-08-11 18:20:51.
+        publish_date (Union[Unset, str]): publish date in ScienceDB Example: author_1;author_2;author_3.
+        taxonomy (Union[Unset, str]): taxonomy in ScienceDB,put together in quotation marks,format is 'code'-'taxonomy'
+            Example: 170-Earth science;00-Others.
+        year (Union[Unset, str]): publish year in ScienceDB Example: 2021.
+        doi (Union[Unset, str]): dataset's doi Example: 10.11922/sciencedb.00101.
+    """
+
+    clicks: Union[Unset, int] = UNSET
+    language: Union[Unset, str] = UNSET
+    reference_number: Union[Unset, int] = UNSET
+    title: Union[Unset, str] = UNSET
+    introduction: Union[Unset, str] = UNSET
+    keyword: Union[Unset, str] = UNSET
+    author: Union[Unset, str] = UNSET
+    publish_date: Union[Unset, str] = UNSET
+    taxonomy: Union[Unset, str] = UNSET
+    year: Union[Unset, str] = UNSET
+    doi: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        clicks = self.clicks
+
+        language = self.language
+
+        reference_number = self.reference_number
+
+        title = self.title
+
+        introduction = self.introduction
+
+        keyword = self.keyword
+
+        author = self.author
+
+        publish_date = self.publish_date
+
+        taxonomy = self.taxonomy
+
+        year = self.year
+
+        doi = self.doi
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if clicks is not UNSET:
+            field_dict["clicks"] = clicks
+        if language is not UNSET:
+            field_dict["language"] = language
+        if reference_number is not UNSET:
+            field_dict["referenceNumber"] = reference_number
+        if title is not UNSET:
+            field_dict["title"] = title
+        if introduction is not UNSET:
+            field_dict["introduction"] = introduction
+        if keyword is not UNSET:
+            field_dict["keyword"] = keyword
+        if author is not UNSET:
+            field_dict["author"] = author
+        if publish_date is not UNSET:
+            field_dict["publishDate"] = publish_date
+        if taxonomy is not UNSET:
+            field_dict["taxonomy"] = taxonomy
+        if year is not UNSET:
+            field_dict["year"] = year
+        if doi is not UNSET:
+            field_dict["doi"] = doi
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        clicks = d.pop("clicks", UNSET)
+
+        language = d.pop("language", UNSET)
+
+        reference_number = d.pop("referenceNumber", UNSET)
+
+        title = d.pop("title", UNSET)
+
+        introduction = d.pop("introduction", UNSET)
+
+        keyword = d.pop("keyword", UNSET)
+
+        author = d.pop("author", UNSET)
+
+        publish_date = d.pop("publishDate", UNSET)
+
+        taxonomy = d.pop("taxonomy", UNSET)
+
+        year = d.pop("year", UNSET)
+
+        doi = d.pop("doi", UNSET)
+
+        search_record = cls(
+            clicks=clicks,
+            language=language,
+            reference_number=reference_number,
+            title=title,
+            introduction=introduction,
+            keyword=keyword,
+            author=author,
+            publish_date=publish_date,
+            taxonomy=taxonomy,
+            year=year,
+            doi=doi,
+        )
+
+        search_record.additional_properties = d
+        return search_record
+
+    @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/search_result.py

@@ -0,0 +1,111 @@
+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.search_record import SearchRecord
+
+
+T = TypeVar("T", bound="SearchResult")
+
+
+@_attrs_define
+class SearchResult:
+    """wrapper of records of '/harvest' and '/search' API
+
+    Attributes:
+        page_no (Union[Unset, int]):
+        page_size (Union[Unset, int]):
+        total_pages (Union[Unset, int]): total pages of records
+        total_elements (Union[Unset, int]): total number of records
+        recommend_data (Union[Unset, List['SearchRecord']]): the list of current page records
+    """
+
+    page_no: Union[Unset, int] = UNSET
+    page_size: Union[Unset, int] = UNSET
+    total_pages: Union[Unset, int] = UNSET
+    total_elements: Union[Unset, int] = UNSET
+    recommend_data: Union[Unset, List["SearchRecord"]] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        page_no = self.page_no
+
+        page_size = self.page_size
+
+        total_pages = self.total_pages
+
+        total_elements = self.total_elements
+
+        recommend_data: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.recommend_data, Unset):
+            recommend_data = []
+            for recommend_data_item_data in self.recommend_data:
+                recommend_data_item = recommend_data_item_data.to_dict()
+                recommend_data.append(recommend_data_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if page_no is not UNSET:
+            field_dict["pageNo"] = page_no
+        if page_size is not UNSET:
+            field_dict["pageSize"] = page_size
+        if total_pages is not UNSET:
+            field_dict["totalPages"] = total_pages
+        if total_elements is not UNSET:
+            field_dict["totalElements"] = total_elements
+        if recommend_data is not UNSET:
+            field_dict["recommendData"] = recommend_data
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.search_record import SearchRecord
+
+        d = src_dict.copy()
+        page_no = d.pop("pageNo", UNSET)
+
+        page_size = d.pop("pageSize", UNSET)
+
+        total_pages = d.pop("totalPages", UNSET)
+
+        total_elements = d.pop("totalElements", UNSET)
+
+        recommend_data = []
+        _recommend_data = d.pop("recommendData", UNSET)
+        for recommend_data_item_data in _recommend_data or []:
+            recommend_data_item = SearchRecord.from_dict(recommend_data_item_data)
+
+            recommend_data.append(recommend_data_item)
+
+        search_result = cls(
+            page_no=page_no,
+            page_size=page_size,
+            total_pages=total_pages,
+            total_elements=total_elements,
+            recommend_data=recommend_data,
+        )
+
+        search_result.additional_properties = d
+        return search_result
+
+    @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