Skip to content

input_

DragData dataclass

Source code in zendriver/cdp/input_.py 
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
@dataclass
class DragData:
    items: typing.List[DragDataItem]

    #: Bit field representing allowed drag operations. Copy = 1, Link = 2, Move = 16
    drag_operations_mask: int

    #: List of filenames that should be included when dropping
    files: typing.Optional[typing.List[str]] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["items"] = [i.to_json() for i in self.items]
        json["dragOperationsMask"] = self.drag_operations_mask
        if self.files is not None:
            json["files"] = [i for i in self.files]
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DragData:
        return cls(
            items=[DragDataItem.from_json(i) for i in json["items"]],
            drag_operations_mask=int(json["dragOperationsMask"]),
            files=(
                [str(i) for i in json["files"]]
                if json.get("files", None) is not None
                else None
            ),
        )

drag_operations_mask: int instance-attribute

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

items: typing.List[DragDataItem] instance-attribute

__init__(items, drag_operations_mask, files=None)

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
213
214
215
216
217
218
219
220
221
222
223
@classmethod
def from_json(cls, json: T_JSON_DICT) -> DragData:
    return cls(
        items=[DragDataItem.from_json(i) for i in json["items"]],
        drag_operations_mask=int(json["dragOperationsMask"]),
        files=(
            [str(i) for i in json["files"]]
            if json.get("files", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/input_.py 
205
206
207
208
209
210
211
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["items"] = [i.to_json() for i in self.items]
    json["dragOperationsMask"] = self.drag_operations_mask
    if self.files is not None:
        json["files"] = [i for i in self.files]
    return json

DragDataItem dataclass

Source code in zendriver/cdp/input_.py 
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
@dataclass
class DragDataItem:
    #: Mime type of the dragged data.
    mime_type: str

    #: Depending of the value of ``mimeType``, it contains the dragged link,
    #: text, HTML markup or any other data.
    data: str

    #: Title associated with a link. Only valid when ``mimeType`` == "text/uri-list".
    title: typing.Optional[str] = None

    #: Stores the base URL for the contained markup. Only valid when ``mimeType``
    #: == "text/html".
    base_url: typing.Optional[str] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["mimeType"] = self.mime_type
        json["data"] = self.data
        if self.title is not None:
            json["title"] = self.title
        if self.base_url is not None:
            json["baseURL"] = self.base_url
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DragDataItem:
        return cls(
            mime_type=str(json["mimeType"]),
            data=str(json["data"]),
            title=str(json["title"]) if json.get("title", None) is not None else None,
            base_url=(
                str(json["baseURL"]) if json.get("baseURL", None) is not None else None
            ),
        )

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

data: str instance-attribute

mime_type: str instance-attribute

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

__init__(mime_type, data, title=None, base_url=None)

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
183
184
185
186
187
188
189
190
191
192
@classmethod
def from_json(cls, json: T_JSON_DICT) -> DragDataItem:
    return cls(
        mime_type=str(json["mimeType"]),
        data=str(json["data"]),
        title=str(json["title"]) if json.get("title", None) is not None else None,
        base_url=(
            str(json["baseURL"]) if json.get("baseURL", None) is not None else None
        ),
    )

to_json()

Source code in zendriver/cdp/input_.py 
173
174
175
176
177
178
179
180
181
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["mimeType"] = self.mime_type
    json["data"] = self.data
    if self.title is not None:
        json["title"] = self.title
    if self.base_url is not None:
        json["baseURL"] = self.base_url
    return json

DragIntercepted dataclass

EXPERIMENTAL

Emitted only when Input.setInterceptDrags is enabled. Use this data with Input.dispatchDragEvent to restore normal drag and drop behavior.

Source code in zendriver/cdp/input_.py 
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
@event_class("Input.dragIntercepted")
@dataclass
class DragIntercepted:
    """
    **EXPERIMENTAL**

    Emitted only when ``Input.setInterceptDrags`` is enabled. Use this data with ``Input.dispatchDragEvent`` to
    restore normal drag and drop behavior.
    """

    data: DragData

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DragIntercepted:
        return cls(data=DragData.from_json(json["data"]))

data: DragData instance-attribute

__init__(data)

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
723
724
725
@classmethod
def from_json(cls, json: T_JSON_DICT) -> DragIntercepted:
    return cls(data=DragData.from_json(json["data"]))

GestureSourceType

Bases: Enum

Source code in zendriver/cdp/input_.py 
112
113
114
115
116
117
118
119
120
121
122
class GestureSourceType(enum.Enum):
    DEFAULT = "default"
    TOUCH = "touch"
    MOUSE = "mouse"

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

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

DEFAULT = 'default' class-attribute instance-attribute

MOUSE = 'mouse' class-attribute instance-attribute

TOUCH = 'touch' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
120
121
122
@classmethod
def from_json(cls, json: str) -> GestureSourceType:
    return cls(json)

to_json()

Source code in zendriver/cdp/input_.py 
117
118
def to_json(self) -> str:
    return self.value

MouseButton

Bases: Enum

Source code in zendriver/cdp/input_.py 
125
126
127
128
129
130
131
132
133
134
135
136
137
138
class MouseButton(enum.Enum):
    NONE = "none"
    LEFT = "left"
    MIDDLE = "middle"
    RIGHT = "right"
    BACK = "back"
    FORWARD = "forward"

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

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

BACK = 'back' class-attribute instance-attribute

FORWARD = 'forward' class-attribute instance-attribute

LEFT = 'left' class-attribute instance-attribute

MIDDLE = 'middle' class-attribute instance-attribute

NONE = 'none' class-attribute instance-attribute

RIGHT = 'right' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
136
137
138
@classmethod
def from_json(cls, json: str) -> MouseButton:
    return cls(json)

to_json()

Source code in zendriver/cdp/input_.py 
133
134
def to_json(self) -> str:
    return self.value

TimeSinceEpoch

Bases: float

UTC time in seconds, counted from January 1, 1970.

Source code in zendriver/cdp/input_.py 
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class TimeSinceEpoch(float):
    """
    UTC time in seconds, counted from January 1, 1970.
    """

    def to_json(self) -> float:
        return self

    @classmethod
    def from_json(cls, json: float) -> TimeSinceEpoch:
        return cls(json)

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

__repr__()

Source code in zendriver/cdp/input_.py 
153
154
def __repr__(self):
    return "TimeSinceEpoch({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
149
150
151
@classmethod
def from_json(cls, json: float) -> TimeSinceEpoch:
    return cls(json)

to_json()

Source code in zendriver/cdp/input_.py 
146
147
def to_json(self) -> float:
    return self

TouchPoint dataclass

Source code in zendriver/cdp/input_.py 
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
@dataclass
class TouchPoint:
    #: X coordinate of the event relative to the main frame's viewport in CSS pixels.
    x: float

    #: Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to
    #: the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
    y: float

    #: X radius of the touch area (default: 1.0).
    radius_x: typing.Optional[float] = None

    #: Y radius of the touch area (default: 1.0).
    radius_y: typing.Optional[float] = None

    #: Rotation angle (default: 0.0).
    rotation_angle: typing.Optional[float] = None

    #: Force (default: 1.0).
    force: typing.Optional[float] = None

    #: The normalized tangential pressure, which has a range of [-1,1] (default: 0).
    tangential_pressure: typing.Optional[float] = None

    #: The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)
    tilt_x: typing.Optional[float] = None

    #: The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).
    tilt_y: typing.Optional[float] = None

    #: The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
    twist: typing.Optional[int] = None

    #: Identifier used to track touch sources between events, must be unique within an event.
    id_: typing.Optional[float] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["x"] = self.x
        json["y"] = self.y
        if self.radius_x is not None:
            json["radiusX"] = self.radius_x
        if self.radius_y is not None:
            json["radiusY"] = self.radius_y
        if self.rotation_angle is not None:
            json["rotationAngle"] = self.rotation_angle
        if self.force is not None:
            json["force"] = self.force
        if self.tangential_pressure is not None:
            json["tangentialPressure"] = self.tangential_pressure
        if self.tilt_x is not None:
            json["tiltX"] = self.tilt_x
        if self.tilt_y is not None:
            json["tiltY"] = self.tilt_y
        if self.twist is not None:
            json["twist"] = self.twist
        if self.id_ is not None:
            json["id"] = self.id_
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> TouchPoint:
        return cls(
            x=float(json["x"]),
            y=float(json["y"]),
            radius_x=(
                float(json["radiusX"])
                if json.get("radiusX", None) is not None
                else None
            ),
            radius_y=(
                float(json["radiusY"])
                if json.get("radiusY", None) is not None
                else None
            ),
            rotation_angle=(
                float(json["rotationAngle"])
                if json.get("rotationAngle", None) is not None
                else None
            ),
            force=float(json["force"]) if json.get("force", None) is not None else None,
            tangential_pressure=(
                float(json["tangentialPressure"])
                if json.get("tangentialPressure", None) is not None
                else None
            ),
            tilt_x=(
                float(json["tiltX"]) if json.get("tiltX", None) is not None else None
            ),
            tilt_y=(
                float(json["tiltY"]) if json.get("tiltY", None) is not None else None
            ),
            twist=int(json["twist"]) if json.get("twist", None) is not None else None,
            id_=float(json["id"]) if json.get("id", None) is not None else None,
        )

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

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

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

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

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

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

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

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

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

x: float instance-attribute

y: float instance-attribute

__init__(x, y, radius_x=None, radius_y=None, rotation_angle=None, force=None, tangential_pressure=None, tilt_x=None, tilt_y=None, twist=None, id_=None)

from_json(json) classmethod

Source code in zendriver/cdp/input_.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
@classmethod
def from_json(cls, json: T_JSON_DICT) -> TouchPoint:
    return cls(
        x=float(json["x"]),
        y=float(json["y"]),
        radius_x=(
            float(json["radiusX"])
            if json.get("radiusX", None) is not None
            else None
        ),
        radius_y=(
            float(json["radiusY"])
            if json.get("radiusY", None) is not None
            else None
        ),
        rotation_angle=(
            float(json["rotationAngle"])
            if json.get("rotationAngle", None) is not None
            else None
        ),
        force=float(json["force"]) if json.get("force", None) is not None else None,
        tangential_pressure=(
            float(json["tangentialPressure"])
            if json.get("tangentialPressure", None) is not None
            else None
        ),
        tilt_x=(
            float(json["tiltX"]) if json.get("tiltX", None) is not None else None
        ),
        tilt_y=(
            float(json["tiltY"]) if json.get("tiltY", None) is not None else None
        ),
        twist=int(json["twist"]) if json.get("twist", None) is not None else None,
        id_=float(json["id"]) if json.get("id", None) is not None else None,
    )

to_json()

Source code in zendriver/cdp/input_.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["x"] = self.x
    json["y"] = self.y
    if self.radius_x is not None:
        json["radiusX"] = self.radius_x
    if self.radius_y is not None:
        json["radiusY"] = self.radius_y
    if self.rotation_angle is not None:
        json["rotationAngle"] = self.rotation_angle
    if self.force is not None:
        json["force"] = self.force
    if self.tangential_pressure is not None:
        json["tangentialPressure"] = self.tangential_pressure
    if self.tilt_x is not None:
        json["tiltX"] = self.tilt_x
    if self.tilt_y is not None:
        json["tiltY"] = self.tilt_y
    if self.twist is not None:
        json["twist"] = self.twist
    if self.id_ is not None:
        json["id"] = self.id_
    return json

cancel_dragging()

Cancels any active dragging in the page.

Source code in zendriver/cdp/input_.py 
487
488
489
490
491
492
493
494
def cancel_dragging() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Cancels any active dragging in the page.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Input.cancelDragging",
    }
    json = yield cmd_dict

dispatch_drag_event(type_, x, y, data, modifiers=None)

Dispatches a drag event into the page.

EXPERIMENTAL

Parameters:

Name Type Description Default
type_ str

Type of the drag event.

 required
x float

X coordinate of the event relative to the main frame's viewport in CSS pixels.

 required
y float

Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.

 required
data DragData
required
modifiers Optional[int]

(Optional) Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

 None
Source code in zendriver/cdp/input_.py 
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
def dispatch_drag_event(
    type_: str,
    x: float,
    y: float,
    data: DragData,
    modifiers: typing.Optional[int] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Dispatches a drag event into the page.

    **EXPERIMENTAL**

    :param type_: Type of the drag event.
    :param x: X coordinate of the event relative to the main frame's viewport in CSS pixels.
    :param y: Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
    :param data:
    :param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
    """
    params: T_JSON_DICT = dict()
    params["type"] = type_
    params["x"] = x
    params["y"] = y
    params["data"] = data.to_json()
    if modifiers is not None:
        params["modifiers"] = modifiers
    cmd_dict: T_JSON_DICT = {
        "method": "Input.dispatchDragEvent",
        "params": params,
    }
    json = yield cmd_dict

dispatch_key_event(type_, modifiers=None, timestamp=None, text=None, unmodified_text=None, key_identifier=None, code=None, key=None, windows_virtual_key_code=None, native_virtual_key_code=None, auto_repeat=None, is_keypad=None, is_system_key=None, location=None, commands=None)

Dispatches a key event to the page.

Parameters:

Name Type Description Default
type_ str

Type of the key event.

 required
modifiers Optional[int]

(Optional) Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

 None
timestamp Optional[TimeSinceEpoch]

(Optional) Time at which the event occurred.

 None
text Optional[str]

(Optional) Text as generated by processing a virtual key code with a keyboard layout. Not needed for for ```keyUpandrawKeyDown```` events (default: "")

 None
unmodified_text Optional[str]

(Optional) Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling (default: "").

 None
key_identifier Optional[str]

(Optional) Unique key identifier (e.g., 'U+0041') (default: "").

 None
code Optional[str]

(Optional) Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").

 None
key Optional[str]

(Optional) Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").

 None
windows_virtual_key_code Optional[int]

(Optional) Windows virtual key code (default: 0).

 None
native_virtual_key_code Optional[int]

(Optional) Native virtual key code (default: 0).

 None
auto_repeat Optional[bool]

(Optional) Whether the event was generated from auto repeat (default: false).

 None
is_keypad Optional[bool]

(Optional) Whether the event was generated from the keypad (default: false).

 None
is_system_key Optional[bool]

(Optional) Whether the event was a system key event (default: false).

 None
location Optional[int]

(Optional) Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default: 0).

 None
commands Optional[List[str]]

(EXPERIMENTAL) (Optional) Editing commands to send with the key event (e.g., 'selectAll') (default: []). These are related to but not equal the command names used in `document.execCommand and NSStandardKeyBindingResponding. See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/editing/commands/editor_command_names.h for valid command names.

 None
Source code in zendriver/cdp/input_.py 
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
def dispatch_key_event(
    type_: str,
    modifiers: typing.Optional[int] = None,
    timestamp: typing.Optional[TimeSinceEpoch] = None,
    text: typing.Optional[str] = None,
    unmodified_text: typing.Optional[str] = None,
    key_identifier: typing.Optional[str] = None,
    code: typing.Optional[str] = None,
    key: typing.Optional[str] = None,
    windows_virtual_key_code: typing.Optional[int] = None,
    native_virtual_key_code: typing.Optional[int] = None,
    auto_repeat: typing.Optional[bool] = None,
    is_keypad: typing.Optional[bool] = None,
    is_system_key: typing.Optional[bool] = None,
    location: typing.Optional[int] = None,
    commands: typing.Optional[typing.List[str]] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Dispatches a key event to the page.

    :param type_: Type of the key event.
    :param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
    :param timestamp: *(Optional)* Time at which the event occurred.
    :param text: *(Optional)* Text as generated by processing a virtual key code with a keyboard layout. Not needed for for ```keyUp```` and ````rawKeyDown```` events (default: "")
    :param unmodified_text: *(Optional)* Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling (default: "").
    :param key_identifier: *(Optional)* Unique key identifier (e.g., 'U+0041') (default: "").
    :param code: *(Optional)* Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").
    :param key: *(Optional)* Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").
    :param windows_virtual_key_code: *(Optional)* Windows virtual key code (default: 0).
    :param native_virtual_key_code: *(Optional)* Native virtual key code (default: 0).
    :param auto_repeat: *(Optional)* Whether the event was generated from auto repeat (default: false).
    :param is_keypad: *(Optional)* Whether the event was generated from the keypad (default: false).
    :param is_system_key: *(Optional)* Whether the event was a system key event (default: false).
    :param location: *(Optional)* Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default: 0).
    :param commands: **(EXPERIMENTAL)** *(Optional)* Editing commands to send with the key event (e.g., 'selectAll') (default: []). These are related to but not equal the command names used in ````document.execCommand``` and NSStandardKeyBindingResponding. See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/editing/commands/editor_command_names.h for valid command names.
    """
    params: T_JSON_DICT = dict()
    params["type"] = type_
    if modifiers is not None:
        params["modifiers"] = modifiers
    if timestamp is not None:
        params["timestamp"] = timestamp.to_json()
    if text is not None:
        params["text"] = text
    if unmodified_text is not None:
        params["unmodifiedText"] = unmodified_text
    if key_identifier is not None:
        params["keyIdentifier"] = key_identifier
    if code is not None:
        params["code"] = code
    if key is not None:
        params["key"] = key
    if windows_virtual_key_code is not None:
        params["windowsVirtualKeyCode"] = windows_virtual_key_code
    if native_virtual_key_code is not None:
        params["nativeVirtualKeyCode"] = native_virtual_key_code
    if auto_repeat is not None:
        params["autoRepeat"] = auto_repeat
    if is_keypad is not None:
        params["isKeypad"] = is_keypad
    if is_system_key is not None:
        params["isSystemKey"] = is_system_key
    if location is not None:
        params["location"] = location
    if commands is not None:
        params["commands"] = [i for i in commands]
    cmd_dict: T_JSON_DICT = {
        "method": "Input.dispatchKeyEvent",
        "params": params,
    }
    json = yield cmd_dict

dispatch_mouse_event(type_, x, y, modifiers=None, timestamp=None, button=None, buttons=None, click_count=None, force=None, tangential_pressure=None, tilt_x=None, tilt_y=None, twist=None, delta_x=None, delta_y=None, pointer_type=None)

Dispatches a mouse event to the page.

Parameters:

Name Type Description Default
type_ str

Type of the mouse event.

 required
x float

X coordinate of the event relative to the main frame's viewport in CSS pixels.

 required
y float

Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.

 required
modifiers Optional[int]

(Optional) Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

 None
timestamp Optional[TimeSinceEpoch]

(Optional) Time at which the event occurred.

 None
button Optional[MouseButton]

(Optional) Mouse button (default: "none").

 None
buttons Optional[int]

(Optional) A number indicating which buttons are pressed on the mouse when a mouse event is triggered. Left=1, Right=2, Middle=4, Back=8, Forward=16, None=0.

 None
click_count Optional[int]

(Optional) Number of times the mouse button was clicked (default: 0).

 None
force Optional[float]

(EXPERIMENTAL) (Optional) The normalized pressure, which has a range of [0,1] (default: 0).

 None
tangential_pressure Optional[float]

(EXPERIMENTAL) (Optional) The normalized tangential pressure, which has a range of [-1,1] (default: 0).

 None
tilt_x Optional[float]

(Optional) The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0).

 None
tilt_y Optional[float]

(Optional) The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).

 None
twist Optional[int]

(EXPERIMENTAL) (Optional) The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).

 None
