dom

AttributeModified dataclass

Fired when Element's attribute is modified.

Source code in zendriver/cdp/dom.py

@event_class("DOM.attributeModified")
@dataclass
class AttributeModified:
    """
    Fired when ``Element``'s attribute is modified.
    """

    #: Id of the node that has changed.
    node_id: NodeId
    #: Attribute name.
    name: str
    #: Attribute value.
    value: str

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> AttributeModified:
        return cls(
            node_id=NodeId.from_json(json["nodeId"]),
            name=str(json["name"]),
            value=str(json["value"]),
        )

name: str instance-attribute

node_id: NodeId instance-attribute

value: str instance-attribute

__init__(node_id, name, value)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> AttributeModified:
    return cls(
        node_id=NodeId.from_json(json["nodeId"]),
        name=str(json["name"]),
        value=str(json["value"]),
    )

AttributeRemoved dataclass

Fired when Element's attribute is removed.

Source code in zendriver/cdp/dom.py

@event_class("DOM.attributeRemoved")
@dataclass
class AttributeRemoved:
    """
    Fired when ``Element``'s attribute is removed.
    """

    #: Id of the node that has changed.
    node_id: NodeId
    #: A ttribute name.
    name: str

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> AttributeRemoved:
        return cls(node_id=NodeId.from_json(json["nodeId"]), name=str(json["name"]))

name: str instance-attribute

node_id: NodeId instance-attribute

__init__(node_id, name)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> AttributeRemoved:
    return cls(node_id=NodeId.from_json(json["nodeId"]), name=str(json["name"]))

BackendNode dataclass

Backend node with a friendly name.

Source code in zendriver/cdp/dom.py

@dataclass
class BackendNode:
    """
    Backend node with a friendly name.
    """

    #: ``Node``'s nodeType.
    node_type: int

    #: ``Node``'s nodeName.
    node_name: str

    backend_node_id: BackendNodeId

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["nodeType"] = self.node_type
        json["nodeName"] = self.node_name
        json["backendNodeId"] = self.backend_node_id.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> BackendNode:
        return cls(
            node_type=int(json["nodeType"]),
            node_name=str(json["nodeName"]),
            backend_node_id=BackendNodeId.from_json(json["backendNodeId"]),
        )

backend_node_id: BackendNodeId instance-attribute

node_name: str instance-attribute

node_type: int instance-attribute

