Source code for pydelfini.delfini_core.models.collection_archive_request

from typing import Any
from typing import cast
from typing import Dict
from typing import List
from typing import Type
from typing import TypeVar
from typing import Union

from attrs import define as _attrs_define

from ..models.collection_archive_request_tabular_format import (
    CollectionArchiveRequestTabularFormat,
)
from ..types import UNSET
from ..types import Unset


T = TypeVar("T", bound="CollectionArchiveRequest")




@_attrs_define
class CollectionArchiveRequest:
    """Selects what the archive contains. An empty request means the
    whole collection version; `itemIds` limits it to those items,
    and `inFolder` to a folder's contents, recursively.

        Attributes:
            in_folder (Union[Unset, str]): ID of the folder whose contents, recursively, to include.
                `ROOT` means the whole collection version.
            item_ids (Union[Unset, List[str]]): IDs of the items to include.
            tabular_format (Union[Unset, CollectionArchiveRequestTabularFormat]): How dataviews and links are written.
                `query` (the default)
                writes each dataview's query definition and only records
                links in the manifest, giving the smallest archive.
                `parquet` and `csv` evaluate each dataview and fetch each
                link, writing tabular results in that format; a link to a
                non-tabular file is copied as-is.
                 Default: CollectionArchiveRequestTabularFormat.QUERY.
    """

    in_folder: Union[Unset, str] = UNSET
    item_ids: Union[Unset, List[str]] = UNSET
    tabular_format: Union[Unset, CollectionArchiveRequestTabularFormat] = (
        CollectionArchiveRequestTabularFormat.QUERY
    )



    def to_dict(self) -> Dict[str, Any]:
        """Convert to a dict"""
        in_folder = self.in_folder
        item_ids: Union[Unset, List[str]] = UNSET
        if not isinstance(self.item_ids, Unset):
            item_ids = self.item_ids

        tabular_format: Union[Unset, str] = UNSET
        if not isinstance(self.tabular_format, Unset):
            tabular_format = self.tabular_format.value

        field_dict: Dict[str, Any] = {}
        field_dict.update({})
        if in_folder is not UNSET:
            field_dict["inFolder"] = in_folder
        if item_ids is not UNSET:
            field_dict["itemIds"] = item_ids
        if tabular_format is not UNSET:
            field_dict["tabularFormat"] = tabular_format

        return field_dict




    @classmethod
    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
        """Create an instance of :py:class:`CollectionArchiveRequest` from a dict"""
        d = src_dict.copy()
        in_folder = d.pop("inFolder", UNSET)

        item_ids = cast(List[str], d.pop("itemIds", UNSET))

        _tabular_format = d.pop("tabularFormat", UNSET)
        tabular_format: Union[Unset, CollectionArchiveRequestTabularFormat]
        if isinstance(_tabular_format, Unset):
            tabular_format = UNSET
        else:
            tabular_format = CollectionArchiveRequestTabularFormat(_tabular_format)

        collection_archive_request = cls(
            in_folder=in_folder,
            item_ids=item_ids,
            tabular_format=tabular_format,
        )

        return collection_archive_request