flashstart-client 9.0.2__py3-none-any.whl

flashstart_client/generated/report/models/get_top_domains_by_category_response_200.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+if TYPE_CHECKING:
+    from ..models.get_top_domains_by_category_response_200_domains_by_category_item import (
+        GetTopDomainsByCategoryResponse200DomainsByCategoryItem,
+    )
+    from ..models.get_top_domains_by_category_response_200_filters import (
+        GetTopDomainsByCategoryResponse200Filters,
+    )
+
+
+T = TypeVar("T", bound="GetTopDomainsByCategoryResponse200")
+
+
+@_attrs_define
+class GetTopDomainsByCategoryResponse200:
+    """
+    Attributes:
+        domains_by_category (list[GetTopDomainsByCategoryResponse200DomainsByCategoryItem]):
+        filters (GetTopDomainsByCategoryResponse200Filters):
+    """
+
+    domains_by_category: list[GetTopDomainsByCategoryResponse200DomainsByCategoryItem]
+    filters: GetTopDomainsByCategoryResponse200Filters
+
+    def to_dict(self) -> dict[str, Any]:
+        domains_by_category = []
+        for domains_by_category_item_data in self.domains_by_category:
+            domains_by_category_item = domains_by_category_item_data.to_dict()
+            domains_by_category.append(domains_by_category_item)
+
+        filters = self.filters.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "domainsByCategory": domains_by_category,
+                "filters": filters,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.get_top_domains_by_category_response_200_domains_by_category_item import (
+            GetTopDomainsByCategoryResponse200DomainsByCategoryItem,
+        )
+        from ..models.get_top_domains_by_category_response_200_filters import (
+            GetTopDomainsByCategoryResponse200Filters,
+        )
+
+        d = dict(src_dict)
+        domains_by_category = []
+        _domains_by_category = d.pop("domainsByCategory")
+        for domains_by_category_item_data in _domains_by_category:
+            domains_by_category_item = (
+                GetTopDomainsByCategoryResponse200DomainsByCategoryItem.from_dict(
+                    domains_by_category_item_data
+                )
+            )
+
+            domains_by_category.append(domains_by_category_item)
+
+        filters = GetTopDomainsByCategoryResponse200Filters.from_dict(d.pop("filters"))
+
+        get_top_domains_by_category_response_200 = cls(
+            domains_by_category=domains_by_category,
+            filters=filters,
+        )
+
+        return get_top_domains_by_category_response_200

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_domains_by_category_item.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+if TYPE_CHECKING:
+    from ..models.get_top_domains_by_category_response_200_domains_by_category_item_domains_item import (
+        GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem,
+    )
+
+
+T = TypeVar("T", bound="GetTopDomainsByCategoryResponse200DomainsByCategoryItem")
+
+
+@_attrs_define
+class GetTopDomainsByCategoryResponse200DomainsByCategoryItem:
+    """
+    Attributes:
+        category (str):
+        domains (list[GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem]):
+    """
+
+    category: str
+    domains: list[GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem]
+
+    def to_dict(self) -> dict[str, Any]:
+        category = self.category
+
+        domains = []
+        for domains_item_data in self.domains:
+            domains_item = domains_item_data.to_dict()
+            domains.append(domains_item)
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "category": category,
+                "domains": domains,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.get_top_domains_by_category_response_200_domains_by_category_item_domains_item import (
+            GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem,
+        )
+
+        d = dict(src_dict)
+        category = d.pop("category")
+
+        domains = []
+        _domains = d.pop("domains")
+        for domains_item_data in _domains:
+            domains_item = GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem.from_dict(
+                domains_item_data
+            )
+
+            domains.append(domains_item)
+
+        get_top_domains_by_category_response_200_domains_by_category_item = cls(
+            category=category,
+            domains=domains,
+        )
+
+        return get_top_domains_by_category_response_200_domains_by_category_item

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_domains_by_category_item_domains_item.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar(
+    "T", bound="GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem"
+)
+
+
+@_attrs_define
+class GetTopDomainsByCategoryResponse200DomainsByCategoryItemDomainsItem:
+    """
+    Attributes:
+        allowed (float):
+        blocked (float):
+        requests (float):
+        unresolved (float):
+        domain (str):
+    """
+
+    allowed: float
+    blocked: float
+    requests: float
+    unresolved: float
+    domain: str
+
+    def to_dict(self) -> dict[str, Any]:
+        allowed = self.allowed
+
+        blocked = self.blocked
+
+        requests = self.requests
+
+        unresolved = self.unresolved
+
+        domain = self.domain
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "allowed": allowed,
+                "blocked": blocked,
+                "requests": requests,
+                "unresolved": unresolved,
+                "domain": domain,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        allowed = d.pop("allowed")
+
+        blocked = d.pop("blocked")
+
+        requests = d.pop("requests")
+
+        unresolved = d.pop("unresolved")
+
+        domain = d.pop("domain")
+
+        get_top_domains_by_category_response_200_domains_by_category_item_domains_item = cls(
+            allowed=allowed,
+            blocked=blocked,
+            requests=requests,
+            unresolved=unresolved,
+            domain=domain,
+        )
+
+        return get_top_domains_by_category_response_200_domains_by_category_item_domains_item

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_filters.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+
+from ..models.get_top_domains_by_category_response_200_filters_granularity import (
+    GetTopDomainsByCategoryResponse200FiltersGranularity,
+)
+from ..models.get_top_domains_by_category_response_200_filters_metric import (
+    GetTopDomainsByCategoryResponse200FiltersMetric,
+)
+from ..models.get_top_domains_by_category_response_200_filters_protection_module import (
+    GetTopDomainsByCategoryResponse200FiltersProtectionModule,
+)
+from ..models.get_top_domains_by_category_response_200_filters_reason import (
+    GetTopDomainsByCategoryResponse200FiltersReason,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="GetTopDomainsByCategoryResponse200Filters")
+
+
+@_attrs_define
+class GetTopDomainsByCategoryResponse200Filters:
+    """
+    Attributes:
+        end (datetime.datetime):
+        start (datetime.datetime):
+        category_ids (list[UUID] | Unset):
+        granularity (GetTopDomainsByCategoryResponse200FiltersGranularity | Unset):
+        limit (float | Unset):
+        metric (GetTopDomainsByCategoryResponse200FiltersMetric | Unset):
+        network_ids (list[UUID] | Unset):
+        organization_ids (list[UUID] | Unset):
+        policy_ids (list[UUID] | Unset):
+        protection_module (GetTopDomainsByCategoryResponse200FiltersProtectionModule | Unset):
+        reason (GetTopDomainsByCategoryResponse200FiltersReason | Unset):
+    """
+
+    end: datetime.datetime
+    start: datetime.datetime
+    category_ids: list[UUID] | Unset = UNSET
+    granularity: GetTopDomainsByCategoryResponse200FiltersGranularity | Unset = UNSET
+    limit: float | Unset = UNSET
+    metric: GetTopDomainsByCategoryResponse200FiltersMetric | Unset = UNSET
+    network_ids: list[UUID] | Unset = UNSET
+    organization_ids: list[UUID] | Unset = UNSET
+    policy_ids: list[UUID] | Unset = UNSET
+    protection_module: (
+        GetTopDomainsByCategoryResponse200FiltersProtectionModule | Unset
+    ) = UNSET
+    reason: GetTopDomainsByCategoryResponse200FiltersReason | Unset = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        end = self.end.isoformat()
+
+        start = self.start.isoformat()
+
+        category_ids: list[str] | Unset = UNSET
+        if not isinstance(self.category_ids, Unset):
+            category_ids = []
+            for category_ids_item_data in self.category_ids:
+                category_ids_item = str(category_ids_item_data)
+                category_ids.append(category_ids_item)
+
+        granularity: str | Unset = UNSET
+        if not isinstance(self.granularity, Unset):
+            granularity = self.granularity.value
+
+        limit = self.limit
+
+        metric: str | Unset = UNSET
+        if not isinstance(self.metric, Unset):
+            metric = self.metric.value
+
+        network_ids: list[str] | Unset = UNSET
+        if not isinstance(self.network_ids, Unset):
+            network_ids = []
+            for network_ids_item_data in self.network_ids:
+                network_ids_item = str(network_ids_item_data)
+                network_ids.append(network_ids_item)
+
+        organization_ids: list[str] | Unset = UNSET
+        if not isinstance(self.organization_ids, Unset):
+            organization_ids = []
+            for organization_ids_item_data in self.organization_ids:
+                organization_ids_item = str(organization_ids_item_data)
+                organization_ids.append(organization_ids_item)
+
+        policy_ids: list[str] | Unset = UNSET
+        if not isinstance(self.policy_ids, Unset):
+            policy_ids = []
+            for policy_ids_item_data in self.policy_ids:
+                policy_ids_item = str(policy_ids_item_data)
+                policy_ids.append(policy_ids_item)
+
+        protection_module: str | Unset = UNSET
+        if not isinstance(self.protection_module, Unset):
+            protection_module = self.protection_module.value
+
+        reason: str | Unset = UNSET
+        if not isinstance(self.reason, Unset):
+            reason = self.reason.value
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "end": end,
+                "start": start,
+            }
+        )
+        if category_ids is not UNSET:
+            field_dict["categoryIds"] = category_ids
+        if granularity is not UNSET:
+            field_dict["granularity"] = granularity
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if metric is not UNSET:
+            field_dict["metric"] = metric
+        if network_ids is not UNSET:
+            field_dict["networkIds"] = network_ids
+        if organization_ids is not UNSET:
+            field_dict["organizationIds"] = organization_ids
+        if policy_ids is not UNSET:
+            field_dict["policyIds"] = policy_ids
+        if protection_module is not UNSET:
+            field_dict["protectionModule"] = protection_module
+        if reason is not UNSET:
+            field_dict["reason"] = reason
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        end = datetime.datetime.fromisoformat(d.pop("end"))
+
+        start = datetime.datetime.fromisoformat(d.pop("start"))
+
+        _category_ids = d.pop("categoryIds", UNSET)
+        category_ids: list[UUID] | Unset = UNSET
+        if _category_ids is not UNSET:
+            category_ids = []
+            for category_ids_item_data in _category_ids:
+                category_ids_item = UUID(category_ids_item_data)
+
+                category_ids.append(category_ids_item)
+
+        _granularity = d.pop("granularity", UNSET)
+        granularity: GetTopDomainsByCategoryResponse200FiltersGranularity | Unset
+        if isinstance(_granularity, Unset):
+            granularity = UNSET
+        else:
+            granularity = GetTopDomainsByCategoryResponse200FiltersGranularity(
+                _granularity
+            )
+
+        limit = d.pop("limit", UNSET)
+
+        _metric = d.pop("metric", UNSET)
+        metric: GetTopDomainsByCategoryResponse200FiltersMetric | Unset
+        if isinstance(_metric, Unset):
+            metric = UNSET
+        else:
+            metric = GetTopDomainsByCategoryResponse200FiltersMetric(_metric)
+
+        _network_ids = d.pop("networkIds", UNSET)
+        network_ids: list[UUID] | Unset = UNSET
+        if _network_ids is not UNSET:
+            network_ids = []
+            for network_ids_item_data in _network_ids:
+                network_ids_item = UUID(network_ids_item_data)
+
+                network_ids.append(network_ids_item)
+
+        _organization_ids = d.pop("organizationIds", UNSET)
+        organization_ids: list[UUID] | Unset = UNSET
+        if _organization_ids is not UNSET:
+            organization_ids = []
+            for organization_ids_item_data in _organization_ids:
+                organization_ids_item = UUID(organization_ids_item_data)
+
+                organization_ids.append(organization_ids_item)
+
+        _policy_ids = d.pop("policyIds", UNSET)
+        policy_ids: list[UUID] | Unset = UNSET
+        if _policy_ids is not UNSET:
+            policy_ids = []
+            for policy_ids_item_data in _policy_ids:
+                policy_ids_item = UUID(policy_ids_item_data)
+
+                policy_ids.append(policy_ids_item)
+
+        _protection_module = d.pop("protectionModule", UNSET)
+        protection_module: (
+            GetTopDomainsByCategoryResponse200FiltersProtectionModule | Unset
+        )
+        if isinstance(_protection_module, Unset):
+            protection_module = UNSET
+        else:
+            protection_module = (
+                GetTopDomainsByCategoryResponse200FiltersProtectionModule(
+                    _protection_module
+                )
+            )
+
+        _reason = d.pop("reason", UNSET)
+        reason: GetTopDomainsByCategoryResponse200FiltersReason | Unset
+        if isinstance(_reason, Unset):
+            reason = UNSET
+        else:
+            reason = GetTopDomainsByCategoryResponse200FiltersReason(_reason)
+
+        get_top_domains_by_category_response_200_filters = cls(
+            end=end,
+            start=start,
+            category_ids=category_ids,
+            granularity=granularity,
+            limit=limit,
+            metric=metric,
+            network_ids=network_ids,
+            organization_ids=organization_ids,
+            policy_ids=policy_ids,
+            protection_module=protection_module,
+            reason=reason,
+        )
+
+        return get_top_domains_by_category_response_200_filters

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_filters_granularity.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class GetTopDomainsByCategoryResponse200FiltersGranularity(StrEnum):
+    DAILY = "daily"
+    HOURLY = "hourly"
+    MONTHLY = "monthly"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_filters_metric.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class GetTopDomainsByCategoryResponse200FiltersMetric(StrEnum):
+    ALLOWED = "allowed"
+    BLOCKED = "blocked"
+    REQUESTS = "requests"
+    UNRESOLVED = "unresolved"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_filters_protection_module.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class GetTopDomainsByCategoryResponse200FiltersProtectionModule(StrEnum):
+    APP_BLOCKER = "app_blocker"
+    BETA_LIST = "beta_list"
+    CONTENT_FILTER = "content_filter"
+    MALWARE_PROTECTION = "malware_protection"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_by_category_response_200_filters_reason.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class GetTopDomainsByCategoryResponse200FiltersReason(StrEnum):
+    IP_BLOCKER = "ip_blocker"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_metric.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class GetTopDomainsMetric(StrEnum):
+    ALLOWED = "allowed"
+    BLOCKED = "blocked"
+    REQUESTS = "requests"
+    UNRESOLVED = "unresolved"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_protection_module.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class GetTopDomainsProtectionModule(StrEnum):
+    APP_BLOCKER = "app_blocker"
+    BETA_LIST = "beta_list"
+    CONTENT_FILTER = "content_filter"
+    MALWARE_PROTECTION = "malware_protection"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_reason.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class GetTopDomainsReason(StrEnum):
+    IP_BLOCKER = "ip_blocker"
+
+    def __str__(self) -> str:
+        return str(self.value)