__init__(node_type, node_name, backend_node_id)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> BackendNode:
    return cls(
        node_type=int(json["nodeType"]),
        node_name=str(json["nodeName"]),
        backend_node_id=BackendNodeId.from_json(json["backendNodeId"]),
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["nodeType"] = self.node_type
    json["nodeName"] = self.node_name
    json["backendNodeId"] = self.backend_node_id.to_json()
    return json

BackendNodeId

Bases: int

Unique DOM node identifier used to reference a node that may not have been pushed to the front-end.

Source code in zendriver/cdp/dom.py

class BackendNodeId(int):
    """
    Unique DOM node identifier used to reference a node that may not have been pushed to the
    front-end.
    """

    def to_json(self) -> int:
        return self

    @classmethod
    def from_json(cls, json: int) -> BackendNodeId:
        return cls(json)

    def __repr__(self):
        return "BackendNodeId({})".format(super().__repr__())

__repr__()

Source code in zendriver/cdp/dom.py

def __repr__(self):
    return "BackendNodeId({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: int) -> BackendNodeId:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> int:
    return self

BoxModel dataclass

Box model.

Source code in zendriver/cdp/dom.py

@dataclass
class BoxModel:
    """
    Box model.
    """

    #: Content box
    content: Quad

    #: Padding box
    padding: Quad

    #: Border box
    border: Quad

    #: Margin box
    margin: Quad

    #: Node width
    width: int

    #: Node height
    height: int

    #: Shape outside coordinates
    shape_outside: typing.Optional[ShapeOutsideInfo] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["content"] = self.content.to_json()
        json["padding"] = self.padding.to_json()
        json["border"] = self.border.to_json()
        json["margin"] = self.margin.to_json()
        json["width"] = self.width
        json["height"] = self.height
        if self.shape_outside is not None:
            json["shapeOutside"] = self.shape_outside.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> BoxModel:
        return cls(
            content=Quad.from_json(json["content"]),
            padding=Quad.from_json(json["padding"]),
            border=Quad.from_json(json["border"]),
            margin=Quad.from_json(json["margin"]),
            width=int(json["width"]),
            height=int(json["height"]),
            shape_outside=(
                ShapeOutsideInfo.from_json(json["shapeOutside"])
                if json.get("shapeOutside", None) is not None
                else None
            ),
        )

border: Quad instance-attribute

content: Quad instance-attribute

height: int instance-attribute

margin: Quad instance-attribute

padding: Quad instance-attribute

shape_outside: typing.Optional[ShapeOutsideInfo] = None class-attribute instance-attribute

width: int instance-attribute

__init__(content, padding, border, margin, width, height, shape_outside=None)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> BoxModel:
    return cls(
        content=Quad.from_json(json["content"]),
        padding=Quad.from_json(json["padding"]),
        border=Quad.from_json(json["border"]),
        margin=Quad.from_json(json["margin"]),
        width=int(json["width"]),
        height=int(json["height"]),
        shape_outside=(
            ShapeOutsideInfo.from_json(json["shapeOutside"])
            if json.get("shapeOutside", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["content"] = self.content.to_json()
    json["padding"] = self.padding.to_json()
    json["border"] = self.border.to_json()
    json["margin"] = self.margin.to_json()
    json["width"] = self.width
    json["height"] = self.height
    if self.shape_outside is not None:
        json["shapeOutside"] = self.shape_outside.to_json()
    return json

CSSComputedStyleProperty dataclass

Source code in zendriver/cdp/dom.py

@dataclass
class CSSComputedStyleProperty:
    #: Computed style property name.
    name: str

    #: Computed style property value.
    value: str

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["name"] = self.name
        json["value"] = self.value
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CSSComputedStyleProperty:
        return cls(
            name=str(json["name"]),
            value=str(json["value"]),
        )

name: str instance-attribute

value: str instance-attribute

__init__(name, value)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> CSSComputedStyleProperty:
    return cls(
        name=str(json["name"]),
        value=str(json["value"]),
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["name"] = self.name
    json["value"] = self.value
    return json

CharacterDataModified dataclass

Mirrors DOMCharacterDataModified event.

Source code in zendriver/cdp/dom.py

@event_class("DOM.characterDataModified")
@dataclass
class CharacterDataModified:
    """
    Mirrors ``DOMCharacterDataModified`` event.
    """

    #: Id of the node that has changed.
    node_id: NodeId
    #: New text value.
    character_data: str

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CharacterDataModified:
        return cls(
            node_id=NodeId.from_json(json["nodeId"]),
            character_data=str(json["characterData"]),
        )

character_data: str instance-attribute

node_id: NodeId instance-attribute

__init__(node_id, character_data)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> CharacterDataModified:
    return cls(
        node_id=NodeId.from_json(json["nodeId"]),
        character_data=str(json["characterData"]),
    )

ChildNodeCountUpdated dataclass

Fired when Container's child node count has changed.

Source code in zendriver/cdp/dom.py

@event_class("DOM.childNodeCountUpdated")
@dataclass
class ChildNodeCountUpdated:
    """
    Fired when ``Container``'s child node count has changed.
    """

    #: Id of the node that has changed.
    node_id: NodeId
    #: New node count.
    child_node_count: int

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ChildNodeCountUpdated:
        return cls(
            node_id=NodeId.from_json(json["nodeId"]),
            child_node_count=int(json["childNodeCount"]),
        )

child_node_count: int instance-attribute

node_id: NodeId instance-attribute

__init__(node_id, child_node_count)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> ChildNodeCountUpdated:
    return cls(
        node_id=NodeId.from_json(json["nodeId"]),
        child_node_count=int(json["childNodeCount"]),
    )

ChildNodeInserted dataclass

Mirrors DOMNodeInserted event.

Source code in zendriver/cdp/dom.py

@event_class("DOM.childNodeInserted")
@dataclass
class ChildNodeInserted:
    """
    Mirrors ``DOMNodeInserted`` event.
    """

    #: Id of the node that has changed.
    parent_node_id: NodeId
    #: Id of the previous sibling.
    previous_node_id: NodeId
    #: Inserted node data.
    node: Node

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ChildNodeInserted:
        return cls(
            parent_node_id=NodeId.from_json(json["parentNodeId"]),
            previous_node_id=NodeId.from_json(json["previousNodeId"]),
            node=Node.from_json(json["node"]),
        )

node: Node instance-attribute

parent_node_id: NodeId instance-attribute

previous_node_id: NodeId instance-attribute

__init__(parent_node_id, previous_node_id, node)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> ChildNodeInserted:
    return cls(
        parent_node_id=NodeId.from_json(json["parentNodeId"]),
        previous_node_id=NodeId.from_json(json["previousNodeId"]),
        node=Node.from_json(json["node"]),
    )

ChildNodeRemoved dataclass

Mirrors DOMNodeRemoved event.

Source code in zendriver/cdp/dom.py

@event_class("DOM.childNodeRemoved")
@dataclass
class ChildNodeRemoved:
    """
    Mirrors ``DOMNodeRemoved`` event.
    """

    #: Parent id.
    parent_node_id: NodeId
    #: Id of the node that has been removed.
    node_id: NodeId

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ChildNodeRemoved:
        return cls(
            parent_node_id=NodeId.from_json(json["parentNodeId"]),
            node_id=NodeId.from_json(json["nodeId"]),
        )

node_id: NodeId instance-attribute

parent_node_id: NodeId instance-attribute

__init__(parent_node_id, node_id)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> ChildNodeRemoved:
    return cls(
        parent_node_id=NodeId.from_json(json["parentNodeId"]),
        node_id=NodeId.from_json(json["nodeId"]),
    )

CompatibilityMode

Bases: Enum

Document compatibility mode.

Source code in zendriver/cdp/dom.py

class CompatibilityMode(enum.Enum):
    """
    Document compatibility mode.
    """

    QUIRKS_MODE = "QuirksMode"
    LIMITED_QUIRKS_MODE = "LimitedQuirksMode"
    NO_QUIRKS_MODE = "NoQuirksMode"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> CompatibilityMode:
        return cls(json)

LIMITED_QUIRKS_MODE = 'LimitedQuirksMode' class-attribute instance-attribute

NO_QUIRKS_MODE = 'NoQuirksMode' class-attribute instance-attribute

QUIRKS_MODE = 'QuirksMode' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: str) -> CompatibilityMode:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> str:
    return self.value

DistributedNodesUpdated dataclass

EXPERIMENTAL

Called when distribution is changed.

Source code in zendriver/cdp/dom.py

@event_class("DOM.distributedNodesUpdated")
@dataclass
class DistributedNodesUpdated:
    """
    **EXPERIMENTAL**

    Called when distribution is changed.
    """

    #: Insertion point where distributed nodes were updated.
    insertion_point_id: NodeId
    #: Distributed nodes for given insertion point.
    distributed_nodes: typing.List[BackendNode]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DistributedNodesUpdated:
        return cls(
            insertion_point_id=NodeId.from_json(json["insertionPointId"]),
            distributed_nodes=[
                BackendNode.from_json(i) for i in json["distributedNodes"]
            ],
        )

distributed_nodes: typing.List[BackendNode] instance-attribute

insertion_point_id: NodeId instance-attribute

__init__(insertion_point_id, distributed_nodes)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> DistributedNodesUpdated:
    return cls(
        insertion_point_id=NodeId.from_json(json["insertionPointId"]),
        distributed_nodes=[
            BackendNode.from_json(i) for i in json["distributedNodes"]
        ],
    )

DocumentUpdated dataclass

Fired when Document has been totally updated. Node ids are no longer valid.

Source code in zendriver/cdp/dom.py

@event_class("DOM.documentUpdated")
@dataclass
class DocumentUpdated:
    """
    Fired when ``Document`` has been totally updated. Node ids are no longer valid.
    """

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DocumentUpdated:
        return cls()

__init__()

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> DocumentUpdated:
    return cls()

InlineStyleInvalidated dataclass

EXPERIMENTAL

Fired when Element's inline style is modified via a CSS property modification.

Source code in zendriver/cdp/dom.py

@event_class("DOM.inlineStyleInvalidated")
@dataclass
class InlineStyleInvalidated:
    """
    **EXPERIMENTAL**

    Fired when ``Element``'s inline style is modified via a CSS property modification.
    """

    #: Ids of the nodes for which the inline styles have been invalidated.
    node_ids: typing.List[NodeId]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> InlineStyleInvalidated:
        return cls(node_ids=[NodeId.from_json(i) for i in json["nodeIds"]])

node_ids: typing.List[NodeId] instance-attribute

__init__(node_ids)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> InlineStyleInvalidated:
    return cls(node_ids=[NodeId.from_json(i) for i in json["nodeIds"]])

LogicalAxes

Bases: Enum

ContainerSelector logical axes

Source code in zendriver/cdp/dom.py

class LogicalAxes(enum.Enum):
    """
    ContainerSelector logical axes
    """

    INLINE = "Inline"
    BLOCK = "Block"
    BOTH = "Both"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> LogicalAxes:
        return cls(json)

BLOCK = 'Block' class-attribute instance-attribute

BOTH = 'Both' class-attribute instance-attribute

INLINE = 'Inline' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: str) -> LogicalAxes:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> str:
    return self.value

Node dataclass

DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type.

Source code in zendriver/cdp/dom.py

@dataclass
class Node:
    """
    DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes.
    DOMNode is a base node mirror type.
    """

    #: Node identifier that is passed into the rest of the DOM messages as the ``nodeId``. Backend
    #: will only push node with given ``id`` once. It is aware of all requested nodes and will only
    #: fire DOM events for nodes known to the client.
    node_id: NodeId

    #: The BackendNodeId for this node.
    backend_node_id: BackendNodeId

    #: ``Node``'s nodeType.
    node_type: int

    #: ``Node``'s nodeName.
    node_name: str

    #: ``Node``'s localName.
    local_name: str

    #: ``Node``'s nodeValue.
    node_value: str

    #: The id of the parent node if any.
    parent_id: typing.Optional[NodeId] = None

    #: Child count for ``Container`` nodes.
    child_node_count: typing.Optional[int] = None

    #: Child nodes of this node when requested with children.
    children: typing.Optional[typing.List[Node]] = None

    #: Attributes of the ``Element`` node in the form of flat array ``[name1, value1, name2, value2]``.
    attributes: typing.Optional[typing.List[str]] = None

    #: Document URL that ``Document`` or ``FrameOwner`` node points to.
    document_url: typing.Optional[str] = None

    #: Base URL that ``Document`` or ``FrameOwner`` node uses for URL completion.
    base_url: typing.Optional[str] = None

    #: ``DocumentType``'s publicId.
    public_id: typing.Optional[str] = None

    #: ``DocumentType``'s systemId.
    system_id: typing.Optional[str] = None

    #: ``DocumentType``'s internalSubset.
    internal_subset: typing.Optional[str] = None

    #: ``Document``'s XML version in case of XML documents.
    xml_version: typing.Optional[str] = None

    #: ``Attr``'s name.
    name: typing.Optional[str] = None

    #: ``Attr``'s value.
    value: typing.Optional[str] = None

    #: Pseudo element type for this node.
    pseudo_type: typing.Optional[PseudoType] = None

    #: Pseudo element identifier for this node. Only present if there is a
    #: valid pseudoType.
    pseudo_identifier: typing.Optional[str] = None

    #: Shadow root type.
    shadow_root_type: typing.Optional[ShadowRootType] = None

    #: Frame ID for frame owner elements.
    frame_id: typing.Optional[page.FrameId] = None

    #: Content document for frame owner elements.
    content_document: typing.Optional[Node] = None

    #: Shadow root list for given element host.
    shadow_roots: typing.Optional[typing.List[Node]] = None

    #: Content document fragment for template elements.
    template_content: typing.Optional[Node] = None

    #: Pseudo elements associated with this node.
    pseudo_elements: typing.Optional[typing.List[Node]] = None

    #: Deprecated, as the HTML Imports API has been removed (crbug.com/937746).
    #: This property used to return the imported document for the HTMLImport links.
    #: The property is always undefined now.
    imported_document: typing.Optional[Node] = None

    #: Distributed nodes for given insertion point.
    distributed_nodes: typing.Optional[typing.List[BackendNode]] = None

    #: Whether the node is SVG.
    is_svg: typing.Optional[bool] = None

    compatibility_mode: typing.Optional[CompatibilityMode] = None

    assigned_slot: typing.Optional[BackendNode] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["nodeId"] = self.node_id.to_json()
        json["backendNodeId"] = self.backend_node_id.to_json()
        json["nodeType"] = self.node_type
        json["nodeName"] = self.node_name
        json["localName"] = self.local_name
        json["nodeValue"] = self.node_value
        if self.parent_id is not None:
            json["parentId"] = self.parent_id.to_json()
        if self.child_node_count is not None:
            json["childNodeCount"] = self.child_node_count
        if self.children is not None:
            json["children"] = [i.to_json() for i in self.children]
        if self.attributes is not None:
            json["attributes"] = [i for i in self.attributes]
        if self.document_url is not None:
            json["documentURL"] = self.document_url
        if self.base_url is not None:
            json["baseURL"] = self.base_url
        if self.public_id is not None:
            json["publicId"] = self.public_id
        if self.system_id is not None:
            json["systemId"] = self.system_id
        if self.internal_subset is not None:
            json["internalSubset"] = self.internal_subset
        if self.xml_version is not None:
            json["xmlVersion"] = self.xml_version
        if self.name is not None:
            json["name"] = self.name
        if self.value is not None:
            json["value"] = self.value
        if self.pseudo_type is not None:
            json["pseudoType"] = self.pseudo_type.to_json()
        if self.pseudo_identifier is not None:
            json["pseudoIdentifier"] = self.pseudo_identifier
        if self.shadow_root_type is not None:
            json["shadowRootType"] = self.shadow_root_type.to_json()
        if self.frame_id is not None:
            json["frameId"] = self.frame_id.to_json()
        if self.content_document is not None:
            json["contentDocument"] = self.content_document.to_json()
        if self.shadow_roots is not None:
            json["shadowRoots"] = [i.to_json() for i in self.shadow_roots]
        if self.template_content is not None:
            json["templateContent"] = self.template_content.to_json()
        if self.pseudo_elements is not None:
            json["pseudoElements"] = [i.to_json() for i in self.pseudo_elements]
        if self.imported_document is not None:
            json["importedDocument"] = self.imported_document.to_json()
        if self.distributed_nodes is not None:
            json["distributedNodes"] = [i.to_json() for i in self.distributed_nodes]
        if self.is_svg is not None:
            json["isSVG"] = self.is_svg
        if self.compatibility_mode is not None:
            json["compatibilityMode"] = self.compatibility_mode.to_json()
        if self.assigned_slot is not None:
            json["assignedSlot"] = self.assigned_slot.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> Node:
        return cls(
            node_id=NodeId.from_json(json["nodeId"]),
            backend_node_id=BackendNodeId.from_json(json["backendNodeId"]),
            node_type=int(json["nodeType"]),
            node_name=str(json["nodeName"]),
            local_name=str(json["localName"]),
            node_value=str(json["nodeValue"]),
            parent_id=(
                NodeId.from_json(json["parentId"])
                if json.get("parentId", None) is not None
                else None
            ),
            child_node_count=(
                int(json["childNodeCount"])
                if json.get("childNodeCount", None) is not None
                else None
            ),
            children=(
                [Node.from_json(i) for i in json["children"]]
                if json.get("children", None) is not None
                else None
            ),
            attributes=(
                [str(i) for i in json["attributes"]]
                if json.get("attributes", None) is not None
                else None
            ),
            document_url=(
                str(json["documentURL"])
                if json.get("documentURL", None) is not None
                else None
            ),
            base_url=(
                str(json["baseURL"]) if json.get("baseURL", None) is not None else None
            ),
            public_id=(
                str(json["publicId"])
                if json.get("publicId", None) is not None
                else None
            ),
            system_id=(
                str(json["systemId"])
                if json.get("systemId", None) is not None
                else None
            ),
            internal_subset=(
                str(json["internalSubset"])
                if json.get("internalSubset", None) is not None
                else None
            ),
            xml_version=(
                str(json["xmlVersion"])
                if json.get("xmlVersion", None) is not None
                else None
            ),
            name=str(json["name"]) if json.get("name", None) is not None else None,
            value=str(json["value"]) if json.get("value", None) is not None else None,
            pseudo_type=(
                PseudoType.from_json(json["pseudoType"])
                if json.get("pseudoType", None) is not None
                else None
            ),
            pseudo_identifier=(
                str(json["pseudoIdentifier"])
                if json.get("pseudoIdentifier", None) is not None
                else None
            ),
            shadow_root_type=(
                ShadowRootType.from_json(json["shadowRootType"])
                if json.get("shadowRootType", None) is not None
                else None
            ),
            frame_id=(
                page.FrameId.from_json(json["frameId"])
                if json.get("frameId", None) is not None
                else None
            ),
            content_document=(
                Node.from_json(json["contentDocument"])
                if json.get("contentDocument", None) is not None
                else None
            ),
            shadow_roots=(
                [Node.from_json(i) for i in json["shadowRoots"]]
                if json.get("shadowRoots", None) is not None
                else None
            ),
            template_content=(
                Node.from_json(json["templateContent"])
                if json.get("templateContent", None) is not None
                else None
            ),
            pseudo_elements=(
                [Node.from_json(i) for i in json["pseudoElements"]]
                if json.get("pseudoElements", None) is not None
                else None
            ),
            imported_document=(
                Node.from_json(json["importedDocument"])
                if json.get("importedDocument", None) is not None
                else None
            ),
            distributed_nodes=(
                [BackendNode.from_json(i) for i in json["distributedNodes"]]
                if json.get("distributedNodes", None) is not None
                else None
            ),
            is_svg=bool(json["isSVG"]) if json.get("isSVG", None) is not None else None,
            compatibility_mode=(
                CompatibilityMode.from_json(json["compatibilityMode"])
                if json.get("compatibilityMode", None) is not None
                else None
            ),
            assigned_slot=(
                BackendNode.from_json(json["assignedSlot"])
                if json.get("assignedSlot", None) is not None
                else None
            ),
        )

assigned_slot: typing.Optional[BackendNode] = None class-attribute instance-attribute

attributes: typing.Optional[typing.List[str]] = None class-attribute instance-attribute

backend_node_id: BackendNodeId instance-attribute

base_url: typing.Optional[str] = None class-attribute instance-attribute

child_node_count: typing.Optional[int] = None class-attribute instance-attribute

children: typing.Optional[typing.List[Node]] = None class-attribute instance-attribute

compatibility_mode: typing.Optional[CompatibilityMode] = None class-attribute instance-attribute

content_document: typing.Optional[Node] = None class-attribute instance-attribute

distributed_nodes: typing.Optional[typing.List[BackendNode]] = None class-attribute instance-attribute

document_url: typing.Optional[str] = None class-attribute instance-attribute

frame_id: typing.Optional[page.FrameId] = None class-attribute instance-attribute

imported_document: typing.Optional[Node] = None class-attribute instance-attribute

internal_subset: typing.Optional[str] = None class-attribute instance-attribute

is_svg: typing.Optional[bool] = None class-attribute instance-attribute

local_name: str instance-attribute

name: typing.Optional[str] = None class-attribute instance-attribute

node_id: NodeId instance-attribute

node_name: str instance-attribute

node_type: int instance-attribute

node_value: str instance-attribute

parent_id: typing.Optional[NodeId] = None class-attribute instance-attribute

pseudo_elements: typing.Optional[typing.List[Node]] = None class-attribute instance-attribute

pseudo_identifier: typing.Optional[str] = None class-attribute instance-attribute

pseudo_type: typing.Optional[PseudoType] = None class-attribute instance-attribute

public_id: typing.Optional[str] = None class-attribute instance-attribute

shadow_root_type: typing.Optional[ShadowRootType] = None class-attribute instance-attribute

shadow_roots: typing.Optional[typing.List[Node]] = None class-attribute instance-attribute

system_id: typing.Optional[str] = None class-attribute instance-attribute

template_content: typing.Optional[Node] = None class-attribute instance-attribute

value: typing.Optional[str] = None class-attribute instance-attribute

xml_version: typing.Optional[str] = None class-attribute instance-attribute

__init__(node_id, backend_node_id, node_type, node_name, local_name, node_value, parent_id=None, child_node_count=None, children=None, attributes=None, document_url=None, base_url=None, public_id=None, system_id=None, internal_subset=None, xml_version=None, name=None, value=None, pseudo_type=None, pseudo_identifier=None, shadow_root_type=None, frame_id=None, content_document=None, shadow_roots=None, template_content=None, pseudo_elements=None, imported_document=None, distributed_nodes=None, is_svg=None, compatibility_mode=None, assigned_slot=None)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> Node:
    return cls(
        node_id=NodeId.from_json(json["nodeId"]),
        backend_node_id=BackendNodeId.from_json(json["backendNodeId"]),
        node_type=int(json["nodeType"]),
        node_name=str(json["nodeName"]),
        local_name=str(json["localName"]),
        node_value=str(json["nodeValue"]),
        parent_id=(
            NodeId.from_json(json["parentId"])
            if json.get("parentId", None) is not None
            else None
        ),
        child_node_count=(
            int(json["childNodeCount"])
            if json.get("childNodeCount", None) is not None
            else None
        ),
        children=(
            [Node.from_json(i) for i in json["children"]]
            if json.get("children", None) is not None
            else None
        ),
        attributes=(
            [str(i) for i in json["attributes"]]
            if json.get("attributes", None) is not None
            else None
        ),
        document_url=(
            str(json["documentURL"])
            if json.get("documentURL", None) is not None
            else None
        ),
        base_url=(
            str(json["baseURL"]) if json.get("baseURL", None) is not None else None
        ),
        public_id=(
            str(json["publicId"])
            if json.get("publicId", None) is not None
            else None
        ),
        system_id=(
            str(json["systemId"])
            if json.get("systemId", None) is not None
            else None
        ),
        internal_subset=(
            str(json["internalSubset"])
            if json.get("internalSubset", None) is not None
            else None
        ),
        xml_version=(
            str(json["xmlVersion"])
            if json.get("xmlVersion", None) is not None
            else None
        ),
        name=str(json["name"]) if json.get("name", None) is not None else None,
        value=str(json["value"]) if json.get("value", None) is not None else None,
        pseudo_type=(
            PseudoType.from_json(json["pseudoType"])
            if json.get("pseudoType", None) is not None
            else None
        ),
        pseudo_identifier=(
            str(json["pseudoIdentifier"])
            if json.get("pseudoIdentifier", None) is not None
            else None
        ),
        shadow_root_type=(
            ShadowRootType.from_json(json["shadowRootType"])
            if json.get("shadowRootType", None) is not None
            else None
        ),
        frame_id=(
            page.FrameId.from_json(json["frameId"])
            if json.get("frameId", None) is not None
            else None
        ),
        content_document=(
            Node.from_json(json["contentDocument"])
            if json.get("contentDocument", None) is not None
            else None
        ),
        shadow_roots=(
            [Node.from_json(i) for i in json["shadowRoots"]]
            if json.get("shadowRoots", None) is not None
            else None
        ),
        template_content=(
            Node.from_json(json["templateContent"])
            if json.get("templateContent", None) is not None
            else None
        ),
        pseudo_elements=(
            [Node.from_json(i) for i in json["pseudoElements"]]
            if json.get("pseudoElements", None) is not None
            else None
        ),
        imported_document=(
            Node.from_json(json["importedDocument"])
            if json.get("importedDocument", None) is not None
            else None
        ),
        distributed_nodes=(
            [BackendNode.from_json(i) for i in json["distributedNodes"]]
            if json.get("distributedNodes", None) is not None
            else None
        ),
        is_svg=bool(json["isSVG"]) if json.get("isSVG", None) is not None else None,
        compatibility_mode=(
            CompatibilityMode.from_json(json["compatibilityMode"])
            if json.get("compatibilityMode", None) is not None
            else None
        ),
        assigned_slot=(
            BackendNode.from_json(json["assignedSlot"])
            if json.get("assignedSlot", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["nodeId"] = self.node_id.to_json()
    json["backendNodeId"] = self.backend_node_id.to_json()
    json["nodeType"] = self.node_type
    json["nodeName"] = self.node_name
    json["localName"] = self.local_name
    json["nodeValue"] = self.node_value
    if self.parent_id is not None:
        json["parentId"] = self.parent_id.to_json()
    if self.child_node_count is not None:
        json["childNodeCount"] = self.child_node_count
    if self.children is not None:
        json["children"] = [i.to_json() for i in self.children]
    if self.attributes is not None:
        json["attributes"] = [i for i in self.attributes]
    if self.document_url is not None:
        json["documentURL"] = self.document_url
    if self.base_url is not None:
        json["baseURL"] = self.base_url
    if self.public_id is not None:
        json["publicId"] = self.public_id
    if self.system_id is not None:
        json["systemId"] = self.system_id
    if self.internal_subset is not None:
        json["internalSubset"] = self.internal_subset
    if self.xml_version is not None:
        json["xmlVersion"] = self.xml_version
    if self.name is not None:
        json["name"] = self.name
    if self.value is not None:
        json["value"] = self.value
    if self.pseudo_type is not None:
        json["pseudoType"] = self.pseudo_type.to_json()
    if self.pseudo_identifier is not None:
        json["pseudoIdentifier"] = self.pseudo_identifier
    if self.shadow_root_type is not None:
        json["shadowRootType"] = self.shadow_root_type.to_json()
    if self.frame_id is not None:
        json["frameId"] = self.frame_id.to_json()
    if self.content_document is not None:
        json["contentDocument"] = self.content_document.to_json()
    if self.shadow_roots is not None:
        json["shadowRoots"] = [i.to_json() for i in self.shadow_roots]
    if self.template_content is not None:
        json["templateContent"] = self.template_content.to_json()
    if self.pseudo_elements is not None:
        json["pseudoElements"] = [i.to_json() for i in self.pseudo_elements]
    if self.imported_document is not None:
        json["importedDocument"] = self.imported_document.to_json()
    if self.distributed_nodes is not None:
        json["distributedNodes"] = [i.to_json() for i in self.distributed_nodes]
    if self.is_svg is not None:
        json["isSVG"] = self.is_svg
    if self.compatibility_mode is not None:
        json["compatibilityMode"] = self.compatibility_mode.to_json()
    if self.assigned_slot is not None:
        json["assignedSlot"] = self.assigned_slot.to_json()
    return json

NodeId

Bases: int

Unique DOM node identifier.

Source code in zendriver/cdp/dom.py

class NodeId(int):
    """
    Unique DOM node identifier.
    """

    def to_json(self) -> int:
        return self

    @classmethod
    def from_json(cls, json: int) -> NodeId:
        return cls(json)

    def __repr__(self):
        return "NodeId({})".format(super().__repr__())

__repr__()

Source code in zendriver/cdp/dom.py

def __repr__(self):
    return "NodeId({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: int) -> NodeId:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> int:
    return self

PhysicalAxes

Bases: Enum

ContainerSelector physical axes

Source code in zendriver/cdp/dom.py

class PhysicalAxes(enum.Enum):
    """
    ContainerSelector physical axes
    """

    HORIZONTAL = "Horizontal"
    VERTICAL = "Vertical"
    BOTH = "Both"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> PhysicalAxes:
        return cls(json)

BOTH = 'Both' class-attribute instance-attribute

HORIZONTAL = 'Horizontal' class-attribute instance-attribute

VERTICAL = 'Vertical' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: str) -> PhysicalAxes:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> str:
    return self.value

PseudoElementAdded dataclass

EXPERIMENTAL

Called when a pseudo element is added to an element.

Source code in zendriver/cdp/dom.py

@event_class("DOM.pseudoElementAdded")
@dataclass
class PseudoElementAdded:
    """
    **EXPERIMENTAL**

    Called when a pseudo element is added to an element.
    """

    #: Pseudo element's parent element id.
    parent_id: NodeId
    #: The added pseudo element.
    pseudo_element: Node

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> PseudoElementAdded:
        return cls(
            parent_id=NodeId.from_json(json["parentId"]),
            pseudo_element=Node.from_json(json["pseudoElement"]),
        )

parent_id: NodeId instance-attribute

pseudo_element: Node instance-attribute

__init__(parent_id, pseudo_element)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> PseudoElementAdded:
    return cls(
        parent_id=NodeId.from_json(json["parentId"]),
        pseudo_element=Node.from_json(json["pseudoElement"]),
    )

PseudoElementRemoved dataclass

EXPERIMENTAL

Called when a pseudo element is removed from an element.

Source code in zendriver/cdp/dom.py

@event_class("DOM.pseudoElementRemoved")
@dataclass
class PseudoElementRemoved:
    """
    **EXPERIMENTAL**

    Called when a pseudo element is removed from an element.
    """

    #: Pseudo element's parent element id.
    parent_id: NodeId
    #: The removed pseudo element id.
    pseudo_element_id: NodeId

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> PseudoElementRemoved:
        return cls(
            parent_id=NodeId.from_json(json["parentId"]),
            pseudo_element_id=NodeId.from_json(json["pseudoElementId"]),
        )

parent_id: NodeId instance-attribute

pseudo_element_id: NodeId instance-attribute

__init__(parent_id, pseudo_element_id)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> PseudoElementRemoved:
    return cls(
        parent_id=NodeId.from_json(json["parentId"]),
        pseudo_element_id=NodeId.from_json(json["pseudoElementId"]),
    )

PseudoType

Bases: Enum

Pseudo element type.

Source code in zendriver/cdp/dom.py

class PseudoType(enum.Enum):
    """
    Pseudo element type.
    """

    FIRST_LINE = "first-line"
    FIRST_LETTER = "first-letter"
    BEFORE = "before"
    AFTER = "after"
    MARKER = "marker"
    BACKDROP = "backdrop"
    SELECTION = "selection"
    SEARCH_TEXT = "search-text"
    TARGET_TEXT = "target-text"
    SPELLING_ERROR = "spelling-error"
    GRAMMAR_ERROR = "grammar-error"
    HIGHLIGHT = "highlight"
    FIRST_LINE_INHERITED = "first-line-inherited"
    SCROLL_MARKER = "scroll-marker"
    SCROLL_MARKER_GROUP = "scroll-marker-group"
    SCROLLBAR = "scrollbar"
    SCROLLBAR_THUMB = "scrollbar-thumb"
    SCROLLBAR_BUTTON = "scrollbar-button"
    SCROLLBAR_TRACK = "scrollbar-track"
    SCROLLBAR_TRACK_PIECE = "scrollbar-track-piece"
    SCROLLBAR_CORNER = "scrollbar-corner"
    RESIZER = "resizer"
    INPUT_LIST_BUTTON = "input-list-button"
    VIEW_TRANSITION = "view-transition"
    VIEW_TRANSITION_GROUP = "view-transition-group"
    VIEW_TRANSITION_IMAGE_PAIR = "view-transition-image-pair"
    VIEW_TRANSITION_OLD = "view-transition-old"
    VIEW_TRANSITION_NEW = "view-transition-new"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> PseudoType:
        return cls(json)

AFTER = 'after' class-attribute instance-attribute

BACKDROP = 'backdrop' class-attribute instance-attribute

BEFORE = 'before' class-attribute instance-attribute

FIRST_LETTER = 'first-letter' class-attribute instance-attribute

FIRST_LINE = 'first-line' class-attribute instance-attribute

FIRST_LINE_INHERITED = 'first-line-inherited' class-attribute instance-attribute

GRAMMAR_ERROR = 'grammar-error' class-attribute instance-attribute

HIGHLIGHT = 'highlight' class-attribute instance-attribute

INPUT_LIST_BUTTON = 'input-list-button' class-attribute instance-attribute

MARKER = 'marker' class-attribute instance-attribute

RESIZER = 'resizer' class-attribute instance-attribute

SCROLLBAR = 'scrollbar' class-attribute instance-attribute

SCROLLBAR_BUTTON = 'scrollbar-button' class-attribute instance-attribute

SCROLLBAR_CORNER = 'scrollbar-corner' class-attribute instance-attribute

SCROLLBAR_THUMB = 'scrollbar-thumb' class-attribute instance-attribute

SCROLLBAR_TRACK = 'scrollbar-track' class-attribute instance-attribute

SCROLLBAR_TRACK_PIECE = 'scrollbar-track-piece' class-attribute instance-attribute

SCROLL_MARKER = 'scroll-marker' class-attribute instance-attribute

SCROLL_MARKER_GROUP = 'scroll-marker-group' class-attribute instance-attribute

SEARCH_TEXT = 'search-text' class-attribute instance-attribute

SELECTION = 'selection' class-attribute instance-attribute

SPELLING_ERROR = 'spelling-error' class-attribute instance-attribute

TARGET_TEXT = 'target-text' class-attribute instance-attribute

VIEW_TRANSITION = 'view-transition' class-attribute instance-attribute

VIEW_TRANSITION_GROUP = 'view-transition-group' class-attribute instance-attribute

VIEW_TRANSITION_IMAGE_PAIR = 'view-transition-image-pair' class-attribute instance-attribute

VIEW_TRANSITION_NEW = 'view-transition-new' class-attribute instance-attribute

VIEW_TRANSITION_OLD = 'view-transition-old' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: str) -> PseudoType:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> str:
    return self.value

Quad

Bases: list

An array of quad vertices, x immediately followed by y for each point, points clock-wise.

Source code in zendriver/cdp/dom.py

class Quad(list):
    """
    An array of quad vertices, x immediately followed by y for each point, points clock-wise.
    """

    def to_json(self) -> typing.List[float]:
        return self

    @classmethod
    def from_json(cls, json: typing.List[float]) -> Quad:
        return cls(json)

    def __repr__(self):
        return "Quad({})".format(super().__repr__())

__repr__()

Source code in zendriver/cdp/dom.py

def __repr__(self):
    return "Quad({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: typing.List[float]) -> Quad:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> typing.List[float]:
    return self

RGBA dataclass

A structure holding an RGBA color.

Source code in zendriver/cdp/dom.py

@dataclass
class RGBA:
    """
    A structure holding an RGBA color.
    """

    #: The red component, in the [0-255] range.
    r: int

    #: The green component, in the [0-255] range.
    g: int

    #: The blue component, in the [0-255] range.
    b: int

    #: The alpha component, in the [0-1] range (default: 1).
    a: typing.Optional[float] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["r"] = self.r
        json["g"] = self.g
        json["b"] = self.b
        if self.a is not None:
            json["a"] = self.a
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> RGBA:
        return cls(
            r=int(json["r"]),
            g=int(json["g"]),
            b=int(json["b"]),
            a=float(json["a"]) if json.get("a", None) is not None else None,
        )

a: typing.Optional[float] = None class-attribute instance-attribute

b: int instance-attribute

g: int instance-attribute

r: int instance-attribute

__init__(r, g, b, a=None)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> RGBA:
    return cls(
        r=int(json["r"]),
        g=int(json["g"]),
        b=int(json["b"]),
        a=float(json["a"]) if json.get("a", None) is not None else None,
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["r"] = self.r
    json["g"] = self.g
    json["b"] = self.b
    if self.a is not None:
        json["a"] = self.a
    return json

Rect dataclass

Rectangle.

Source code in zendriver/cdp/dom.py

@dataclass
class Rect:
    """
    Rectangle.
    """

    #: X coordinate
    x: float

    #: Y coordinate
    y: float

    #: Rectangle width
    width: float

    #: Rectangle height
    height: float

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["x"] = self.x
        json["y"] = self.y
        json["width"] = self.width
        json["height"] = self.height
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> Rect:
        return cls(
            x=float(json["x"]),
            y=float(json["y"]),
            width=float(json["width"]),
            height=float(json["height"]),
        )

height: float instance-attribute

width: float instance-attribute

x: float instance-attribute

y: float instance-attribute

__init__(x, y, width, height)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> Rect:
    return cls(
        x=float(json["x"]),
        y=float(json["y"]),
        width=float(json["width"]),
        height=float(json["height"]),
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["x"] = self.x
    json["y"] = self.y
    json["width"] = self.width
    json["height"] = self.height
    return json

ScrollOrientation

Bases: Enum

Physical scroll orientation

Source code in zendriver/cdp/dom.py

class ScrollOrientation(enum.Enum):
    """
    Physical scroll orientation
    """

    HORIZONTAL = "horizontal"
    VERTICAL = "vertical"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> ScrollOrientation:
        return cls(json)

HORIZONTAL = 'horizontal' class-attribute instance-attribute

VERTICAL = 'vertical' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: str) -> ScrollOrientation:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> str:
    return self.value

SetChildNodes dataclass

Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.

Source code in zendriver/cdp/dom.py

@event_class("DOM.setChildNodes")
@dataclass
class SetChildNodes:
    """
    Fired when backend wants to provide client with the missing DOM structure. This happens upon
    most of the calls requesting node ids.
    """

    #: Parent node id to populate with children.
    parent_id: NodeId
    #: Child nodes array.
    nodes: typing.List[Node]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> SetChildNodes:
        return cls(
            parent_id=NodeId.from_json(json["parentId"]),
            nodes=[Node.from_json(i) for i in json["nodes"]],
        )

nodes: typing.List[Node] instance-attribute

parent_id: NodeId instance-attribute

__init__(parent_id, nodes)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> SetChildNodes:
    return cls(
        parent_id=NodeId.from_json(json["parentId"]),
        nodes=[Node.from_json(i) for i in json["nodes"]],
    )

ShadowRootPopped dataclass

EXPERIMENTAL

Called when shadow root is popped from the element.

Source code in zendriver/cdp/dom.py

@event_class("DOM.shadowRootPopped")
@dataclass
class ShadowRootPopped:
    """
    **EXPERIMENTAL**

    Called when shadow root is popped from the element.
    """

    #: Host element id.
    host_id: NodeId
    #: Shadow root id.
    root_id: NodeId

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ShadowRootPopped:
        return cls(
            host_id=NodeId.from_json(json["hostId"]),
            root_id=NodeId.from_json(json["rootId"]),
        )

host_id: NodeId instance-attribute

root_id: NodeId instance-attribute

__init__(host_id, root_id)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> ShadowRootPopped:
    return cls(
        host_id=NodeId.from_json(json["hostId"]),
        root_id=NodeId.from_json(json["rootId"]),
    )

ShadowRootPushed dataclass

EXPERIMENTAL

Called when shadow root is pushed into the element.

Source code in zendriver/cdp/dom.py

@event_class("DOM.shadowRootPushed")
@dataclass
class ShadowRootPushed:
    """
    **EXPERIMENTAL**

    Called when shadow root is pushed into the element.
    """

    #: Host element id.
    host_id: NodeId
    #: Shadow root.
    root: Node

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ShadowRootPushed:
        return cls(
            host_id=NodeId.from_json(json["hostId"]), root=Node.from_json(json["root"])
        )

host_id: NodeId instance-attribute

root: Node instance-attribute

__init__(host_id, root)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> ShadowRootPushed:
    return cls(
        host_id=NodeId.from_json(json["hostId"]), root=Node.from_json(json["root"])
    )

ShadowRootType

Bases: Enum

Shadow root type.

Source code in zendriver/cdp/dom.py

class ShadowRootType(enum.Enum):
    """
    Shadow root type.
    """

    USER_AGENT = "user-agent"
    OPEN_ = "open"
    CLOSED = "closed"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> ShadowRootType:
        return cls(json)

CLOSED = 'closed' class-attribute instance-attribute

OPEN_ = 'open' class-attribute instance-attribute

USER_AGENT = 'user-agent' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: str) -> ShadowRootType:
    return cls(json)

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> str:
    return self.value

ShapeOutsideInfo dataclass

CSS Shape Outside details.

Source code in zendriver/cdp/dom.py

@dataclass
class ShapeOutsideInfo:
    """
    CSS Shape Outside details.
    """

    #: Shape bounds
    bounds: Quad

    #: Shape coordinate details
    shape: typing.List[typing.Any]

    #: Margin shape bounds
    margin_shape: typing.List[typing.Any]

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["bounds"] = self.bounds.to_json()
        json["shape"] = [i for i in self.shape]
        json["marginShape"] = [i for i in self.margin_shape]
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ShapeOutsideInfo:
        return cls(
            bounds=Quad.from_json(json["bounds"]),
            shape=[i for i in json["shape"]],
            margin_shape=[i for i in json["marginShape"]],
        )

bounds: Quad instance-attribute

margin_shape: typing.List[typing.Any] instance-attribute

shape: typing.List[typing.Any] instance-attribute

__init__(bounds, shape, margin_shape)

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> ShapeOutsideInfo:
    return cls(
        bounds=Quad.from_json(json["bounds"]),
        shape=[i for i in json["shape"]],
        margin_shape=[i for i in json["marginShape"]],
    )

to_json()

Source code in zendriver/cdp/dom.py

def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["bounds"] = self.bounds.to_json()
    json["shape"] = [i for i in self.shape]
    json["marginShape"] = [i for i in self.margin_shape]
    return json

TopLayerElementsUpdated dataclass

EXPERIMENTAL

Called when top layer elements are changed.

Source code in zendriver/cdp/dom.py

@event_class("DOM.topLayerElementsUpdated")
@dataclass
class TopLayerElementsUpdated:
    """
    **EXPERIMENTAL**

    Called when top layer elements are changed.
    """

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> TopLayerElementsUpdated:
        return cls()

__init__()

from_json(json) classmethod

Source code in zendriver/cdp/dom.py

@classmethod
def from_json(cls, json: T_JSON_DICT) -> TopLayerElementsUpdated:
    return cls()

collect_class_names_from_subtree(node_id)

Collects class names for the node with given id and all of it's child nodes.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to collect class names.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[str]]	Class name list.

Source code in zendriver/cdp/dom.py

def collect_class_names_from_subtree(
    node_id: NodeId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[str]]:
    """
    Collects class names for the node with given id and all of it's child nodes.

    **EXPERIMENTAL**

    :param node_id: Id of the node to collect class names.
    :returns: Class name list.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.collectClassNamesFromSubtree",
        "params": params,
    }
    json = yield cmd_dict
    return [str(i) for i in json["classNames"]]

copy_to(node_id, target_node_id, insert_before_node_id=None)

Creates a deep copy of the specified node and places it into the target container before the given anchor.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to copy.	required
target_node_id	NodeId	Id of the element to drop the copy into.	required
insert_before_node_id	Optional[NodeId]	(Optional) Drop the copy before this node (if absent, the copy becomes the last child of targetNodeId).	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	Id of the node clone.

Source code in zendriver/cdp/dom.py

def copy_to(
    node_id: NodeId,
    target_node_id: NodeId,
    insert_before_node_id: typing.Optional[NodeId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Creates a deep copy of the specified node and places it into the target container before the
    given anchor.

    **EXPERIMENTAL**

    :param node_id: Id of the node to copy.
    :param target_node_id: Id of the element to drop the copy into.
    :param insert_before_node_id: *(Optional)* Drop the copy before this node (if absent, the copy becomes the last child of ```targetNodeId```).
    :returns: Id of the node clone.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["targetNodeId"] = target_node_id.to_json()
    if insert_before_node_id is not None:
        params["insertBeforeNodeId"] = insert_before_node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.copyTo",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

describe_node(node_id=None, backend_node_id=None, object_id=None, depth=None, pierce=None)

Describes node given its id, does not require domain to be enabled. Does not start tracking any objects, can be used for automation.

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None
depth	Optional[int]	(Optional) The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.	None
pierce	Optional[bool]	(Optional) Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Node]	Node description.

Source code in zendriver/cdp/dom.py

def describe_node(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
    depth: typing.Optional[int] = None,
    pierce: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, Node]:
    """
    Describes node given its id, does not require domain to be enabled. Does not start tracking any
    objects, can be used for automation.

    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    :param depth: *(Optional)* The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
    :param pierce: *(Optional)* Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
    :returns: Node description.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    if depth is not None:
        params["depth"] = depth
    if pierce is not None:
        params["pierce"] = pierce
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.describeNode",
        "params": params,
    }
    json = yield cmd_dict
    return Node.from_json(json["node"])

disable()

Disables DOM agent for the given page.

Source code in zendriver/cdp/dom.py

def disable() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Disables DOM agent for the given page.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.disable",
    }
    json = yield cmd_dict

discard_search_results(search_id)

Discards search results from the session with the given id. getSearchResults should no longer be called for that search.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
search_id	str	Unique search session identifier.	required

Source code in zendriver/cdp/dom.py

def discard_search_results(
    search_id: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Discards search results from the session with the given id. ``getSearchResults`` should no longer
    be called for that search.

    **EXPERIMENTAL**

    :param search_id: Unique search session identifier.
    """
    params: T_JSON_DICT = dict()
    params["searchId"] = search_id
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.discardSearchResults",
        "params": params,
    }
    json = yield cmd_dict

enable(include_whitespace=None)

Enables DOM agent for the given page.

Parameters:

Name	Type	Description	Default
include_whitespace	Optional[str]	(EXPERIMENTAL) (Optional) Whether to include whitespaces in the children array of returned Nodes.	None

Source code in zendriver/cdp/dom.py

def enable(
    include_whitespace: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Enables DOM agent for the given page.

    :param include_whitespace: **(EXPERIMENTAL)** *(Optional)* Whether to include whitespaces in the children array of returned Nodes.
    """
    params: T_JSON_DICT = dict()
    if include_whitespace is not None:
        params["includeWhitespace"] = include_whitespace
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.enable",
        "params": params,
    }
    json = yield cmd_dict

focus(node_id=None, backend_node_id=None, object_id=None)

Focuses the given element.

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None

Source code in zendriver/cdp/dom.py

def focus(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Focuses the given element.

    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.focus",
        "params": params,
    }
    json = yield cmd_dict

get_anchor_element(node_id, anchor_specifier=None)

Returns the target anchor element of the given anchor query according to https://www.w3.org/TR/css-anchor-position-1/#target.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the positioned element from which to find the anchor.	required
anchor_specifier	Optional[str]	(Optional) An optional anchor specifier, as defined in https://www.w3.org/TR/css-anchor-position-1/#anchor-specifier. If not provided, it will return the implicit anchor element for the given positioned element.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	The anchor element of the given anchor query.

Source code in zendriver/cdp/dom.py

def get_anchor_element(
    node_id: NodeId, anchor_specifier: typing.Optional[str] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Returns the target anchor element of the given anchor query according to
    https://www.w3.org/TR/css-anchor-position-1/#target.

    **EXPERIMENTAL**

    :param node_id: Id of the positioned element from which to find the anchor.
    :param anchor_specifier: *(Optional)* An optional anchor specifier, as defined in https://www.w3.org/TR/css-anchor-position-1/#anchor-specifier. If not provided, it will return the implicit anchor element for the given positioned element.
    :returns: The anchor element of the given anchor query.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    if anchor_specifier is not None:
        params["anchorSpecifier"] = anchor_specifier
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getAnchorElement",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

get_attributes(node_id)

Returns attributes for the specified node.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to retrieve attributes for.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[str]]	An interleaved array of node attribute names and values.

Source code in zendriver/cdp/dom.py

def get_attributes(
    node_id: NodeId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[str]]:
    """
    Returns attributes for the specified node.

    :param node_id: Id of the node to retrieve attributes for.
    :returns: An interleaved array of node attribute names and values.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getAttributes",
        "params": params,
    }
    json = yield cmd_dict
    return [str(i) for i in json["attributes"]]

get_box_model(node_id=None, backend_node_id=None, object_id=None)

Returns boxes for the given node.

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, BoxModel]	Box model for the node.

Source code in zendriver/cdp/dom.py

def get_box_model(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, BoxModel]:
    """
    Returns boxes for the given node.

    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    :returns: Box model for the node.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getBoxModel",
        "params": params,
    }
    json = yield cmd_dict
    return BoxModel.from_json(json["model"])

get_container_for_node(node_id, container_name=None, physical_axes=None, logical_axes=None)

Returns the query container of the given node based on container query conditions: containerName, physical, and logical axes. If no axes are provided, the style container is returned, which is the direct parent or the closest element with a matching container-name.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId		required
container_name	Optional[str]	(Optional)	None
physical_axes	Optional[PhysicalAxes]	(Optional)	None
logical_axes	Optional[LogicalAxes]	(Optional)	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Optional[NodeId]]	(Optional) The container node for the given node, or null if not found.