delta_x Optional[float]

(Optional) X delta in CSS pixels for mouse wheel event (default: 0).

 None
delta_y Optional[float]

(Optional) Y delta in CSS pixels for mouse wheel event (default: 0).

 None
pointer_type Optional[str]

(Optional) Pointer type (default: "mouse").

 None
Source code in zendriver/cdp/input_.py 
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
def dispatch_mouse_event(
    type_: str,
    x: float,
    y: float,
    modifiers: typing.Optional[int] = None,
    timestamp: typing.Optional[TimeSinceEpoch] = None,
    button: typing.Optional[MouseButton] = None,
    buttons: typing.Optional[int] = None,
    click_count: typing.Optional[int] = None,
    force: typing.Optional[float] = None,
    tangential_pressure: typing.Optional[float] = None,
    tilt_x: typing.Optional[float] = None,
    tilt_y: typing.Optional[float] = None,
    twist: typing.Optional[int] = None,
    delta_x: typing.Optional[float] = None,
    delta_y: typing.Optional[float] = None,
    pointer_type: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Dispatches a mouse event to the page.

    :param type_: Type of the mouse event.
    :param x: X coordinate of the event relative to the main frame's viewport in CSS pixels.
    :param y: Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
    :param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
    :param timestamp: *(Optional)* Time at which the event occurred.
    :param button: *(Optional)* Mouse button (default: "none").
    :param buttons: *(Optional)* A number indicating which buttons are pressed on the mouse when a mouse event is triggered. Left=1, Right=2, Middle=4, Back=8, Forward=16, None=0.
    :param click_count: *(Optional)* Number of times the mouse button was clicked (default: 0).
    :param force: **(EXPERIMENTAL)** *(Optional)* The normalized pressure, which has a range of [0,1] (default: 0).
    :param tangential_pressure: **(EXPERIMENTAL)** *(Optional)* The normalized tangential pressure, which has a range of [-1,1] (default: 0).
    :param tilt_x: *(Optional)* The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0).
    :param tilt_y: *(Optional)* The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0).
    :param twist: **(EXPERIMENTAL)** *(Optional)* The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
    :param delta_x: *(Optional)* X delta in CSS pixels for mouse wheel event (default: 0).
    :param delta_y: *(Optional)* Y delta in CSS pixels for mouse wheel event (default: 0).
    :param pointer_type: *(Optional)* Pointer type (default: "mouse").
    """
    params: T_JSON_DICT = dict()
    params["type"] = type_
    params["x"] = x
    params["y"] = y
    if modifiers is not None:
        params["modifiers"] = modifiers
    if timestamp is not None:
        params["timestamp"] = timestamp.to_json()
    if button is not None:
        params["button"] = button.to_json()
    if buttons is not None:
        params["buttons"] = buttons
    if click_count is not None:
        params["clickCount"] = click_count
    if force is not None:
        params["force"] = force
    if tangential_pressure is not None:
        params["tangentialPressure"] = tangential_pressure
    if tilt_x is not None:
        params["tiltX"] = tilt_x
    if tilt_y is not None:
        params["tiltY"] = tilt_y
    if twist is not None:
        params["twist"] = twist
    if delta_x is not None:
        params["deltaX"] = delta_x
    if delta_y is not None:
        params["deltaY"] = delta_y
    if pointer_type is not None:
        params["pointerType"] = pointer_type
    cmd_dict: T_JSON_DICT = {
        "method": "Input.dispatchMouseEvent",
        "params": params,
    }
    json = yield cmd_dict

dispatch_touch_event(type_, touch_points, modifiers=None, timestamp=None)

Dispatches a touch event to the page.

Parameters:

Name Type Description Default
type_ str

Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while TouchStart and TouchMove must contains at least one.

 required
touch_points List[TouchPoint]

Active touch points on the touch device. One event per any changed point (compared to previous touch event in a sequence) is generated, emulating pressing/moving/releasing points one by one.

 required
modifiers Optional[int]

(Optional) Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

 None
timestamp Optional[TimeSinceEpoch]

(Optional) Time at which the event occurred.

 None
Source code in zendriver/cdp/input_.py 
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
def dispatch_touch_event(
    type_: str,
    touch_points: typing.List[TouchPoint],
    modifiers: typing.Optional[int] = None,
    timestamp: typing.Optional[TimeSinceEpoch] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Dispatches a touch event to the page.

    :param type_: Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while TouchStart and TouchMove must contains at least one.
    :param touch_points: Active touch points on the touch device. One event per any changed point (compared to previous touch event in a sequence) is generated, emulating pressing/moving/releasing points one by one.
    :param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
    :param timestamp: *(Optional)* Time at which the event occurred.
    """
    params: T_JSON_DICT = dict()
    params["type"] = type_
    params["touchPoints"] = [i.to_json() for i in touch_points]
    if modifiers is not None:
        params["modifiers"] = modifiers
    if timestamp is not None:
        params["timestamp"] = timestamp.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Input.dispatchTouchEvent",
        "params": params,
    }
    json = yield cmd_dict