flashstart_client/generated/report/models/get_top_domains_response_200.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+if TYPE_CHECKING:
+    from ..models.get_top_domains_response_200_domains_item import (
+        GetTopDomainsResponse200DomainsItem,
+    )
+    from ..models.get_top_domains_response_200_filters import (
+        GetTopDomainsResponse200Filters,
+    )
+
+
+T = TypeVar("T", bound="GetTopDomainsResponse200")
+
+
+@_attrs_define
+class GetTopDomainsResponse200:
+    """
+    Attributes:
+        domains (list[GetTopDomainsResponse200DomainsItem]):
+        filters (GetTopDomainsResponse200Filters):
+    """
+
+    domains: list[GetTopDomainsResponse200DomainsItem]
+    filters: GetTopDomainsResponse200Filters
+
+    def to_dict(self) -> dict[str, Any]:
+        domains = []
+        for domains_item_data in self.domains:
+            domains_item = domains_item_data.to_dict()
+            domains.append(domains_item)
+
+        filters = self.filters.to_dict()
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "domains": domains,
+                "filters": filters,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.get_top_domains_response_200_domains_item import (
+            GetTopDomainsResponse200DomainsItem,
+        )
+        from ..models.get_top_domains_response_200_filters import (
+            GetTopDomainsResponse200Filters,
+        )
+
+        d = dict(src_dict)
+        domains = []
+        _domains = d.pop("domains")
+        for domains_item_data in _domains:
+            domains_item = GetTopDomainsResponse200DomainsItem.from_dict(
+                domains_item_data
+            )
+
+            domains.append(domains_item)
+
+        filters = GetTopDomainsResponse200Filters.from_dict(d.pop("filters"))
+
+        get_top_domains_response_200 = cls(
+            domains=domains,
+            filters=filters,
+        )
+
+        return get_top_domains_response_200