Source code in zendriver/cdp/dom.py

def get_container_for_node(
    node_id: NodeId,
    container_name: typing.Optional[str] = None,
    physical_axes: typing.Optional[PhysicalAxes] = None,
    logical_axes: typing.Optional[LogicalAxes] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.Optional[NodeId]]:
    """
    Returns the query container of the given node based on container query
    conditions: containerName, physical, and logical axes. If no axes are
    provided, the style container is returned, which is the direct parent or the
    closest element with a matching container-name.

    **EXPERIMENTAL**

    :param node_id:
    :param container_name: *(Optional)*
    :param physical_axes: *(Optional)*
    :param logical_axes: *(Optional)*
    :returns: *(Optional)* The container node for the given node, or null if not found.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    if container_name is not None:
        params["containerName"] = container_name
    if physical_axes is not None:
        params["physicalAxes"] = physical_axes.to_json()
    if logical_axes is not None:
        params["logicalAxes"] = logical_axes.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getContainerForNode",
        "params": params,
    }
    json = yield cmd_dict
    return (
        NodeId.from_json(json["nodeId"])
        if json.get("nodeId", None) is not None
        else None
    )

get_content_quads(node_id=None, backend_node_id=None, object_id=None)

Returns quads that describe node position on the page. This method might return multiple quads for inline nodes.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[Quad]]	Quads that describe node layout relative to viewport.

Source code in zendriver/cdp/dom.py

def get_content_quads(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[Quad]]:
    """
    Returns quads that describe node position on the page. This method
    might return multiple quads for inline nodes.

    **EXPERIMENTAL**

    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    :returns: Quads that describe node layout relative to viewport.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getContentQuads",
        "params": params,
    }
    json = yield cmd_dict
    return [Quad.from_json(i) for i in json["quads"]]