emulate_touch_from_mouse_event(type_, x, y, button, timestamp=None, delta_x=None, delta_y=None, modifiers=None, click_count=None)

Emulates touch event from the mouse event parameters.

EXPERIMENTAL

Parameters:

Name Type Description Default
type_ str

Type of the mouse event.

 required
x int

X coordinate of the mouse pointer in DIP.

 required
y int

Y coordinate of the mouse pointer in DIP.

 required
button MouseButton

Mouse button. Only "none", "left", "right" are supported.

 required
timestamp Optional[TimeSinceEpoch]

(Optional) Time at which the event occurred (default: current time).

 None
delta_x Optional[float]

(Optional) X delta in DIP for mouse wheel event (default: 0).

 None
delta_y Optional[float]

(Optional) Y delta in DIP for mouse wheel event (default: 0).

 None
modifiers Optional[int]

(Optional) Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

 None
click_count Optional[int]

(Optional) Number of times the mouse button was clicked (default: 0).

 None
Source code in zendriver/cdp/input_.py 
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
def emulate_touch_from_mouse_event(
    type_: str,
    x: int,
    y: int,
    button: MouseButton,
    timestamp: typing.Optional[TimeSinceEpoch] = None,
    delta_x: typing.Optional[float] = None,
    delta_y: typing.Optional[float] = None,
    modifiers: typing.Optional[int] = None,
    click_count: typing.Optional[int] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Emulates touch event from the mouse event parameters.

    **EXPERIMENTAL**

    :param type_: Type of the mouse event.
    :param x: X coordinate of the mouse pointer in DIP.
    :param y: Y coordinate of the mouse pointer in DIP.
    :param button: Mouse button. Only "none", "left", "right" are supported.
    :param timestamp: *(Optional)* Time at which the event occurred (default: current time).
    :param delta_x: *(Optional)* X delta in DIP for mouse wheel event (default: 0).
    :param delta_y: *(Optional)* Y delta in DIP for mouse wheel event (default: 0).
    :param modifiers: *(Optional)* Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
    :param click_count: *(Optional)* Number of times the mouse button was clicked (default: 0).
    """
    params: T_JSON_DICT = dict()
    params["type"] = type_
    params["x"] = x
    params["y"] = y
    params["button"] = button.to_json()
    if timestamp is not None:
        params["timestamp"] = timestamp.to_json()
    if delta_x is not None:
        params["deltaX"] = delta_x
    if delta_y is not None:
        params["deltaY"] = delta_y
    if modifiers is not None:
        params["modifiers"] = modifiers
    if click_count is not None:
        params["clickCount"] = click_count
    cmd_dict: T_JSON_DICT = {
        "method": "Input.emulateTouchFromMouseEvent",
        "params": params,
    }
    json = yield cmd_dict

ime_set_composition(text, selection_start, selection_end, replacement_start=None, replacement_end=None)

This method sets the current candidate text for IME. Use imeCommitComposition to commit the final text. Use imeSetComposition with empty string as text to cancel composition.

EXPERIMENTAL

Parameters:

Name Type Description Default
text str

The text to insert

 required
selection_start int

selection start

 required
selection_end int

selection end

 required
replacement_start Optional[int]

(Optional) replacement start

 None
replacement_end Optional[int]

(Optional) replacement end

 None
Source code in zendriver/cdp/input_.py 
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
def ime_set_composition(
    text: str,
    selection_start: int,
    selection_end: int,
    replacement_start: typing.Optional[int] = None,
    replacement_end: typing.Optional[int] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    This method sets the current candidate text for IME.
    Use imeCommitComposition to commit the final text.
    Use imeSetComposition with empty string as text to cancel composition.

    **EXPERIMENTAL**

    :param text: The text to insert
    :param selection_start: selection start
    :param selection_end: selection end
    :param replacement_start: *(Optional)* replacement start
    :param replacement_end: *(Optional)* replacement end
    """
    params: T_JSON_DICT = dict()
    params["text"] = text
    params["selectionStart"] = selection_start
    params["selectionEnd"] = selection_end
    if replacement_start is not None:
        params["replacementStart"] = replacement_start
    if replacement_end is not None:
        params["replacementEnd"] = replacement_end
    cmd_dict: T_JSON_DICT = {
        "method": "Input.imeSetComposition",
        "params": params,
    }
    json = yield cmd_dict

insert_text(text)

This method emulates inserting text that doesn't come from a key press, for example an emoji keyboard or an IME.

EXPERIMENTAL

Parameters:

Name Type Description Default
text str

The text to insert.

 required
Source code in zendriver/cdp/input_.py 
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
def insert_text(text: str) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    This method emulates inserting text that doesn't come from a key press,
    for example an emoji keyboard or an IME.

    **EXPERIMENTAL**

    :param text: The text to insert.
    """
    params: T_JSON_DICT = dict()
    params["text"] = text
    cmd_dict: T_JSON_DICT = {
        "method": "Input.insertText",
        "params": params,
    }
    json = yield cmd_dict

set_ignore_input_events(ignore)

Ignores input events (useful while auditing page).

Parameters:

Name Type Description Default
ignore bool

Ignores input events processing when set to true.

 required
Source code in zendriver/cdp/input_.py 
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
def set_ignore_input_events(
    ignore: bool,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Ignores input events (useful while auditing page).

    :param ignore: Ignores input events processing when set to true.
    """
    params: T_JSON_DICT = dict()
    params["ignore"] = ignore
    cmd_dict: T_JSON_DICT = {
        "method": "Input.setIgnoreInputEvents",
        "params": params,
    }
    json = yield cmd_dict

set_intercept_drags(enabled)

Prevents default drag and drop behavior and instead emits Input.dragIntercepted events. Drag and drop behavior can be directly controlled via Input.dispatchDragEvent.

EXPERIMENTAL

Parameters:

Name Type Description Default
enabled bool
required
Source code in zendriver/cdp/input_.py 
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
def set_intercept_drags(
    enabled: bool,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Prevents default drag and drop behavior and instead emits ``Input.dragIntercepted`` events.
    Drag and drop behavior can be directly controlled via ``Input.dispatchDragEvent``.

    **EXPERIMENTAL**

    :param enabled:
    """
    params: T_JSON_DICT = dict()
    params["enabled"] = enabled
    cmd_dict: T_JSON_DICT = {
        "method": "Input.setInterceptDrags",
        "params": params,
    }
    json = yield cmd_dict

synthesize_pinch_gesture(x, y, scale_factor, relative_speed=None, gesture_source_type=None)

Synthesizes a pinch gesture over a time period by issuing appropriate touch events.

EXPERIMENTAL

Parameters:

Name Type Description Default
x float

X coordinate of the start of the gesture in CSS pixels.

 required
y float

Y coordinate of the start of the gesture in CSS pixels.

 required
scale_factor float

Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).

 required
relative_speed Optional[int]

(Optional) Relative pointer speed in pixels per second (default: 800).

 None
gesture_source_type Optional[GestureSourceType]

(Optional) Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).

 None
Source code in zendriver/cdp/input_.py 
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
def synthesize_pinch_gesture(
    x: float,
    y: float,
    scale_factor: float,
    relative_speed: typing.Optional[int] = None,
    gesture_source_type: typing.Optional[GestureSourceType] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Synthesizes a pinch gesture over a time period by issuing appropriate touch events.

    **EXPERIMENTAL**

    :param x: X coordinate of the start of the gesture in CSS pixels.
    :param y: Y coordinate of the start of the gesture in CSS pixels.
    :param scale_factor: Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).
    :param relative_speed: *(Optional)* Relative pointer speed in pixels per second (default: 800).
    :param gesture_source_type: *(Optional)* Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
    """
    params: T_JSON_DICT = dict()
    params["x"] = x
    params["y"] = y
    params["scaleFactor"] = scale_factor
    if relative_speed is not None:
        params["relativeSpeed"] = relative_speed
    if gesture_source_type is not None:
        params["gestureSourceType"] = gesture_source_type.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Input.synthesizePinchGesture",
        "params": params,
    }
    json = yield cmd_dict

synthesize_scroll_gesture(x, y, x_distance=None, y_distance=None, x_overscroll=None, y_overscroll=None, prevent_fling=None, speed=None, gesture_source_type=None, repeat_count=None, repeat_delay_ms=None, interaction_marker_name=None)

Synthesizes a scroll gesture over a time period by issuing appropriate touch events.

EXPERIMENTAL

Parameters:

Name Type Description Default
x float

X coordinate of the start of the gesture in CSS pixels.

 required
y float

Y coordinate of the start of the gesture in CSS pixels.

 required
x_distance Optional[float]

(Optional) The distance to scroll along the X axis (positive to scroll left).

 None
y_distance Optional[float]

(Optional) The distance to scroll along the Y axis (positive to scroll up).

 None
x_overscroll Optional[float]

(Optional) The number of additional pixels to scroll back along the X axis, in addition to the given distance.

 None
y_overscroll Optional[float]

(Optional) The number of additional pixels to scroll back along the Y axis, in addition to the given distance.

 None
prevent_fling Optional[bool]

(Optional) Prevent fling (default: true).

 None
speed Optional[int]

(Optional) Swipe speed in pixels per second (default: 800).

 None
gesture_source_type Optional[GestureSourceType]

(Optional) Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).

 None