flashstart_client/generated/report/models/get_top_domains_response_200_domains_item.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="GetTopDomainsResponse200DomainsItem")
+
+
+@_attrs_define
+class GetTopDomainsResponse200DomainsItem:
+    """
+    Attributes:
+        allowed (float):
+        blocked (float):
+        requests (float):
+        unresolved (float):
+        domain (str):
+    """
+
+    allowed: float
+    blocked: float
+    requests: float
+    unresolved: float
+    domain: str
+
+    def to_dict(self) -> dict[str, Any]:
+        allowed = self.allowed
+
+        blocked = self.blocked
+
+        requests = self.requests
+
+        unresolved = self.unresolved
+
+        domain = self.domain
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update(
+            {
+                "allowed": allowed,
+                "blocked": blocked,
+                "requests": requests,
+                "unresolved": unresolved,
+                "domain": domain,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        allowed = d.pop("allowed")
+
+        blocked = d.pop("blocked")
+
+        requests = d.pop("requests")
+
+        unresolved = d.pop("unresolved")
+
+        domain = d.pop("domain")
+
+        get_top_domains_response_200_domains_item = cls(
+            allowed=allowed,
+            blocked=blocked,
+            requests=requests,
+            unresolved=unresolved,
+            domain=domain,
+        )
+
+        return get_top_domains_response_200_domains_item