get_document(depth=None, pierce=None)

Returns the root DOM node (and optionally the subtree) to the caller. Implicitly enables the DOM domain events for the current target.

Parameters:

Name	Type	Description	Default
depth	Optional[int]	(Optional) The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.	None
pierce	Optional[bool]	(Optional) Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Node]	Resulting node.

Source code in zendriver/cdp/dom.py

def get_document(
    depth: typing.Optional[int] = None, pierce: typing.Optional[bool] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, Node]:
    """
    Returns the root DOM node (and optionally the subtree) to the caller.
    Implicitly enables the DOM domain events for the current target.

    :param depth: *(Optional)* The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
    :param pierce: *(Optional)* Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
    :returns: Resulting node.
    """
    params: T_JSON_DICT = dict()
    if depth is not None:
        params["depth"] = depth
    if pierce is not None:
        params["pierce"] = pierce
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getDocument",
        "params": params,
    }
    json = yield cmd_dict
    return Node.from_json(json["root"])

get_element_by_relation(node_id, relation)

Returns the NodeId of the matched element according to certain relations.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node from which to query the relation.	required
relation	str	Type of relation to get.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	NodeId of the element matching the queried relation.

Source code in zendriver/cdp/dom.py

def get_element_by_relation(
    node_id: NodeId, relation: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Returns the NodeId of the matched element according to certain relations.

    **EXPERIMENTAL**

    :param node_id: Id of the node from which to query the relation.
    :param relation: Type of relation to get.
    :returns: NodeId of the element matching the queried relation.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["relation"] = relation
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getElementByRelation",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

get_file_info(object_id)

Returns file information for the given File wrapper.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
object_id	RemoteObjectId	JavaScript object id of the node wrapper.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, str]

