parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/security/types.py

@@ -0,0 +1,168 @@
+"""Custom types and enums for the Security domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..network.types import TimeSinceEpoch as Network_TimeSinceEpoch
+
+type CertificateId = int  # An internal certificate ID value.
+
+
+@register("Security.MixedContentType")
+class MixedContentType(str, Enum):
+    """
+    A description of mixed content (HTTP resources on HTTPS pages), as defined by
+    https://www.w3.org/TR/mixed-content/#categories
+    """
+    BLOCKABLE = 'blockable'
+    OPTIONALLY_BLOCKABLE = 'optionally-blockable'
+    NONE = 'none'
+
+
+@register("Security.SecurityState")
+class SecurityState(str, Enum):
+    """The security level of a page or resource."""
+    UNKNOWN = 'unknown'
+    NEUTRAL = 'neutral'
+    INSECURE = 'insecure'
+    SECURE = 'secure'
+    INFO = 'info'
+    INSECURE_BROKEN = 'insecure-broken'
+
+
+@register("Security.CertificateSecurityState")
+@dataclass
+class CertificateSecurityState(DataType):
+    """Details about the security state of the page certificate."""
+    protocol: str
+    key_exchange: str
+    cipher: str
+    certificate: List[str]
+    subject_name: str
+    issuer: str
+    valid_from: Network_TimeSinceEpoch
+    valid_to: Network_TimeSinceEpoch
+    certificate_has_weak_signature: bool
+    certificate_has_sha1_signature: bool
+    modern_ssl: bool
+    obsolete_ssl_protocol: bool
+    obsolete_ssl_key_exchange: bool
+    obsolete_ssl_cipher: bool
+    obsolete_ssl_signature: bool
+    key_exchange_group: Optional[str] = None
+    mac: Optional[str] = None
+    certificate_network_error: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('protocol', 'protocol', False, 'primitive'),
+        FieldMeta('key_exchange', 'keyExchange', False, 'primitive'),
+        FieldMeta('cipher', 'cipher', False, 'primitive'),
+        FieldMeta('certificate', 'certificate', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('subject_name', 'subjectName', False, 'primitive'),
+        FieldMeta('issuer', 'issuer', False, 'primitive'),
+        FieldMeta('valid_from', 'validFrom', False, 'primitive'),
+        FieldMeta('valid_to', 'validTo', False, 'primitive'),
+        FieldMeta('certificate_has_weak_signature', 'certificateHasWeakSignature', False, 'primitive'),
+        FieldMeta('certificate_has_sha1_signature', 'certificateHasSha1Signature', False, 'primitive'),
+        FieldMeta('modern_ssl', 'modernSSL', False, 'primitive'),
+        FieldMeta('obsolete_ssl_protocol', 'obsoleteSslProtocol', False, 'primitive'),
+        FieldMeta('obsolete_ssl_key_exchange', 'obsoleteSslKeyExchange', False, 'primitive'),
+        FieldMeta('obsolete_ssl_cipher', 'obsoleteSslCipher', False, 'primitive'),
+        FieldMeta('obsolete_ssl_signature', 'obsoleteSslSignature', False, 'primitive'),
+        FieldMeta('key_exchange_group', 'keyExchangeGroup', True, 'primitive'),
+        FieldMeta('mac', 'mac', True, 'primitive'),
+        FieldMeta('certificate_network_error', 'certificateNetworkError', True, 'primitive'),
+    )
+
+
+@register("Security.SafetyTipStatus")
+class SafetyTipStatus(str, Enum):
+    BADREPUTATION = 'badReputation'
+    LOOKALIKE = 'lookalike'
+
+
+@register("Security.SafetyTipInfo")
+@dataclass
+class SafetyTipInfo(DataType):
+    safety_tip_status: SafetyTipStatus
+    safe_url: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('safety_tip_status', 'safetyTipStatus', False, 'enum', ref='Security.SafetyTipStatus'),
+        FieldMeta('safe_url', 'safeUrl', True, 'primitive'),
+    )
+
+
+@register("Security.VisibleSecurityState")
+@dataclass
+class VisibleSecurityState(DataType):
+    """Security state information about the page."""
+    security_state: SecurityState
+    security_state_issue_ids: List[str]
+    certificate_security_state: Optional[CertificateSecurityState] = None
+    safety_tip_info: Optional[SafetyTipInfo] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('security_state', 'securityState', False, 'enum', ref='Security.SecurityState'),
+        FieldMeta('security_state_issue_ids', 'securityStateIssueIds', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('certificate_security_state', 'certificateSecurityState', True, 'object', ref='Security.CertificateSecurityState'),
+        FieldMeta('safety_tip_info', 'safetyTipInfo', True, 'object', ref='Security.SafetyTipInfo'),
+    )
+
+
+@register("Security.SecurityStateExplanation")
+@dataclass
+class SecurityStateExplanation(DataType):
+    """An explanation of an factor contributing to the security state."""
+    security_state: SecurityState
+    title: str
+    summary: str
+    description: str
+    mixed_content_type: MixedContentType
+    certificate: List[str]
+    recommendations: Optional[List[str]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('security_state', 'securityState', False, 'enum', ref='Security.SecurityState'),
+        FieldMeta('title', 'title', False, 'primitive'),
+        FieldMeta('summary', 'summary', False, 'primitive'),
+        FieldMeta('description', 'description', False, 'primitive'),
+        FieldMeta('mixed_content_type', 'mixedContentType', False, 'enum', ref='Security.MixedContentType'),
+        FieldMeta('certificate', 'certificate', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('recommendations', 'recommendations', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("Security.InsecureContentStatus")
+@dataclass
+class InsecureContentStatus(DataType):
+    """Information about insecure content on the page."""
+    ran_mixed_content: bool
+    displayed_mixed_content: bool
+    contained_mixed_form: bool
+    ran_content_with_cert_errors: bool
+    displayed_content_with_cert_errors: bool
+    ran_insecure_content_style: SecurityState
+    displayed_insecure_content_style: SecurityState
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('ran_mixed_content', 'ranMixedContent', False, 'primitive'),
+        FieldMeta('displayed_mixed_content', 'displayedMixedContent', False, 'primitive'),
+        FieldMeta('contained_mixed_form', 'containedMixedForm', False, 'primitive'),
+        FieldMeta('ran_content_with_cert_errors', 'ranContentWithCertErrors', False, 'primitive'),
+        FieldMeta('displayed_content_with_cert_errors', 'displayedContentWithCertErrors', False, 'primitive'),
+        FieldMeta('ran_insecure_content_style', 'ranInsecureContentStyle', False, 'enum', ref='Security.SecurityState'),
+        FieldMeta('displayed_insecure_content_style', 'displayedInsecureContentStyle', False, 'enum', ref='Security.SecurityState'),
+    )
+
+
+@register("Security.CertificateErrorAction")
+class CertificateErrorAction(str, Enum):
+    """
+    The action to take when a certificate error occurs. continue will continue processing the
+    request and cancel will cancel the request.
+    """
+    CONTINUE = 'continue'
+    CANCEL = 'cancel'
+
+__all__ = ["CertificateErrorAction", "CertificateId", "CertificateSecurityState", "InsecureContentStatus", "MixedContentType", "SafetyTipInfo", "SafetyTipStatus", "SecurityState", "SecurityStateExplanation", "VisibleSecurityState"]

parsek_cdp/cdp/serviceworker/__init__.py

@@ -0,0 +1,15 @@
+"""The ServiceWorker CDP domain (generated).
+
+Importing ``ServiceWorker`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``ServiceWorker.SomeEvent`` /
+``ServiceWorker.SomeType``); commands run on a target via ``page.cdp.ServiceWorker``.
+"""
+from . import events, functions, types
+from .functions import ServiceWorker
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(ServiceWorker,)``).
+DOMAIN = "ServiceWorker"
+
+__all__ = ["events", "functions", "types", "ServiceWorker", "DOMAIN"]

parsek_cdp/cdp/serviceworker/events.py

@@ -0,0 +1,43 @@
+"""Events for the ServiceWorker domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import (
+        ServiceWorkerErrorMessage,
+        ServiceWorkerRegistration,
+        ServiceWorkerVersion,
+    )
+
+@register_event("ServiceWorker.workerErrorReported")
+@dataclass
+class WorkerErrorReported(Event):
+    error_message: ServiceWorkerErrorMessage
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('error_message', 'errorMessage', False, 'object', ref='ServiceWorker.ServiceWorkerErrorMessage'),
+    )
+
+
+@register_event("ServiceWorker.workerRegistrationUpdated")
+@dataclass
+class WorkerRegistrationUpdated(Event):
+    registrations: List[ServiceWorkerRegistration]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('registrations', 'registrations', False, 'array', inner=FieldMeta('', '', False, 'object', ref='ServiceWorker.ServiceWorkerRegistration')),
+    )
+
+
+@register_event("ServiceWorker.workerVersionUpdated")
+@dataclass
+class WorkerVersionUpdated(Event):
+    versions: List[ServiceWorkerVersion]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('versions', 'versions', False, 'array', inner=FieldMeta('', '', False, 'object', ref='ServiceWorker.ServiceWorkerVersion')),
+    )
+
+__all__ = ["WorkerErrorReported", "WorkerRegistrationUpdated", "WorkerVersionUpdated"]

parsek_cdp/cdp/serviceworker/functions.py

@@ -0,0 +1,115 @@
+"""Commands for the ServiceWorker domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import RegistrationID
+
+class ServiceWorker:
+    """Commands of the ServiceWorker domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def deliver_push_message(self, *, origin: str, registration_id: RegistrationID, data: str) -> None:
+        """
+        :param origin:
+        :param registration_id:
+        :param data:
+        """
+        _params: Dict[str, Any] = {}
+        _params['origin'] = encode(FieldMeta('', '', False, 'primitive'), origin)
+        _params['registrationId'] = encode(FieldMeta('', '', False, 'primitive'), registration_id)
+        _params['data'] = encode(FieldMeta('', '', False, 'primitive'), data)
+        _result = await self._target.send('ServiceWorker.deliverPushMessage', _params)
+        return None
+
+    async def disable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('ServiceWorker.disable', _params)
+        return None
+
+    async def dispatch_sync_event(self, *, origin: str, registration_id: RegistrationID, tag: str, last_chance: bool) -> None:
+        """
+        :param origin:
+        :param registration_id:
+        :param tag:
+        :param last_chance:
+        """
+        _params: Dict[str, Any] = {}
+        _params['origin'] = encode(FieldMeta('', '', False, 'primitive'), origin)
+        _params['registrationId'] = encode(FieldMeta('', '', False, 'primitive'), registration_id)
+        _params['tag'] = encode(FieldMeta('', '', False, 'primitive'), tag)
+        _params['lastChance'] = encode(FieldMeta('', '', False, 'primitive'), last_chance)
+        _result = await self._target.send('ServiceWorker.dispatchSyncEvent', _params)
+        return None
+
+    async def dispatch_periodic_sync_event(self, *, origin: str, registration_id: RegistrationID, tag: str) -> None:
+        """
+        :param origin:
+        :param registration_id:
+        :param tag:
+        """
+        _params: Dict[str, Any] = {}
+        _params['origin'] = encode(FieldMeta('', '', False, 'primitive'), origin)
+        _params['registrationId'] = encode(FieldMeta('', '', False, 'primitive'), registration_id)
+        _params['tag'] = encode(FieldMeta('', '', False, 'primitive'), tag)
+        _result = await self._target.send('ServiceWorker.dispatchPeriodicSyncEvent', _params)
+        return None
+
+    async def enable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('ServiceWorker.enable', _params)
+        return None
+
+    async def set_force_update_on_page_load(self, *, force_update_on_page_load: bool) -> None:
+        """:param force_update_on_page_load:"""
+        _params: Dict[str, Any] = {}
+        _params['forceUpdateOnPageLoad'] = encode(FieldMeta('', '', False, 'primitive'), force_update_on_page_load)
+        _result = await self._target.send('ServiceWorker.setForceUpdateOnPageLoad', _params)
+        return None
+
+    async def skip_waiting(self, *, scope_url: str) -> None:
+        """:param scope_url:"""
+        _params: Dict[str, Any] = {}
+        _params['scopeURL'] = encode(FieldMeta('', '', False, 'primitive'), scope_url)
+        _result = await self._target.send('ServiceWorker.skipWaiting', _params)
+        return None
+
+    async def start_worker(self, *, scope_url: str) -> None:
+        """:param scope_url:"""
+        _params: Dict[str, Any] = {}
+        _params['scopeURL'] = encode(FieldMeta('', '', False, 'primitive'), scope_url)
+        _result = await self._target.send('ServiceWorker.startWorker', _params)
+        return None
+
+    async def stop_all_workers(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('ServiceWorker.stopAllWorkers', _params)
+        return None
+
+    async def stop_worker(self, *, version_id: str) -> None:
+        """:param version_id:"""
+        _params: Dict[str, Any] = {}
+        _params['versionId'] = encode(FieldMeta('', '', False, 'primitive'), version_id)
+        _result = await self._target.send('ServiceWorker.stopWorker', _params)
+        return None
+
+    async def unregister(self, *, scope_url: str) -> None:
+        """:param scope_url:"""
+        _params: Dict[str, Any] = {}
+        _params['scopeURL'] = encode(FieldMeta('', '', False, 'primitive'), scope_url)
+        _result = await self._target.send('ServiceWorker.unregister', _params)
+        return None
+
+    async def update_registration(self, *, scope_url: str) -> None:
+        """:param scope_url:"""
+        _params: Dict[str, Any] = {}
+        _params['scopeURL'] = encode(FieldMeta('', '', False, 'primitive'), scope_url)
+        _result = await self._target.send('ServiceWorker.updateRegistration', _params)
+        return None

parsek_cdp/cdp/serviceworker/types.py

@@ -0,0 +1,95 @@
+"""Custom types and enums for the ServiceWorker domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..target.types import TargetID as Target_TargetID
+
+type RegistrationID = str
+
+
+@register("ServiceWorker.ServiceWorkerRegistration")
+@dataclass
+class ServiceWorkerRegistration(DataType):
+    """ServiceWorker registration."""
+    registration_id: RegistrationID
+    scope_url: str
+    is_deleted: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('registration_id', 'registrationId', False, 'primitive'),
+        FieldMeta('scope_url', 'scopeURL', False, 'primitive'),
+        FieldMeta('is_deleted', 'isDeleted', False, 'primitive'),
+    )
+
+
+@register("ServiceWorker.ServiceWorkerVersionRunningStatus")
+class ServiceWorkerVersionRunningStatus(str, Enum):
+    STOPPED = 'stopped'
+    STARTING = 'starting'
+    RUNNING = 'running'
+    STOPPING = 'stopping'
+
+
+@register("ServiceWorker.ServiceWorkerVersionStatus")
+class ServiceWorkerVersionStatus(str, Enum):
+    NEW = 'new'
+    INSTALLING = 'installing'
+    INSTALLED = 'installed'
+    ACTIVATING = 'activating'
+    ACTIVATED = 'activated'
+    REDUNDANT = 'redundant'
+
+
+@register("ServiceWorker.ServiceWorkerVersion")
+@dataclass
+class ServiceWorkerVersion(DataType):
+    """ServiceWorker version."""
+    version_id: str
+    registration_id: RegistrationID
+    script_url: str
+    running_status: ServiceWorkerVersionRunningStatus
+    status: ServiceWorkerVersionStatus
+    script_last_modified: Optional[float] = None
+    script_response_time: Optional[float] = None
+    controlled_clients: Optional[List[Target_TargetID]] = None
+    target_id: Optional[Target_TargetID] = None
+    router_rules: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('version_id', 'versionId', False, 'primitive'),
+        FieldMeta('registration_id', 'registrationId', False, 'primitive'),
+        FieldMeta('script_url', 'scriptURL', False, 'primitive'),
+        FieldMeta('running_status', 'runningStatus', False, 'enum', ref='ServiceWorker.ServiceWorkerVersionRunningStatus'),
+        FieldMeta('status', 'status', False, 'enum', ref='ServiceWorker.ServiceWorkerVersionStatus'),
+        FieldMeta('script_last_modified', 'scriptLastModified', True, 'primitive'),
+        FieldMeta('script_response_time', 'scriptResponseTime', True, 'primitive'),
+        FieldMeta('controlled_clients', 'controlledClients', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('target_id', 'targetId', True, 'primitive'),
+        FieldMeta('router_rules', 'routerRules', True, 'primitive'),
+    )
+
+
+@register("ServiceWorker.ServiceWorkerErrorMessage")
+@dataclass
+class ServiceWorkerErrorMessage(DataType):
+    """ServiceWorker error message."""
+    error_message: str
+    registration_id: RegistrationID
+    version_id: str
+    source_url: str
+    line_number: int
+    column_number: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('error_message', 'errorMessage', False, 'primitive'),
+        FieldMeta('registration_id', 'registrationId', False, 'primitive'),
+        FieldMeta('version_id', 'versionId', False, 'primitive'),
+        FieldMeta('source_url', 'sourceURL', False, 'primitive'),
+        FieldMeta('line_number', 'lineNumber', False, 'primitive'),
+        FieldMeta('column_number', 'columnNumber', False, 'primitive'),
+    )
+
+__all__ = ["RegistrationID", "ServiceWorkerErrorMessage", "ServiceWorkerRegistration", "ServiceWorkerVersion", "ServiceWorkerVersionRunningStatus", "ServiceWorkerVersionStatus"]

parsek_cdp/cdp/storage/__init__.py

@@ -0,0 +1,15 @@
+"""The Storage CDP domain (generated).
+
+Importing ``Storage`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Storage.SomeEvent`` /
+``Storage.SomeType``); commands run on a target via ``page.cdp.Storage``.
+"""
+from . import events, functions, types
+from .functions import Storage
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(Storage,)``).
+DOMAIN = "Storage"
+
+__all__ = ["events", "functions", "types", "Storage", "DOMAIN"]