repeat_count Optional[int]

(Optional) The number of times to repeat the gesture (default: 0).

 None
repeat_delay_ms Optional[int]

(Optional) The number of milliseconds delay between each repeat. (default: 250).

 None
interaction_marker_name Optional[str]

(Optional) The name of the interaction markers to generate, if not empty (default: "").

 None
Source code in zendriver/cdp/input_.py 
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
def synthesize_scroll_gesture(
    x: float,
    y: float,
    x_distance: typing.Optional[float] = None,
    y_distance: typing.Optional[float] = None,
    x_overscroll: typing.Optional[float] = None,
    y_overscroll: typing.Optional[float] = None,
    prevent_fling: typing.Optional[bool] = None,
    speed: typing.Optional[int] = None,
    gesture_source_type: typing.Optional[GestureSourceType] = None,
    repeat_count: typing.Optional[int] = None,
    repeat_delay_ms: typing.Optional[int] = None,
    interaction_marker_name: typing.Optional[str] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Synthesizes a scroll gesture over a time period by issuing appropriate touch events.

    **EXPERIMENTAL**

    :param x: X coordinate of the start of the gesture in CSS pixels.
    :param y: Y coordinate of the start of the gesture in CSS pixels.
    :param x_distance: *(Optional)* The distance to scroll along the X axis (positive to scroll left).
    :param y_distance: *(Optional)* The distance to scroll along the Y axis (positive to scroll up).
    :param x_overscroll: *(Optional)* The number of additional pixels to scroll back along the X axis, in addition to the given distance.
    :param y_overscroll: *(Optional)* The number of additional pixels to scroll back along the Y axis, in addition to the given distance.
    :param prevent_fling: *(Optional)* Prevent fling (default: true).
    :param speed: *(Optional)* Swipe speed in pixels per second (default: 800).
    :param gesture_source_type: *(Optional)* Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
    :param repeat_count: *(Optional)* The number of times to repeat the gesture (default: 0).
    :param repeat_delay_ms: *(Optional)* The number of milliseconds delay between each repeat. (default: 250).
    :param interaction_marker_name: *(Optional)* The name of the interaction markers to generate, if not empty (default: "").
    """
    params: T_JSON_DICT = dict()
    params["x"] = x
    params["y"] = y
    if x_distance is not None:
        params["xDistance"] = x_distance
    if y_distance is not None:
        params["yDistance"] = y_distance
    if x_overscroll is not None:
        params["xOverscroll"] = x_overscroll
    if y_overscroll is not None:
        params["yOverscroll"] = y_overscroll
    if prevent_fling is not None:
        params["preventFling"] = prevent_fling
    if speed is not None:
        params["speed"] = speed
    if gesture_source_type is not None:
        params["gestureSourceType"] = gesture_source_type.to_json()
    if repeat_count is not None:
        params["repeatCount"] = repeat_count
    if repeat_delay_ms is not None:
        params["repeatDelayMs"] = repeat_delay_ms
    if interaction_marker_name is not None:
        params["interactionMarkerName"] = interaction_marker_name
    cmd_dict: T_JSON_DICT = {
        "method": "Input.synthesizeScrollGesture",
        "params": params,
    }
    json = yield cmd_dict

synthesize_tap_gesture(x, y, duration=None, tap_count=None, gesture_source_type=None)

Synthesizes a tap gesture over a time period by issuing appropriate touch events.

EXPERIMENTAL

Parameters:

Name Type Description Default
x float

X coordinate of the start of the gesture in CSS pixels.

 required
y float

Y coordinate of the start of the gesture in CSS pixels.

 required
duration Optional[int]

(Optional) Duration between touchdown and touchup events in ms (default: 50).

 None
tap_count Optional[int]

(Optional) Number of times to perform the tap (e.g. 2 for double tap, default: 1).

 None
gesture_source_type Optional[GestureSourceType]

(Optional) Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).

 None
Source code in zendriver/cdp/input_.py 
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
def synthesize_tap_gesture(
    x: float,
    y: float,
    duration: typing.Optional[int] = None,
    tap_count: typing.Optional[int] = None,
    gesture_source_type: typing.Optional[GestureSourceType] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Synthesizes a tap gesture over a time period by issuing appropriate touch events.

    **EXPERIMENTAL**

    :param x: X coordinate of the start of the gesture in CSS pixels.
    :param y: Y coordinate of the start of the gesture in CSS pixels.
    :param duration: *(Optional)* Duration between touchdown and touchup events in ms (default: 50).
    :param tap_count: *(Optional)* Number of times to perform the tap (e.g. 2 for double tap, default: 1).
    :param gesture_source_type: *(Optional)* Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
    """
    params: T_JSON_DICT = dict()
    params["x"] = x
    params["y"] = y
    if duration is not None:
        params["duration"] = duration
    if tap_count is not None:
        params["tapCount"] = tap_count
    if gesture_source_type is not None:
        params["gestureSourceType"] = gesture_source_type.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Input.synthesizeTapGesture",
        "params": params,
    }
    json = yield cmd_dict