Source code in zendriver/cdp/dom.py

def get_file_info(
    object_id: runtime.RemoteObjectId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, str]:
    """
    Returns file information for the given
    File wrapper.

    **EXPERIMENTAL**

    :param object_id: JavaScript object id of the node wrapper.
    :returns:
    """
    params: T_JSON_DICT = dict()
    params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getFileInfo",
        "params": params,
    }
    json = yield cmd_dict
    return str(json["path"])

get_flattened_document(depth=None, pierce=None)

Returns the root DOM node (and optionally the subtree) to the caller. Deprecated, as it is not designed to work well with the rest of the DOM agent. Use DOMSnapshot.captureSnapshot instead.

.. deprecated:: 1.3

Parameters:

Name	Type	Description	Default
depth	Optional[int]	(Optional) The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.	None
pierce	Optional[bool]	(Optional) Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[Node]]	Resulting node.

Source code in zendriver/cdp/dom.py

@deprecated(version="1.3")
def get_flattened_document(
    depth: typing.Optional[int] = None, pierce: typing.Optional[bool] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[Node]]:
    """
    Returns the root DOM node (and optionally the subtree) to the caller.
    Deprecated, as it is not designed to work well with the rest of the DOM agent.
    Use DOMSnapshot.captureSnapshot instead.

    .. deprecated:: 1.3

    :param depth: *(Optional)* The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
    :param pierce: *(Optional)* Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
    :returns: Resulting node.
    """
    params: T_JSON_DICT = dict()
    if depth is not None:
        params["depth"] = depth
    if pierce is not None:
        params["pierce"] = pierce
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getFlattenedDocument",
        "params": params,
    }
    json = yield cmd_dict
    return [Node.from_json(i) for i in json["nodes"]]

get_frame_owner(frame_id)

Returns iframe node that owns iframe with the given domain.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
frame_id	FrameId		required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[BackendNodeId, Optional[NodeId]]]	A tuple with the following items: 0. backendNodeId - Resulting node. 1. nodeId - (Optional) Id of the node at given coordinates, only when enabled and requested document.

Source code in zendriver/cdp/dom.py

def get_frame_owner(
    frame_id: page.FrameId,
) -> typing.Generator[
    T_JSON_DICT, T_JSON_DICT, typing.Tuple[BackendNodeId, typing.Optional[NodeId]]
]:
    """
    Returns iframe node that owns iframe with the given domain.

    **EXPERIMENTAL**

    :param frame_id:
    :returns: A tuple with the following items:

        0. **backendNodeId** - Resulting node.
        1. **nodeId** - *(Optional)* Id of the node at given coordinates, only when enabled and requested document.
    """
    params: T_JSON_DICT = dict()
    params["frameId"] = frame_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getFrameOwner",
        "params": params,
    }
    json = yield cmd_dict
    return (
        BackendNodeId.from_json(json["backendNodeId"]),
        (
            NodeId.from_json(json["nodeId"])
            if json.get("nodeId", None) is not None
            else None
        ),
    )

get_node_for_location(x, y, include_user_agent_shadow_dom=None, ignore_pointer_events_none=None)

Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is either returned or not.

Parameters:

Name	Type	Description	Default
x	int	X coordinate.	required
y	int	Y coordinate.	required
include_user_agent_shadow_dom	Optional[bool]	(Optional) False to skip to the nearest non-UA shadow root ancestor (default: false).	None
ignore_pointer_events_none	Optional[bool]	(Optional) Whether to ignore pointer-events: none on elements and hit test them.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[BackendNodeId, FrameId, Optional[NodeId]]]	A tuple with the following items: 0. backendNodeId - Resulting node. 1. frameId - Frame this node belongs to. 2. nodeId - (Optional) Id of the node at given coordinates, only when enabled and requested document.

Source code in zendriver/cdp/dom.py

def get_node_for_location(
    x: int,
    y: int,
    include_user_agent_shadow_dom: typing.Optional[bool] = None,
    ignore_pointer_events_none: typing.Optional[bool] = None,
) -> typing.Generator[
    T_JSON_DICT,
    T_JSON_DICT,
    typing.Tuple[BackendNodeId, page.FrameId, typing.Optional[NodeId]],
]:
    """
    Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is
    either returned or not.

    :param x: X coordinate.
    :param y: Y coordinate.
    :param include_user_agent_shadow_dom: *(Optional)* False to skip to the nearest non-UA shadow root ancestor (default: false).
    :param ignore_pointer_events_none: *(Optional)* Whether to ignore pointer-events: none on elements and hit test them.
    :returns: A tuple with the following items:

        0. **backendNodeId** - Resulting node.
        1. **frameId** - Frame this node belongs to.
        2. **nodeId** - *(Optional)* Id of the node at given coordinates, only when enabled and requested document.
    """
    params: T_JSON_DICT = dict()
    params["x"] = x
    params["y"] = y
    if include_user_agent_shadow_dom is not None:
        params["includeUserAgentShadowDOM"] = include_user_agent_shadow_dom
    if ignore_pointer_events_none is not None:
        params["ignorePointerEventsNone"] = ignore_pointer_events_none
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getNodeForLocation",
        "params": params,
    }
    json = yield cmd_dict
    return (
        BackendNodeId.from_json(json["backendNodeId"]),
        page.FrameId.from_json(json["frameId"]),
        (
            NodeId.from_json(json["nodeId"])
            if json.get("nodeId", None) is not None
            else None
        ),
    )

get_node_stack_traces(node_id)

Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to get stack traces for.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Optional[StackTrace]]	(Optional) Creation stack trace, if available.

Source code in zendriver/cdp/dom.py

def get_node_stack_traces(
    node_id: NodeId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.Optional[runtime.StackTrace]]:
    """
    Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.

    **EXPERIMENTAL**

    :param node_id: Id of the node to get stack traces for.
    :returns: *(Optional)* Creation stack trace, if available.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getNodeStackTraces",
        "params": params,
    }
    json = yield cmd_dict
    return (
        runtime.StackTrace.from_json(json["creation"])
        if json.get("creation", None) is not None
        else None
    )

get_nodes_for_subtree_by_style(node_id, computed_styles, pierce=None)

Finds nodes with a given computed style in a subtree.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Node ID pointing to the root of a subtree.	required
computed_styles	List[CSSComputedStyleProperty]	The style to filter nodes by (includes nodes if any of properties matches).	required
pierce	Optional[bool]	(Optional) Whether or not iframes and shadow roots in the same target should be traversed when returning the results (default is false).	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[NodeId]]	Resulting nodes.

Source code in zendriver/cdp/dom.py

def get_nodes_for_subtree_by_style(
    node_id: NodeId,
    computed_styles: typing.List[CSSComputedStyleProperty],
    pierce: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[NodeId]]:
    """
    Finds nodes with a given computed style in a subtree.

    **EXPERIMENTAL**

    :param node_id: Node ID pointing to the root of a subtree.
    :param computed_styles: The style to filter nodes by (includes nodes if any of properties matches).
    :param pierce: *(Optional)* Whether or not iframes and shadow roots in the same target should be traversed when returning the results (default is false).
    :returns: Resulting nodes.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["computedStyles"] = [i.to_json() for i in computed_styles]
    if pierce is not None:
        params["pierce"] = pierce
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getNodesForSubtreeByStyle",
        "params": params,
    }
    json = yield cmd_dict
    return [NodeId.from_json(i) for i in json["nodeIds"]]

get_outer_html(node_id=None, backend_node_id=None, object_id=None)

Returns node's HTML markup.

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, str]	Outer HTML markup.

Source code in zendriver/cdp/dom.py

def get_outer_html(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, str]:
    """
    Returns node's HTML markup.

    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    :returns: Outer HTML markup.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getOuterHTML",
        "params": params,
    }
    json = yield cmd_dict
    return str(json["outerHTML"])

get_querying_descendants_for_container(node_id)

Returns the descendants of a container query container that have container queries against this container.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the container node to find querying descendants from.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[NodeId]]	Descendant nodes with container queries against the given container.

Source code in zendriver/cdp/dom.py

def get_querying_descendants_for_container(
    node_id: NodeId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[NodeId]]:
    """
    Returns the descendants of a container query container that have
    container queries against this container.

    **EXPERIMENTAL**

    :param node_id: Id of the container node to find querying descendants from.
    :returns: Descendant nodes with container queries against the given container.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getQueryingDescendantsForContainer",
        "params": params,
    }
    json = yield cmd_dict
    return [NodeId.from_json(i) for i in json["nodeIds"]]

get_relayout_boundary(node_id)

Returns the id of the nearest ancestor that is a relayout boundary.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	Relayout boundary node id for the given node.

Source code in zendriver/cdp/dom.py

def get_relayout_boundary(
    node_id: NodeId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Returns the id of the nearest ancestor that is a relayout boundary.

    **EXPERIMENTAL**

    :param node_id: Id of the node.
    :returns: Relayout boundary node id for the given node.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getRelayoutBoundary",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

get_search_results(search_id, from_index, to_index)

Returns search results from given fromIndex to given toIndex from the search with the given identifier.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
search_id	str	Unique search session identifier.	required
from_index	int	Start index of the search result to be returned.	required
to_index	int	End index of the search result to be returned.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[NodeId]]	Ids of the search result nodes.

Source code in zendriver/cdp/dom.py

def get_search_results(
    search_id: str, from_index: int, to_index: int
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[NodeId]]:
    """
    Returns search results from given ``fromIndex`` to given ``toIndex`` from the search with the given
    identifier.

    **EXPERIMENTAL**

    :param search_id: Unique search session identifier.
    :param from_index: Start index of the search result to be returned.
    :param to_index: End index of the search result to be returned.
    :returns: Ids of the search result nodes.
    """
    params: T_JSON_DICT = dict()
    params["searchId"] = search_id
    params["fromIndex"] = from_index
    params["toIndex"] = to_index
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getSearchResults",
        "params": params,
    }
    json = yield cmd_dict
    return [NodeId.from_json(i) for i in json["nodeIds"]]

get_top_layer_elements()

Returns NodeIds of current top layer elements. Top layer is rendered closest to the user within a viewport, therefore its elements always appear on top of all other content.

EXPERIMENTAL

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[NodeId]]	NodeIds of top layer elements

Source code in zendriver/cdp/dom.py

def get_top_layer_elements() -> (
    typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[NodeId]]
):
    """
    Returns NodeIds of current top layer elements.
    Top layer is rendered closest to the user within a viewport, therefore its elements always
    appear on top of all other content.

    **EXPERIMENTAL**

    :returns: NodeIds of top layer elements
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.getTopLayerElements",
    }
    json = yield cmd_dict
    return [NodeId.from_json(i) for i in json["nodeIds"]]

hide_highlight()

Hides any highlight.

Source code in zendriver/cdp/dom.py

def hide_highlight() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Hides any highlight.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.hideHighlight",
    }
    json = yield cmd_dict

highlight_node()

Highlights DOM node.

Source code in zendriver/cdp/dom.py

def highlight_node() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Highlights DOM node.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.highlightNode",
    }
    json = yield cmd_dict

highlight_rect()

Highlights given rectangle.

Source code in zendriver/cdp/dom.py

def highlight_rect() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Highlights given rectangle.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.highlightRect",
    }
    json = yield cmd_dict

mark_undoable_state()

Marks last undoable state.

EXPERIMENTAL

Source code in zendriver/cdp/dom.py

def mark_undoable_state() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Marks last undoable state.

    **EXPERIMENTAL**
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.markUndoableState",
    }
    json = yield cmd_dict

move_to(node_id, target_node_id, insert_before_node_id=None)

Moves node into the new container, places it before the given anchor.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to move.	required
target_node_id	NodeId	Id of the element to drop the moved node into.	required
insert_before_node_id	Optional[NodeId]	(Optional) Drop node before this one (if absent, the moved node becomes the last child of targetNodeId).	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	New id of the moved node.

Source code in zendriver/cdp/dom.py

def move_to(
    node_id: NodeId,
    target_node_id: NodeId,
    insert_before_node_id: typing.Optional[NodeId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Moves node into the new container, places it before the given anchor.

    :param node_id: Id of the node to move.
    :param target_node_id: Id of the element to drop the moved node into.
    :param insert_before_node_id: *(Optional)* Drop node before this one (if absent, the moved node becomes the last child of ```targetNodeId```).
    :returns: New id of the moved node.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["targetNodeId"] = target_node_id.to_json()
    if insert_before_node_id is not None:
        params["insertBeforeNodeId"] = insert_before_node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.moveTo",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

perform_search(query, include_user_agent_shadow_dom=None)

Searches for a given string in the DOM tree. Use getSearchResults to access search results or cancelSearch to end this search session.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
query	str	Plain text or query selector or XPath search query.	required
include_user_agent_shadow_dom	Optional[bool]	(Optional) True to search in user agent shadow DOM.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[str, int]]	A tuple with the following items: 0. searchId - Unique search session identifier. 1. resultCount - Number of search results.

Source code in zendriver/cdp/dom.py

def perform_search(
    query: str, include_user_agent_shadow_dom: typing.Optional[bool] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.Tuple[str, int]]:
    """
    Searches for a given string in the DOM tree. Use ``getSearchResults`` to access search results or
    ``cancelSearch`` to end this search session.

    **EXPERIMENTAL**

    :param query: Plain text or query selector or XPath search query.
    :param include_user_agent_shadow_dom: *(Optional)* True to search in user agent shadow DOM.
    :returns: A tuple with the following items:

        0. **searchId** - Unique search session identifier.
        1. **resultCount** - Number of search results.
    """
    params: T_JSON_DICT = dict()
    params["query"] = query
    if include_user_agent_shadow_dom is not None:
        params["includeUserAgentShadowDOM"] = include_user_agent_shadow_dom
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.performSearch",
        "params": params,
    }
    json = yield cmd_dict
    return (str(json["searchId"]), int(json["resultCount"]))

push_node_by_path_to_frontend(path)

Requests that the node is sent to the caller given its path. // FIXME, use XPath

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
path	str	Path to node in the proprietary format.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	Id of the node for given path.

Source code in zendriver/cdp/dom.py

def push_node_by_path_to_frontend(
    path: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Requests that the node is sent to the caller given its path. // FIXME, use XPath

    **EXPERIMENTAL**

    :param path: Path to node in the proprietary format.
    :returns: Id of the node for given path.
    """
    params: T_JSON_DICT = dict()
    params["path"] = path
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.pushNodeByPathToFrontend",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

push_nodes_by_backend_ids_to_frontend(backend_node_ids)

Requests that a batch of nodes is sent to the caller given their backend node ids.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
backend_node_ids	List[BackendNodeId]	The array of backend node ids.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[NodeId]]	The array of ids of pushed nodes that correspond to the backend ids specified in backendNodeIds.

Source code in zendriver/cdp/dom.py

def push_nodes_by_backend_ids_to_frontend(
    backend_node_ids: typing.List[BackendNodeId],
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[NodeId]]:
    """
    Requests that a batch of nodes is sent to the caller given their backend node ids.

    **EXPERIMENTAL**

    :param backend_node_ids: The array of backend node ids.
    :returns: The array of ids of pushed nodes that correspond to the backend ids specified in backendNodeIds.
    """
    params: T_JSON_DICT = dict()
    params["backendNodeIds"] = [i.to_json() for i in backend_node_ids]
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.pushNodesByBackendIdsToFrontend",
        "params": params,
    }
    json = yield cmd_dict
    return [NodeId.from_json(i) for i in json["nodeIds"]]

query_selector(node_id, selector)

Executes querySelector on a given node.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to query upon.	required
selector	str	Selector string.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	Query selector result.

Source code in zendriver/cdp/dom.py

def query_selector(
    node_id: NodeId, selector: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Executes ``querySelector`` on a given node.

    :param node_id: Id of the node to query upon.
    :param selector: Selector string.
    :returns: Query selector result.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["selector"] = selector
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.querySelector",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

query_selector_all(node_id, selector)

Executes querySelectorAll on a given node.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to query upon.	required
selector	str	Selector string.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, List[NodeId]]	Query selector result.

Source code in zendriver/cdp/dom.py

def query_selector_all(
    node_id: NodeId, selector: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[NodeId]]:
    """
    Executes ``querySelectorAll`` on a given node.

    :param node_id: Id of the node to query upon.
    :param selector: Selector string.
    :returns: Query selector result.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["selector"] = selector
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.querySelectorAll",
        "params": params,
    }
    json = yield cmd_dict
    return [NodeId.from_json(i) for i in json["nodeIds"]]

redo()

Re-does the last undone action.

EXPERIMENTAL

Source code in zendriver/cdp/dom.py

def redo() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Re-does the last undone action.

    **EXPERIMENTAL**
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.redo",
    }
    json = yield cmd_dict

remove_attribute(node_id, name)

Removes attribute with given name from an element with given id.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the element to remove attribute from.	required
name	str	Name of the attribute to remove.	required

Source code in zendriver/cdp/dom.py

def remove_attribute(
    node_id: NodeId, name: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes attribute with given name from an element with given id.

    :param node_id: Id of the element to remove attribute from.
    :param name: Name of the attribute to remove.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["name"] = name
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.removeAttribute",
        "params": params,
    }
    json = yield cmd_dict

remove_node(node_id)

Removes node with given id.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to remove.	required

Source code in zendriver/cdp/dom.py

def remove_node(node_id: NodeId) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes node with given id.

    :param node_id: Id of the node to remove.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.removeNode",
        "params": params,
    }
    json = yield cmd_dict

request_child_nodes(node_id, depth=None, pierce=None)

Requests that children of the node with given id are returned to the caller in form of setChildNodes events where not only immediate children are retrieved, but all children down to the specified depth.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to get children for.	required
depth	Optional[int]	(Optional) The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.	None
pierce	Optional[bool]	(Optional) Whether or not iframes and shadow roots should be traversed when returning the sub-tree (default is false).	None

Source code in zendriver/cdp/dom.py

def request_child_nodes(
    node_id: NodeId,
    depth: typing.Optional[int] = None,
    pierce: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Requests that children of the node with given id are returned to the caller in form of
    ``setChildNodes`` events where not only immediate children are retrieved, but all children down to
    the specified depth.

    :param node_id: Id of the node to get children for.
    :param depth: *(Optional)* The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
    :param pierce: *(Optional)* Whether or not iframes and shadow roots should be traversed when returning the sub-tree (default is false).
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    if depth is not None:
        params["depth"] = depth
    if pierce is not None:
        params["pierce"] = pierce
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.requestChildNodes",
        "params": params,
    }
    json = yield cmd_dict

request_node(object_id)

Requests that the node is sent to the caller given the JavaScript node object reference. All nodes that form the path from the node to the root are also sent to the client as a series of setChildNodes notifications.

Parameters:

Name	Type	Description	Default
object_id	RemoteObjectId	JavaScript object id to convert into node.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	Node id for given object.

Source code in zendriver/cdp/dom.py

def request_node(
    object_id: runtime.RemoteObjectId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Requests that the node is sent to the caller given the JavaScript node object reference. All
    nodes that form the path from the node to the root are also sent to the client as a series of
    ``setChildNodes`` notifications.

    :param object_id: JavaScript object id to convert into node.
    :returns: Node id for given object.
    """
    params: T_JSON_DICT = dict()
    params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.requestNode",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

resolve_node(node_id=None, backend_node_id=None, object_group=None, execution_context_id=None)

Resolves the JavaScript node object for a given NodeId or BackendNodeId.

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Id of the node to resolve.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Backend identifier of the node to resolve.	None
object_group	Optional[str]	(Optional) Symbolic group name that can be used to release multiple objects.	None
execution_context_id	Optional[ExecutionContextId]	(Optional) Execution context in which to resolve the node.	None

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, RemoteObject]	JavaScript object wrapper for given node.

Source code in zendriver/cdp/dom.py

def resolve_node(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_group: typing.Optional[str] = None,
    execution_context_id: typing.Optional[runtime.ExecutionContextId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, runtime.RemoteObject]:
    """
    Resolves the JavaScript node object for a given NodeId or BackendNodeId.

    :param node_id: *(Optional)* Id of the node to resolve.
    :param backend_node_id: *(Optional)* Backend identifier of the node to resolve.
    :param object_group: *(Optional)* Symbolic group name that can be used to release multiple objects.
    :param execution_context_id: *(Optional)* Execution context in which to resolve the node.
    :returns: JavaScript object wrapper for given node.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_group is not None:
        params["objectGroup"] = object_group
    if execution_context_id is not None:
        params["executionContextId"] = execution_context_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.resolveNode",
        "params": params,
    }
    json = yield cmd_dict
    return runtime.RemoteObject.from_json(json["object"])

scroll_into_view_if_needed(node_id=None, backend_node_id=None, object_id=None, rect=None)

Scrolls the specified rect of the given node into view if not already visible. Note: exactly one between nodeId, backendNodeId and objectId should be passed to identify the node.

Parameters:

Name	Type	Description	Default
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None
rect	Optional[Rect]	(Optional) The rect to be scrolled into view, relative to the node's border box, in CSS pixels. When omitted, center of the node will be used, similar to Element.scrollIntoView.	None

Source code in zendriver/cdp/dom.py

def scroll_into_view_if_needed(
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
    rect: typing.Optional[Rect] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Scrolls the specified rect of the given node into view if not already visible.
    Note: exactly one between nodeId, backendNodeId and objectId should be passed
    to identify the node.

    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    :param rect: *(Optional)* The rect to be scrolled into view, relative to the node's border box, in CSS pixels. When omitted, center of the node will be used, similar to Element.scrollIntoView.
    """
    params: T_JSON_DICT = dict()
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    if rect is not None:
        params["rect"] = rect.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.scrollIntoViewIfNeeded",
        "params": params,
    }
    json = yield cmd_dict

set_attribute_value(node_id, name, value)

Sets attribute for an element with given id.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the element to set attribute for.	required
name	str	Attribute name.	required
value	str	Attribute value.	required

Source code in zendriver/cdp/dom.py

def set_attribute_value(
    node_id: NodeId, name: str, value: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets attribute for an element with given id.

    :param node_id: Id of the element to set attribute for.
    :param name: Attribute name.
    :param value: Attribute value.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["name"] = name
    params["value"] = value
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setAttributeValue",
        "params": params,
    }
    json = yield cmd_dict

set_attributes_as_text(node_id, text, name=None)

Sets attributes on element with given id. This method is useful when user edits some existing attribute value and types in several attribute name/value pairs.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the element to set attributes for.	required
text	str	Text with a number of attributes. Will parse this text using HTML parser.	required
name	Optional[str]	(Optional) Attribute name to replace with new attributes derived from text in case text parsed successfully.	None

Source code in zendriver/cdp/dom.py

def set_attributes_as_text(
    node_id: NodeId, text: str, name: typing.Optional[str] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets attributes on element with given id. This method is useful when user edits some existing
    attribute value and types in several attribute name/value pairs.

    :param node_id: Id of the element to set attributes for.
    :param text: Text with a number of attributes. Will parse this text using HTML parser.
    :param name: *(Optional)* Attribute name to replace with new attributes derived from text in case text parsed successfully.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["text"] = text
    if name is not None:
        params["name"] = name
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setAttributesAsText",
        "params": params,
    }
    json = yield cmd_dict

set_file_input_files(files, node_id=None, backend_node_id=None, object_id=None)

Sets files for the given file input element.

Parameters:

Name	Type	Description	Default
files	List[str]	Array of file paths to set.	required
node_id	Optional[NodeId]	(Optional) Identifier of the node.	None
backend_node_id	Optional[BackendNodeId]	(Optional) Identifier of the backend node.	None
object_id	Optional[RemoteObjectId]	(Optional) JavaScript object id of the node wrapper.	None

Source code in zendriver/cdp/dom.py

def set_file_input_files(
    files: typing.List[str],
    node_id: typing.Optional[NodeId] = None,
    backend_node_id: typing.Optional[BackendNodeId] = None,
    object_id: typing.Optional[runtime.RemoteObjectId] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets files for the given file input element.

    :param files: Array of file paths to set.
    :param node_id: *(Optional)* Identifier of the node.
    :param backend_node_id: *(Optional)* Identifier of the backend node.
    :param object_id: *(Optional)* JavaScript object id of the node wrapper.
    """
    params: T_JSON_DICT = dict()
    params["files"] = [i for i in files]
    if node_id is not None:
        params["nodeId"] = node_id.to_json()
    if backend_node_id is not None:
        params["backendNodeId"] = backend_node_id.to_json()
    if object_id is not None:
        params["objectId"] = object_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setFileInputFiles",
        "params": params,
    }
    json = yield cmd_dict

set_inspected_node(node_id)

Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
node_id	NodeId	DOM node id to be accessible by means of $x command line API.	required

Source code in zendriver/cdp/dom.py

def set_inspected_node(
    node_id: NodeId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Enables console to refer to the node with given id via $x (see Command Line API for more details
    $x functions).

    **EXPERIMENTAL**

    :param node_id: DOM node id to be accessible by means of $x command line API.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setInspectedNode",
        "params": params,
    }
    json = yield cmd_dict

set_node_name(node_id, name)

Sets node name for a node with given id.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to set name for.	required
name	str	New node's name.	required

Returns:

Type	Description
Generator[T_JSON_DICT, T_JSON_DICT, NodeId]	New node's id.

Source code in zendriver/cdp/dom.py

def set_node_name(
    node_id: NodeId, name: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, NodeId]:
    """
    Sets node name for a node with given id.

    :param node_id: Id of the node to set name for.
    :param name: New node's name.
    :returns: New node's id.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["name"] = name
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setNodeName",
        "params": params,
    }
    json = yield cmd_dict
    return NodeId.from_json(json["nodeId"])

set_node_stack_traces_enabled(enable)

Sets if stack traces should be captured for Nodes. See Node.getNodeStackTraces. Default is disabled.

EXPERIMENTAL

Parameters:

Name	Type	Description	Default
enable	bool	Enable or disable.	required

Source code in zendriver/cdp/dom.py

def set_node_stack_traces_enabled(
    enable: bool,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets if stack traces should be captured for Nodes. See ``Node.getNodeStackTraces``. Default is disabled.

    **EXPERIMENTAL**

    :param enable: Enable or disable.
    """
    params: T_JSON_DICT = dict()
    params["enable"] = enable
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setNodeStackTracesEnabled",
        "params": params,
    }
    json = yield cmd_dict

set_node_value(node_id, value)

Sets node value for a node with given id.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to set value for.	required
value	str	New node's value.	required

Source code in zendriver/cdp/dom.py

def set_node_value(
    node_id: NodeId, value: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets node value for a node with given id.

    :param node_id: Id of the node to set value for.
    :param value: New node's value.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["value"] = value
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setNodeValue",
        "params": params,
    }
    json = yield cmd_dict

set_outer_html(node_id, outer_html)

Sets node HTML markup, returns new node id.

Parameters:

Name	Type	Description	Default
node_id	NodeId	Id of the node to set markup for.	required
outer_html	str	Outer HTML markup to set.	required

Source code in zendriver/cdp/dom.py

def set_outer_html(
    node_id: NodeId, outer_html: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets node HTML markup, returns new node id.

    :param node_id: Id of the node to set markup for.
    :param outer_html: Outer HTML markup to set.
    """
    params: T_JSON_DICT = dict()
    params["nodeId"] = node_id.to_json()
    params["outerHTML"] = outer_html
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.setOuterHTML",
        "params": params,
    }
    json = yield cmd_dict

undo()

Undoes the last performed action.

EXPERIMENTAL

Source code in zendriver/cdp/dom.py

def undo() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Undoes the last performed action.

    **EXPERIMENTAL**
    """
    cmd_dict: T_JSON_DICT = {
        "method": "DOM.undo",
    }
    json = yield cmd_dict