Skip to content

debugger

BreakLocation dataclass

Source code in zendriver/cdp/debugger.py 
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
329
330
331
332
@dataclass
class BreakLocation:
    #: Script identifier as reported in the ``Debugger.scriptParsed``.
    script_id: runtime.ScriptId

    #: Line number in the script (0-based).
    line_number: int

    #: Column number in the script (0-based).
    column_number: typing.Optional[int] = None

    type_: typing.Optional[str] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["scriptId"] = self.script_id.to_json()
        json["lineNumber"] = self.line_number
        if self.column_number is not None:
            json["columnNumber"] = self.column_number
        if self.type_ is not None:
            json["type"] = self.type_
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> BreakLocation:
        return cls(
            script_id=runtime.ScriptId.from_json(json["scriptId"]),
            line_number=int(json["lineNumber"]),
            column_number=(
                int(json["columnNumber"])
                if json.get("columnNumber", None) is not None
                else None
            ),
            type_=str(json["type"]) if json.get("type", None) is not None else None,
        )

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

line_number: int instance-attribute

script_id: runtime.ScriptId instance-attribute

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

__init__(script_id, line_number, column_number=None, type_=None)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
321
322
323
324
325
326
327
328
329
330
331
332
@classmethod
def from_json(cls, json: T_JSON_DICT) -> BreakLocation:
    return cls(
        script_id=runtime.ScriptId.from_json(json["scriptId"]),
        line_number=int(json["lineNumber"]),
        column_number=(
            int(json["columnNumber"])
            if json.get("columnNumber", None) is not None
            else None
        ),
        type_=str(json["type"]) if json.get("type", None) is not None else None,
    )

to_json()

Source code in zendriver/cdp/debugger.py 
311
312
313
314
315
316
317
318
319
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["scriptId"] = self.script_id.to_json()
    json["lineNumber"] = self.line_number
    if self.column_number is not None:
        json["columnNumber"] = self.column_number
    if self.type_ is not None:
        json["type"] = self.type_
    return json

BreakpointId

Bases: str

Breakpoint identifier.

Source code in zendriver/cdp/debugger.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class BreakpointId(str):
    """
    Breakpoint identifier.
    """

    def to_json(self) -> str:
        return self

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

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

__repr__()

Source code in zendriver/cdp/debugger.py 
30
31
def __repr__(self):
    return "BreakpointId({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
26
27
28
@classmethod
def from_json(cls, json: str) -> BreakpointId:
    return cls(json)

to_json()

Source code in zendriver/cdp/debugger.py 
23
24
def to_json(self) -> str:
    return self

BreakpointResolved dataclass

Fired when breakpoint is resolved to an actual script and location.

Source code in zendriver/cdp/debugger.py 
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
@event_class("Debugger.breakpointResolved")
@dataclass
class BreakpointResolved:
    """
    Fired when breakpoint is resolved to an actual script and location.
    """

    #: Breakpoint unique identifier.
    breakpoint_id: BreakpointId
    #: Actual breakpoint location.
    location: Location

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> BreakpointResolved:
        return cls(
            breakpoint_id=BreakpointId.from_json(json["breakpointId"]),
            location=Location.from_json(json["location"]),
        )

breakpoint_id: BreakpointId instance-attribute

location: Location instance-attribute

__init__(breakpoint_id, location)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
1255
1256
1257
1258
1259
1260
@classmethod
def from_json(cls, json: T_JSON_DICT) -> BreakpointResolved:
    return cls(
        breakpoint_id=BreakpointId.from_json(json["breakpointId"]),
        location=Location.from_json(json["location"]),
    )

CallFrame dataclass

JavaScript call frame. Array of call frames form the call stack.

Source code in zendriver/cdp/debugger.py 
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
@dataclass
class CallFrame:
    """
    JavaScript call frame. Array of call frames form the call stack.
    """

    #: Call frame identifier. This identifier is only valid while the virtual machine is paused.
    call_frame_id: CallFrameId

    #: Name of the JavaScript function called on this call frame.
    function_name: str

    #: Location in the source code.
    location: Location

    #: JavaScript script name or url.
    #: Deprecated in favor of using the ``location.scriptId`` to resolve the URL via a previously
    #: sent ``Debugger.scriptParsed`` event.
    url: str

    #: Scope chain for this call frame.
    scope_chain: typing.List[Scope]

    #: ``this`` object for this call frame.
    this: runtime.RemoteObject

    #: Location in the source code.
    function_location: typing.Optional[Location] = None

    #: The value being returned, if the function is at return point.
    return_value: typing.Optional[runtime.RemoteObject] = None

    #: Valid only while the VM is paused and indicates whether this frame
    #: can be restarted or not. Note that a ``true`` value here does not
    #: guarantee that Debugger#restartFrame with this CallFrameId will be
    #: successful, but it is very likely.
    can_be_restarted: typing.Optional[bool] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["callFrameId"] = self.call_frame_id.to_json()
        json["functionName"] = self.function_name
        json["location"] = self.location.to_json()
        json["url"] = self.url
        json["scopeChain"] = [i.to_json() for i in self.scope_chain]
        json["this"] = self.this.to_json()
        if self.function_location is not None:
            json["functionLocation"] = self.function_location.to_json()
        if self.return_value is not None:
            json["returnValue"] = self.return_value.to_json()
        if self.can_be_restarted is not None:
            json["canBeRestarted"] = self.can_be_restarted
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CallFrame:
        return cls(
            call_frame_id=CallFrameId.from_json(json["callFrameId"]),
            function_name=str(json["functionName"]),
            location=Location.from_json(json["location"]),
            url=str(json["url"]),
            scope_chain=[Scope.from_json(i) for i in json["scopeChain"]],
            this=runtime.RemoteObject.from_json(json["this"]),
            function_location=(
                Location.from_json(json["functionLocation"])
                if json.get("functionLocation", None) is not None
                else None
            ),
            return_value=(
                runtime.RemoteObject.from_json(json["returnValue"])
                if json.get("returnValue", None) is not None
                else None
            ),
            can_be_restarted=(
                bool(json["canBeRestarted"])
                if json.get("canBeRestarted", None) is not None
                else None
            ),
        )

call_frame_id: CallFrameId instance-attribute

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

function_location: typing.Optional[Location] = None class-attribute instance-attribute

function_name: str instance-attribute

location: Location instance-attribute

return_value: typing.Optional[runtime.RemoteObject] = None class-attribute instance-attribute

scope_chain: typing.List[Scope] instance-attribute

this: runtime.RemoteObject instance-attribute

url: str instance-attribute

__init__(call_frame_id, function_name, location, url, scope_chain, this, function_location=None, return_value=None, can_be_restarted=None)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
@classmethod
def from_json(cls, json: T_JSON_DICT) -> CallFrame:
    return cls(
        call_frame_id=CallFrameId.from_json(json["callFrameId"]),
        function_name=str(json["functionName"]),
        location=Location.from_json(json["location"]),
        url=str(json["url"]),
        scope_chain=[Scope.from_json(i) for i in json["scopeChain"]],
        this=runtime.RemoteObject.from_json(json["this"]),
        function_location=(
            Location.from_json(json["functionLocation"])
            if json.get("functionLocation", None) is not None
            else None
        ),
        return_value=(
            runtime.RemoteObject.from_json(json["returnValue"])
            if json.get("returnValue", None) is not None
            else None
        ),
        can_be_restarted=(
            bool(json["canBeRestarted"])
            if json.get("canBeRestarted", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["callFrameId"] = self.call_frame_id.to_json()
    json["functionName"] = self.function_name
    json["location"] = self.location.to_json()
    json["url"] = self.url
    json["scopeChain"] = [i.to_json() for i in self.scope_chain]
    json["this"] = self.this.to_json()
    if self.function_location is not None:
        json["functionLocation"] = self.function_location.to_json()
    if self.return_value is not None:
        json["returnValue"] = self.return_value.to_json()
    if self.can_be_restarted is not None:
        json["canBeRestarted"] = self.can_be_restarted
    return json

CallFrameId

Bases: str

Call frame identifier.

Source code in zendriver/cdp/debugger.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class CallFrameId(str):
    """
    Call frame identifier.
    """

    def to_json(self) -> str:
        return self

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

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

__repr__()

Source code in zendriver/cdp/debugger.py 
46
47
def __repr__(self):
    return "CallFrameId({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
42
43
44
@classmethod
def from_json(cls, json: str) -> CallFrameId:
    return cls(json)

to_json()

Source code in zendriver/cdp/debugger.py 
39
40
def to_json(self) -> str:
    return self

DebugSymbols dataclass

Debug symbols available for a wasm script.

Source code in zendriver/cdp/debugger.py 
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
@dataclass
class DebugSymbols:
    """
    Debug symbols available for a wasm script.
    """

    #: Type of the debug symbols.
    type_: str

    #: URL of the external symbol source.
    external_url: typing.Optional[str] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["type"] = self.type_
        if self.external_url is not None:
            json["externalURL"] = self.external_url
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DebugSymbols:
        return cls(
            type_=str(json["type"]),
            external_url=(
                str(json["externalURL"])
                if json.get("externalURL", None) is not None
                else None
            ),
        )

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

type_: str instance-attribute

__init__(type_, external_url=None)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
392
393
394
395
396
397
398
399
400
401
@classmethod
def from_json(cls, json: T_JSON_DICT) -> DebugSymbols:
    return cls(
        type_=str(json["type"]),
        external_url=(
            str(json["externalURL"])
            if json.get("externalURL", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
385
386
387
388
389
390
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["type"] = self.type_
    if self.external_url is not None:
        json["externalURL"] = self.external_url
    return json

Location dataclass

Location in the source code.

Source code in zendriver/cdp/debugger.py 
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
@dataclass
class Location:
    """
    Location in the source code.
    """

    #: Script identifier as reported in the ``Debugger.scriptParsed``.
    script_id: runtime.ScriptId

    #: Line number in the script (0-based).
    line_number: int

    #: Column number in the script (0-based).
    column_number: typing.Optional[int] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["scriptId"] = self.script_id.to_json()
        json["lineNumber"] = self.line_number
        if self.column_number is not None:
            json["columnNumber"] = self.column_number
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> Location:
        return cls(
            script_id=runtime.ScriptId.from_json(json["scriptId"]),
            line_number=int(json["lineNumber"]),
            column_number=(
                int(json["columnNumber"])
                if json.get("columnNumber", None) is not None
                else None
            ),
        )

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

line_number: int instance-attribute

script_id: runtime.ScriptId instance-attribute

__init__(script_id, line_number, column_number=None)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
73
74
75
76
77
78
79
80
81
82
83
@classmethod
def from_json(cls, json: T_JSON_DICT) -> Location:
    return cls(
        script_id=runtime.ScriptId.from_json(json["scriptId"]),
        line_number=int(json["lineNumber"]),
        column_number=(
            int(json["columnNumber"])
            if json.get("columnNumber", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
65
66
67
68
69
70
71
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["scriptId"] = self.script_id.to_json()
    json["lineNumber"] = self.line_number
    if self.column_number is not None:
        json["columnNumber"] = self.column_number
    return json

LocationRange dataclass

Location range within one script.

Source code in zendriver/cdp/debugger.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
@dataclass
class LocationRange:
    """
    Location range within one script.
    """

    script_id: runtime.ScriptId

    start: ScriptPosition

    end: ScriptPosition

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["scriptId"] = self.script_id.to_json()
        json["start"] = self.start.to_json()
        json["end"] = self.end.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> LocationRange:
        return cls(
            script_id=runtime.ScriptId.from_json(json["scriptId"]),
            start=ScriptPosition.from_json(json["start"]),
            end=ScriptPosition.from_json(json["end"]),
        )

end: ScriptPosition instance-attribute

script_id: runtime.ScriptId instance-attribute

start: ScriptPosition instance-attribute

__init__(script_id, start, end)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
129
130
131
132
133
134
135
@classmethod
def from_json(cls, json: T_JSON_DICT) -> LocationRange:
    return cls(
        script_id=runtime.ScriptId.from_json(json["scriptId"]),
        start=ScriptPosition.from_json(json["start"]),
        end=ScriptPosition.from_json(json["end"]),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
122
123
124
125
126
127
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["scriptId"] = self.script_id.to_json()
    json["start"] = self.start.to_json()
    json["end"] = self.end.to_json()
    return json

Paused dataclass

Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.

Source code in zendriver/cdp/debugger.py 
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
@event_class("Debugger.paused")
@dataclass
class Paused:
    """
    Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
    """

    #: Call stack the virtual machine stopped on.
    call_frames: typing.List[CallFrame]
    #: Pause reason.
    reason: str
    #: Object containing break-specific auxiliary properties.
    data: typing.Optional[dict]
    #: Hit breakpoints IDs
    hit_breakpoints: typing.Optional[typing.List[str]]
    #: Async stack trace, if any.
    async_stack_trace: typing.Optional[runtime.StackTrace]
    #: Async stack trace, if any.
    async_stack_trace_id: typing.Optional[runtime.StackTraceId]
    #: Never present, will be removed.
    async_call_stack_trace_id: typing.Optional[runtime.StackTraceId]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> Paused:
        return cls(
            call_frames=[CallFrame.from_json(i) for i in json["callFrames"]],
            reason=str(json["reason"]),
            data=dict(json["data"]) if json.get("data", None) is not None else None,
            hit_breakpoints=(
                [str(i) for i in json["hitBreakpoints"]]
                if json.get("hitBreakpoints", None) is not None
                else None
            ),
            async_stack_trace=(
                runtime.StackTrace.from_json(json["asyncStackTrace"])
                if json.get("asyncStackTrace", None) is not None
                else None
            ),
            async_stack_trace_id=(
                runtime.StackTraceId.from_json(json["asyncStackTraceId"])
                if json.get("asyncStackTraceId", None) is not None
                else None
            ),
            async_call_stack_trace_id=(
                runtime.StackTraceId.from_json(json["asyncCallStackTraceId"])
                if json.get("asyncCallStackTraceId", None) is not None
                else None
            ),
        )

async_call_stack_trace_id: typing.Optional[runtime.StackTraceId] instance-attribute

async_stack_trace: typing.Optional[runtime.StackTrace] instance-attribute

async_stack_trace_id: typing.Optional[runtime.StackTraceId] instance-attribute

call_frames: typing.List[CallFrame] instance-attribute

data: typing.Optional[dict] instance-attribute

hit_breakpoints: typing.Optional[typing.List[str]] instance-attribute

reason: str instance-attribute

__init__(call_frames, reason, data, hit_breakpoints, async_stack_trace, async_stack_trace_id, async_call_stack_trace_id)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
@classmethod
def from_json(cls, json: T_JSON_DICT) -> Paused:
    return cls(
        call_frames=[CallFrame.from_json(i) for i in json["callFrames"]],
        reason=str(json["reason"]),
        data=dict(json["data"]) if json.get("data", None) is not None else None,
        hit_breakpoints=(
            [str(i) for i in json["hitBreakpoints"]]
            if json.get("hitBreakpoints", None) is not None
            else None
        ),
        async_stack_trace=(
            runtime.StackTrace.from_json(json["asyncStackTrace"])
            if json.get("asyncStackTrace", None) is not None
            else None
        ),
        async_stack_trace_id=(
            runtime.StackTraceId.from_json(json["asyncStackTraceId"])
            if json.get("asyncStackTraceId", None) is not None
            else None
        ),
        async_call_stack_trace_id=(
            runtime.StackTraceId.from_json(json["asyncCallStackTraceId"])
            if json.get("asyncCallStackTraceId", None) is not None
            else None
        ),
    )

Resumed dataclass

Fired when the virtual machine resumed execution.

Source code in zendriver/cdp/debugger.py 
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
@event_class("Debugger.resumed")
@dataclass
class Resumed:
    """
    Fired when the virtual machine resumed execution.
    """

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

__init__()

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
1321
1322
1323
@classmethod
def from_json(cls, json: T_JSON_DICT) -> Resumed:
    return cls()

Scope dataclass

Scope description.

Source code in zendriver/cdp/debugger.py 
219
220
221
222
223
224
225
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
256
257
258
259
260
261
262
263
264
265
266
267
268
269
@dataclass
class Scope:
    """
    Scope description.
    """

    #: Scope type.
    type_: str

    #: Object representing the scope. For ``global`` and ``with`` scopes it represents the actual
    #: object; for the rest of the scopes, it is artificial transient object enumerating scope
    #: variables as its properties.
    object_: runtime.RemoteObject

    name: typing.Optional[str] = None

    #: Location in the source code where scope starts
    start_location: typing.Optional[Location] = None

    #: Location in the source code where scope ends
    end_location: typing.Optional[Location] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["type"] = self.type_
        json["object"] = self.object_.to_json()
        if self.name is not None:
            json["name"] = self.name
        if self.start_location is not None:
            json["startLocation"] = self.start_location.to_json()
        if self.end_location is not None:
            json["endLocation"] = self.end_location.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> Scope:
        return cls(
            type_=str(json["type"]),
            object_=runtime.RemoteObject.from_json(json["object"]),
            name=str(json["name"]) if json.get("name", None) is not None else None,
            start_location=(
                Location.from_json(json["startLocation"])
                if json.get("startLocation", None) is not None
                else None
            ),
            end_location=(
                Location.from_json(json["endLocation"])
                if json.get("endLocation", None) is not None
                else None
            ),
        )

end_location: typing.Optional[Location] = None class-attribute instance-attribute

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

object_: runtime.RemoteObject instance-attribute

start_location: typing.Optional[Location] = None class-attribute instance-attribute

type_: str instance-attribute

__init__(type_, object_, name=None, start_location=None, end_location=None)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
@classmethod
def from_json(cls, json: T_JSON_DICT) -> Scope:
    return cls(
        type_=str(json["type"]),
        object_=runtime.RemoteObject.from_json(json["object"]),
        name=str(json["name"]) if json.get("name", None) is not None else None,
        start_location=(
            Location.from_json(json["startLocation"])
            if json.get("startLocation", None) is not None
            else None
        ),
        end_location=(
            Location.from_json(json["endLocation"])
            if json.get("endLocation", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
241
242
243
244
245
246
247
248
249
250
251
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["type"] = self.type_
    json["object"] = self.object_.to_json()
    if self.name is not None:
        json["name"] = self.name
    if self.start_location is not None:
        json["startLocation"] = self.start_location.to_json()
    if self.end_location is not None:
        json["endLocation"] = self.end_location.to_json()
    return json

ScriptFailedToParse dataclass

Fired when virtual machine fails to parse the script.

Source code in zendriver/cdp/debugger.py 
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
@event_class("Debugger.scriptFailedToParse")
@dataclass
class ScriptFailedToParse:
    """
    Fired when virtual machine fails to parse the script.
    """

    #: Identifier of the script parsed.
    script_id: runtime.ScriptId
    #: URL or name of the script parsed (if any).
    url: str
    #: Line offset of the script within the resource with given URL (for script tags).
    start_line: int
    #: Column offset of the script within the resource with given URL.
    start_column: int
    #: Last line of the script.
    end_line: int
    #: Length of the last line of the script.
    end_column: int
    #: Specifies script creation context.
    execution_context_id: runtime.ExecutionContextId
    #: Content hash of the script, SHA-256.
    hash_: str
    #: Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'``'isolated'``'worker', frameId: string}
    execution_context_aux_data: typing.Optional[dict]
    #: URL of source map associated with script (if any).
    source_map_url: typing.Optional[str]
    #: True, if this script has sourceURL.
    has_source_url: typing.Optional[bool]
    #: True, if this script is ES6 module.
    is_module: typing.Optional[bool]
    #: This script length.
    length: typing.Optional[int]
    #: JavaScript top stack frame of where the script parsed event was triggered if available.
    stack_trace: typing.Optional[runtime.StackTrace]
    #: If the scriptLanguage is WebAssembly, the code section offset in the module.
    code_offset: typing.Optional[int]
    #: The language of the script.
    script_language: typing.Optional[ScriptLanguage]
    #: The name the embedder supplied for this script.
    embedder_name: typing.Optional[str]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ScriptFailedToParse:
        return cls(
            script_id=runtime.ScriptId.from_json(json["scriptId"]),
            url=str(json["url"]),
            start_line=int(json["startLine"]),
            start_column=int(json["startColumn"]),
            end_line=int(json["endLine"]),
            end_column=int(json["endColumn"]),
            execution_context_id=runtime.ExecutionContextId.from_json(
                json["executionContextId"]
            ),
            hash_=str(json["hash"]),
            execution_context_aux_data=(
                dict(json["executionContextAuxData"])
                if json.get("executionContextAuxData", None) is not None
                else None
            ),
            source_map_url=(
                str(json["sourceMapURL"])
                if json.get("sourceMapURL", None) is not None
                else None
            ),
            has_source_url=(
                bool(json["hasSourceURL"])
                if json.get("hasSourceURL", None) is not None
                else None
            ),
            is_module=(
                bool(json["isModule"])
                if json.get("isModule", None) is not None
                else None
            ),
            length=(
                int(json["length"]) if json.get("length", None) is not None else None
            ),
            stack_trace=(
                runtime.StackTrace.from_json(json["stackTrace"])
                if json.get("stackTrace", None) is not None
                else None
            ),
            code_offset=(
                int(json["codeOffset"])
                if json.get("codeOffset", None) is not None
                else None
            ),
            script_language=(
                ScriptLanguage.from_json(json["scriptLanguage"])
                if json.get("scriptLanguage", None) is not None
                else None
            ),
            embedder_name=(
                str(json["embedderName"])
                if json.get("embedderName", None) is not None
                else None
            ),
        )

code_offset: typing.Optional[int] instance-attribute

embedder_name: typing.Optional[str] instance-attribute

end_column: int instance-attribute

end_line: int instance-attribute

execution_context_aux_data: typing.Optional[dict] instance-attribute

execution_context_id: runtime.ExecutionContextId instance-attribute

has_source_url: typing.Optional[bool] instance-attribute

hash_: str instance-attribute

is_module: typing.Optional[bool] instance-attribute

length: typing.Optional[int] instance-attribute

script_id: runtime.ScriptId instance-attribute

script_language: typing.Optional[ScriptLanguage] instance-attribute

source_map_url: typing.Optional[str] instance-attribute

stack_trace: typing.Optional[runtime.StackTrace] instance-attribute

start_column: int instance-attribute

start_line: int instance-attribute

url: str instance-attribute

__init__(script_id, url, start_line, start_column, end_line, end_column, execution_context_id, hash_, execution_context_aux_data, source_map_url, has_source_url, is_module, length, stack_trace, code_offset, script_language, embedder_name)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
@classmethod
def from_json(cls, json: T_JSON_DICT) -> ScriptFailedToParse:
    return cls(
        script_id=runtime.ScriptId.from_json(json["scriptId"]),
        url=str(json["url"]),
        start_line=int(json["startLine"]),
        start_column=int(json["startColumn"]),
        end_line=int(json["endLine"]),
        end_column=int(json["endColumn"]),
        execution_context_id=runtime.ExecutionContextId.from_json(
            json["executionContextId"]
        ),
        hash_=str(json["hash"]),
        execution_context_aux_data=(
            dict(json["executionContextAuxData"])
            if json.get("executionContextAuxData", None) is not None
            else None
        ),
        source_map_url=(
            str(json["sourceMapURL"])
            if json.get("sourceMapURL", None) is not None
            else None
        ),
        has_source_url=(
            bool(json["hasSourceURL"])
            if json.get("hasSourceURL", None) is not None
            else None
        ),
        is_module=(
            bool(json["isModule"])
            if json.get("isModule", None) is not None
            else None
        ),
        length=(
            int(json["length"]) if json.get("length", None) is not None else None
        ),
        stack_trace=(
            runtime.StackTrace.from_json(json["stackTrace"])
            if json.get("stackTrace", None) is not None
            else None
        ),
        code_offset=(
            int(json["codeOffset"])
            if json.get("codeOffset", None) is not None
            else None
        ),
        script_language=(
            ScriptLanguage.from_json(json["scriptLanguage"])
            if json.get("scriptLanguage", None) is not None
            else None
        ),
        embedder_name=(
            str(json["embedderName"])
            if json.get("embedderName", None) is not None
            else None
        ),
    )

ScriptLanguage

Bases: Enum

Enum of possible script languages.

Source code in zendriver/cdp/debugger.py 
357
358
359
360
361
362
363
364
365
366
367
368
369
370
class ScriptLanguage(enum.Enum):
    """
    Enum of possible script languages.
    """

    JAVA_SCRIPT = "JavaScript"
    WEB_ASSEMBLY = "WebAssembly"

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

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

JAVA_SCRIPT = 'JavaScript' class-attribute instance-attribute

WEB_ASSEMBLY = 'WebAssembly' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
368
369
370
@classmethod
def from_json(cls, json: str) -> ScriptLanguage:
    return cls(json)

to_json()

Source code in zendriver/cdp/debugger.py 
365
366
def to_json(self) -> str:
    return self.value

ScriptParsed dataclass

Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.

Source code in zendriver/cdp/debugger.py 
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
@event_class("Debugger.scriptParsed")
@dataclass
class ScriptParsed:
    """
    Fired when virtual machine parses script. This event is also fired for all known and uncollected
    scripts upon enabling debugger.
    """

    #: Identifier of the script parsed.
    script_id: runtime.ScriptId
    #: URL or name of the script parsed (if any).
    url: str
    #: Line offset of the script within the resource with given URL (for script tags).
    start_line: int
    #: Column offset of the script within the resource with given URL.
    start_column: int
    #: Last line of the script.
    end_line: int
    #: Length of the last line of the script.
    end_column: int
    #: Specifies script creation context.
    execution_context_id: runtime.ExecutionContextId
    #: Content hash of the script, SHA-256.
    hash_: str
    #: Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'``'isolated'``'worker', frameId: string}
    execution_context_aux_data: typing.Optional[dict]
    #: True, if this script is generated as a result of the live edit operation.
    is_live_edit: typing.Optional[bool]
    #: URL of source map associated with script (if any).
    source_map_url: typing.Optional[str]
    #: True, if this script has sourceURL.
    has_source_url: typing.Optional[bool]
    #: True, if this script is ES6 module.
    is_module: typing.Optional[bool]
    #: This script length.
    length: typing.Optional[int]
    #: JavaScript top stack frame of where the script parsed event was triggered if available.
    stack_trace: typing.Optional[runtime.StackTrace]
    #: If the scriptLanguage is WebAssembly, the code section offset in the module.
    code_offset: typing.Optional[int]
    #: The language of the script.
    script_language: typing.Optional[ScriptLanguage]
    #: If the scriptLanguage is WebASsembly, the source of debug symbols for the module.
    debug_symbols: typing.Optional[DebugSymbols]
    #: The name the embedder supplied for this script.
    embedder_name: typing.Optional[str]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ScriptParsed:
        return cls(
            script_id=runtime.ScriptId.from_json(json["scriptId"]),
            url=str(json["url"]),
            start_line=int(json["startLine"]),
            start_column=int(json["startColumn"]),
            end_line=int(json["endLine"]),
            end_column=int(json["endColumn"]),
            execution_context_id=runtime.ExecutionContextId.from_json(
                json["executionContextId"]
            ),
            hash_=str(json["hash"]),
            execution_context_aux_data=(
                dict(json["executionContextAuxData"])
                if json.get("executionContextAuxData", None) is not None
                else None
            ),
            is_live_edit=(
                bool(json["isLiveEdit"])
                if json.get("isLiveEdit", None) is not None
                else None
            ),
            source_map_url=(
                str(json["sourceMapURL"])
                if json.get("sourceMapURL", None) is not None
                else None
            ),
            has_source_url=(
                bool(json["hasSourceURL"])
                if json.get("hasSourceURL", None) is not None
                else None
            ),
            is_module=(
                bool(json["isModule"])
                if json.get("isModule", None) is not None
                else None
            ),
            length=(
                int(json["length"]) if json.get("length", None) is not None else None
            ),
            stack_trace=(
                runtime.StackTrace.from_json(json["stackTrace"])
                if json.get("stackTrace", None) is not None
                else None
            ),
            code_offset=(
                int(json["codeOffset"])
                if json.get("codeOffset", None) is not None
                else None
            ),
            script_language=(
                ScriptLanguage.from_json(json["scriptLanguage"])
                if json.get("scriptLanguage", None) is not None
                else None
            ),
            debug_symbols=(
                DebugSymbols.from_json(json["debugSymbols"])
                if json.get("debugSymbols", None) is not None
                else None
            ),
            embedder_name=(
                str(json["embedderName"])
                if json.get("embedderName", None) is not None
                else None
            ),
        )

code_offset: typing.Optional[int] instance-attribute

debug_symbols: typing.Optional[DebugSymbols] instance-attribute

embedder_name: typing.Optional[str] instance-attribute

end_column: int instance-attribute

end_line: int instance-attribute

execution_context_aux_data: typing.Optional[dict] instance-attribute

execution_context_id: runtime.ExecutionContextId instance-attribute

has_source_url: typing.Optional[bool] instance-attribute

hash_: str instance-attribute

is_live_edit: typing.Optional[bool] instance-attribute

is_module: typing.Optional[bool] instance-attribute

length: typing.Optional[int] instance-attribute

script_id: runtime.ScriptId instance-attribute

script_language: typing.Optional[ScriptLanguage] instance-attribute

source_map_url: typing.Optional[str] instance-attribute

stack_trace: typing.Optional[runtime.StackTrace] instance-attribute

start_column: int instance-attribute

start_line: int instance-attribute

url: str instance-attribute

__init__(script_id, url, start_line, start_column, end_line, end_column, execution_context_id, hash_, execution_context_aux_data, is_live_edit, source_map_url, has_source_url, is_module, length, stack_trace, code_offset, script_language, debug_symbols, embedder_name)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
@classmethod
def from_json(cls, json: T_JSON_DICT) -> ScriptParsed:
    return cls(
        script_id=runtime.ScriptId.from_json(json["scriptId"]),
        url=str(json["url"]),
        start_line=int(json["startLine"]),
        start_column=int(json["startColumn"]),
        end_line=int(json["endLine"]),
        end_column=int(json["endColumn"]),
        execution_context_id=runtime.ExecutionContextId.from_json(
            json["executionContextId"]
        ),
        hash_=str(json["hash"]),
        execution_context_aux_data=(
            dict(json["executionContextAuxData"])
            if json.get("executionContextAuxData", None) is not None
            else None
        ),
        is_live_edit=(
            bool(json["isLiveEdit"])
            if json.get("isLiveEdit", None) is not None
            else None
        ),
        source_map_url=(
            str(json["sourceMapURL"])
            if json.get("sourceMapURL", None) is not None
            else None
        ),
        has_source_url=(
            bool(json["hasSourceURL"])
            if json.get("hasSourceURL", None) is not None
            else None
        ),
        is_module=(
            bool(json["isModule"])
            if json.get("isModule", None) is not None
            else None
        ),
        length=(
            int(json["length"]) if json.get("length", None) is not None else None
        ),
        stack_trace=(
            runtime.StackTrace.from_json(json["stackTrace"])
            if json.get("stackTrace", None) is not None
            else None
        ),
        code_offset=(
            int(json["codeOffset"])
            if json.get("codeOffset", None) is not None
            else None
        ),
        script_language=(
            ScriptLanguage.from_json(json["scriptLanguage"])
            if json.get("scriptLanguage", None) is not None
            else None
        ),
        debug_symbols=(
            DebugSymbols.from_json(json["debugSymbols"])
            if json.get("debugSymbols", None) is not None
            else None
        ),
        embedder_name=(
            str(json["embedderName"])
            if json.get("embedderName", None) is not None
            else None
        ),
    )

ScriptPosition dataclass

Location in the source code.

Source code in zendriver/cdp/debugger.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
@dataclass
class ScriptPosition:
    """
    Location in the source code.
    """

    line_number: int

    column_number: int

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["lineNumber"] = self.line_number
        json["columnNumber"] = self.column_number
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ScriptPosition:
        return cls(
            line_number=int(json["lineNumber"]),
            column_number=int(json["columnNumber"]),
        )

column_number: int instance-attribute

line_number: int instance-attribute

__init__(line_number, column_number)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
102
103
104
105
106
107
@classmethod
def from_json(cls, json: T_JSON_DICT) -> ScriptPosition:
    return cls(
        line_number=int(json["lineNumber"]),
        column_number=int(json["columnNumber"]),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
 96
 97
 98
 99
100
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["lineNumber"] = self.line_number
    json["columnNumber"] = self.column_number
    return json

SearchMatch dataclass

Search match for resource.

Source code in zendriver/cdp/debugger.py 
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
@dataclass
class SearchMatch:
    """
    Search match for resource.
    """

    #: Line number in resource content.
    line_number: float

    #: Line with match content.
    line_content: str

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["lineNumber"] = self.line_number
        json["lineContent"] = self.line_content
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> SearchMatch:
        return cls(
            line_number=float(json["lineNumber"]),
            line_content=str(json["lineContent"]),
        )

line_content: str instance-attribute

line_number: float instance-attribute

__init__(line_number, line_content)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
290
291
292
293
294
295
@classmethod
def from_json(cls, json: T_JSON_DICT) -> SearchMatch:
    return cls(
        line_number=float(json["lineNumber"]),
        line_content=str(json["lineContent"]),
    )

to_json()

Source code in zendriver/cdp/debugger.py 
284
285
286
287
288
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["lineNumber"] = self.line_number
    json["lineContent"] = self.line_content
    return json

WasmDisassemblyChunk dataclass

Source code in zendriver/cdp/debugger.py 
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
@dataclass
class WasmDisassemblyChunk:
    #: The next chunk of disassembled lines.
    lines: typing.List[str]

    #: The bytecode offsets describing the start of each line.
    bytecode_offsets: typing.List[int]

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["lines"] = [i for i in self.lines]
        json["bytecodeOffsets"] = [i for i in self.bytecode_offsets]
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> WasmDisassemblyChunk:
        return cls(
            lines=[str(i) for i in json["lines"]],
            bytecode_offsets=[int(i) for i in json["bytecodeOffsets"]],
        )

bytecode_offsets: typing.List[int] instance-attribute

lines: typing.List[str] instance-attribute

__init__(lines, bytecode_offsets)

from_json(json) classmethod

Source code in zendriver/cdp/debugger.py 
349
350
351
352
353
354
@classmethod
def from_json(cls, json: T_JSON_DICT) -> WasmDisassemblyChunk:
    return cls(
        lines=[str(i) for i in json["lines"]],
        bytecode_offsets=[int(i) for i in json["bytecodeOffsets"]],
    )

to_json()

Source code in zendriver/cdp/debugger.py 
343
344
345
346
347
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["lines"] = [i for i in self.lines]
    json["bytecodeOffsets"] = [i for i in self.bytecode_offsets]
    return json

continue_to_location(location, target_call_frames=None)

Continues execution until specific location is reached.

Parameters:

Name Type Description Default
location Location

Location to continue to.

 required
target_call_frames Optional[str]

(Optional)

 None
Source code in zendriver/cdp/debugger.py 
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
def continue_to_location(
    location: Location, target_call_frames: typing.Optional[str] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Continues execution until specific location is reached.

    :param location: Location to continue to.
    :param target_call_frames: *(Optional)*
    """
    params: T_JSON_DICT = dict()
    params["location"] = location.to_json()
    if target_call_frames is not None:
        params["targetCallFrames"] = target_call_frames
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.continueToLocation",
        "params": params,
    }
    json = yield cmd_dict

disable()

Disables debugger for given page.

Source code in zendriver/cdp/debugger.py 
424
425
426
427
428
429
430
431
def disable() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Disables debugger for given page.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.disable",
    }
    json = yield cmd_dict

disassemble_wasm_module(script_id)

EXPERIMENTAL

Parameters:

Name Type Description Default
script_id ScriptId

Id of the script to disassemble

 required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[Optional[str], int, List[int], WasmDisassemblyChunk]]

A tuple with the following items: 0. streamId - (Optional) For large modules, return a stream from which additional chunks of disassembly can be read successively. 1. totalNumberOfLines - The total number of lines in the disassembly text. 2. functionBodyOffsets - The offsets of all function bodies, in the format [start1, end1, start2, end2, ...] where all ends are exclusive. 3. chunk - The first chunk of disassembly.
Source code in zendriver/cdp/debugger.py 
574
575
576
577
578
579
580
581
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
def disassemble_wasm_module(
    script_id: runtime.ScriptId,
) -> typing.Generator[
    T_JSON_DICT,
    T_JSON_DICT,
    typing.Tuple[typing.Optional[str], int, typing.List[int], WasmDisassemblyChunk],
]:
    """


    **EXPERIMENTAL**

    :param script_id: Id of the script to disassemble
    :returns: A tuple with the following items:

        0. **streamId** - *(Optional)* For large modules, return a stream from which additional chunks of disassembly can be read successively.
        1. **totalNumberOfLines** - The total number of lines in the disassembly text.
        2. **functionBodyOffsets** - The offsets of all function bodies, in the format [start1, end1, start2, end2, ...] where all ends are exclusive.
        3. **chunk** - The first chunk of disassembly.
    """
    params: T_JSON_DICT = dict()
    params["scriptId"] = script_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.disassembleWasmModule",
        "params": params,
    }
    json = yield cmd_dict
    return (
        str(json["streamId"]) if json.get("streamId", None) is not None else None,
        int(json["totalNumberOfLines"]),
        [int(i) for i in json["functionBodyOffsets"]],
        WasmDisassemblyChunk.from_json(json["chunk"]),
    )

enable(max_scripts_cache_size=None)

Enables debugger for the given page. Clients should not assume that the debugging has been enabled until the result for this command is received.

Parameters:

Name Type Description Default
max_scripts_cache_size Optional[float]

(EXPERIMENTAL) (Optional) The maximum size in bytes of collected scripts (not referenced by other heap objects) the debugger can hold. Puts no limit if parameter is omitted.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, UniqueDebuggerId]

Unique identifier of the debugger.
Source code in zendriver/cdp/debugger.py 
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
def enable(
    max_scripts_cache_size: typing.Optional[float] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, runtime.UniqueDebuggerId]:
    """
    Enables debugger for the given page. Clients should not assume that the debugging has been
    enabled until the result for this command is received.

    :param max_scripts_cache_size: **(EXPERIMENTAL)** *(Optional)* The maximum size in bytes of collected scripts (not referenced by other heap objects) the debugger can hold. Puts no limit if parameter is omitted.
    :returns: Unique identifier of the debugger.
    """
    params: T_JSON_DICT = dict()
    if max_scripts_cache_size is not None:
        params["maxScriptsCacheSize"] = max_scripts_cache_size
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.enable",
        "params": params,
    }
    json = yield cmd_dict
    return runtime.UniqueDebuggerId.from_json(json["debuggerId"])

evaluate_on_call_frame(call_frame_id, expression, object_group=None, include_command_line_api=None, silent=None, return_by_value=None, generate_preview=None, throw_on_side_effect=None, timeout=None)

Evaluates expression on a given call frame.

Parameters:

Name Type Description Default
call_frame_id CallFrameId

Call frame identifier to evaluate on.

 required
expression str

Expression to evaluate.

 required
object_group Optional[str]

(Optional) String object group name to put result into (allows rapid releasing resulting object handles using ```releaseObjectGroup````).

 None
include_command_line_api Optional[bool]

(Optional) Specifies whether command line API should be available to the evaluated expression, defaults to false.

 None
silent Optional[bool]

(Optional) In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides `setPauseOnException state.

 None
return_by_value Optional[bool]

(Optional) Whether the result is expected to be a JSON object that should be sent by value.

 None
generate_preview Optional[bool]

(EXPERIMENTAL) (Optional) Whether preview should be generated for the result.

 None
throw_on_side_effect Optional[bool]

(Optional) Whether to throw an exception if side effect cannot be ruled out during evaluation.

 None
timeout Optional[TimeDelta]

(EXPERIMENTAL) (Optional) Terminate execution after timing out (number of milliseconds).

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[RemoteObject, Optional[ExceptionDetails]]]

A tuple with the following items: 0. result - Object wrapper for the evaluation result. 1. exceptionDetails - (Optional) Exception details.
Source code in zendriver/cdp/debugger.py 
455
456
457
458
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
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
def evaluate_on_call_frame(
    call_frame_id: CallFrameId,
    expression: str,
    object_group: typing.Optional[str] = None,
    include_command_line_api: typing.Optional[bool] = None,
    silent: typing.Optional[bool] = None,
    return_by_value: typing.Optional[bool] = None,
    generate_preview: typing.Optional[bool] = None,
    throw_on_side_effect: typing.Optional[bool] = None,
    timeout: typing.Optional[runtime.TimeDelta] = None,
) -> typing.Generator[
    T_JSON_DICT,
    T_JSON_DICT,
    typing.Tuple[runtime.RemoteObject, typing.Optional[runtime.ExceptionDetails]],
]:
    """
    Evaluates expression on a given call frame.

    :param call_frame_id: Call frame identifier to evaluate on.
    :param expression: Expression to evaluate.
    :param object_group: *(Optional)* String object group name to put result into (allows rapid releasing resulting object handles using ```releaseObjectGroup````).
    :param include_command_line_api: *(Optional)* Specifies whether command line API should be available to the evaluated expression, defaults to false.
    :param silent: *(Optional)* In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides ````setPauseOnException``` state.
    :param return_by_value: *(Optional)* Whether the result is expected to be a JSON object that should be sent by value.
    :param generate_preview: **(EXPERIMENTAL)** *(Optional)* Whether preview should be generated for the result.
    :param throw_on_side_effect: *(Optional)* Whether to throw an exception if side effect cannot be ruled out during evaluation.
    :param timeout: **(EXPERIMENTAL)** *(Optional)* Terminate execution after timing out (number of milliseconds).
    :returns: A tuple with the following items:

        0. **result** - Object wrapper for the evaluation result.
        1. **exceptionDetails** - *(Optional)* Exception details.
    """
    params: T_JSON_DICT = dict()
    params["callFrameId"] = call_frame_id.to_json()
    params["expression"] = expression
    if object_group is not None:
        params["objectGroup"] = object_group
    if include_command_line_api is not None:
        params["includeCommandLineAPI"] = include_command_line_api
    if silent is not None:
        params["silent"] = silent
    if return_by_value is not None:
        params["returnByValue"] = return_by_value
    if generate_preview is not None:
        params["generatePreview"] = generate_preview
    if throw_on_side_effect is not None:
        params["throwOnSideEffect"] = throw_on_side_effect
    if timeout is not None:
        params["timeout"] = timeout.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.evaluateOnCallFrame",
        "params": params,
    }
    json = yield cmd_dict
    return (
        runtime.RemoteObject.from_json(json["result"]),
        (
            runtime.ExceptionDetails.from_json(json["exceptionDetails"])
            if json.get("exceptionDetails", None) is not None
            else None
        ),
    )

get_possible_breakpoints(start, end=None, restrict_to_function=None)

Returns possible locations for breakpoint. scriptId in start and end range locations should be the same.

Parameters:

Name Type Description Default
start Location

Start of range to search possible breakpoint locations in.

 required
end Optional[Location]

(Optional) End of range to search possible breakpoint locations in (excluding). When not specified, end of scripts is used as end of range.

 None
restrict_to_function Optional[bool]

(Optional) Only consider locations which are in the same (non-nested) function as start.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, List[BreakLocation]]

List of the possible breakpoint locations.
Source code in zendriver/cdp/debugger.py 
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
def get_possible_breakpoints(
    start: Location,
    end: typing.Optional[Location] = None,
    restrict_to_function: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[BreakLocation]]:
    """
    Returns possible locations for breakpoint. scriptId in start and end range locations should be
    the same.

    :param start: Start of range to search possible breakpoint locations in.
    :param end: *(Optional)* End of range to search possible breakpoint locations in (excluding). When not specified, end of scripts is used as end of range.
    :param restrict_to_function: *(Optional)* Only consider locations which are in the same (non-nested) function as start.
    :returns: List of the possible breakpoint locations.
    """
    params: T_JSON_DICT = dict()
    params["start"] = start.to_json()
    if end is not None:
        params["end"] = end.to_json()
    if restrict_to_function is not None:
        params["restrictToFunction"] = restrict_to_function
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.getPossibleBreakpoints",
        "params": params,
    }
    json = yield cmd_dict
    return [BreakLocation.from_json(i) for i in json["locations"]]

get_script_source(script_id)

Returns source for the script with given id.

Parameters:

Name Type Description Default
script_id ScriptId

Id of the script to get source for.

 required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[str, Optional[str]]]

A tuple with the following items: 0. scriptSource - Script source (empty in case of Wasm bytecode). 1. bytecode - (Optional) Wasm bytecode. (Encoded as a base64 string when passed over JSON)
Source code in zendriver/cdp/debugger.py 
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
def get_script_source(
    script_id: runtime.ScriptId,
) -> typing.Generator[
    T_JSON_DICT, T_JSON_DICT, typing.Tuple[str, typing.Optional[str]]
]:
    """
    Returns source for the script with given id.

    :param script_id: Id of the script to get source for.
    :returns: A tuple with the following items:

        0. **scriptSource** - Script source (empty in case of Wasm bytecode).
        1. **bytecode** - *(Optional)* Wasm bytecode. (Encoded as a base64 string when passed over JSON)
    """
    params: T_JSON_DICT = dict()
    params["scriptId"] = script_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.getScriptSource",
        "params": params,
    }
    json = yield cmd_dict
    return (
        str(json["scriptSource"]),
        str(json["bytecode"]) if json.get("bytecode", None) is not None else None,
    )

get_stack_trace(stack_trace_id)

Returns stack trace with given stackTraceId.

EXPERIMENTAL

Parameters:

Name Type Description Default
stack_trace_id StackTraceId
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, StackTrace]
Source code in zendriver/cdp/debugger.py 
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
def get_stack_trace(
    stack_trace_id: runtime.StackTraceId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, runtime.StackTrace]:
    """
    Returns stack trace with given ``stackTraceId``.

    **EXPERIMENTAL**

    :param stack_trace_id:
    :returns:
    """
    params: T_JSON_DICT = dict()
    params["stackTraceId"] = stack_trace_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.getStackTrace",
        "params": params,
    }
    json = yield cmd_dict
    return runtime.StackTrace.from_json(json["stackTrace"])

get_wasm_bytecode(script_id)

This command is deprecated. Use getScriptSource instead.

.. deprecated:: 1.3

Parameters:

Name Type Description Default
script_id ScriptId

Id of the Wasm script to get source for.

 required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, str]

Script source. (Encoded as a base64 string when passed over JSON)
Source code in zendriver/cdp/debugger.py 
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
@deprecated(version="1.3")
def get_wasm_bytecode(
    script_id: runtime.ScriptId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, str]:
    """
    This command is deprecated. Use getScriptSource instead.

    .. deprecated:: 1.3

    :param script_id: Id of the Wasm script to get source for.
    :returns: Script source. (Encoded as a base64 string when passed over JSON)
    """
    params: T_JSON_DICT = dict()
    params["scriptId"] = script_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.getWasmBytecode",
        "params": params,
    }
    json = yield cmd_dict
    return str(json["bytecode"])

next_wasm_disassembly_chunk(stream_id)

Disassemble the next chunk of lines for the module corresponding to the stream. If disassembly is complete, this API will invalidate the streamId and return an empty chunk. Any subsequent calls for the now invalid stream will return errors.

EXPERIMENTAL

Parameters:

Name Type Description Default
stream_id str
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, WasmDisassemblyChunk]

The next chunk of disassembly.
Source code in zendriver/cdp/debugger.py 
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
def next_wasm_disassembly_chunk(
    stream_id: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, WasmDisassemblyChunk]:
    """
    Disassemble the next chunk of lines for the module corresponding to the
    stream. If disassembly is complete, this API will invalidate the streamId
    and return an empty chunk. Any subsequent calls for the now invalid stream
    will return errors.

    **EXPERIMENTAL**

    :param stream_id:
    :returns: The next chunk of disassembly.
    """
    params: T_JSON_DICT = dict()
    params["streamId"] = stream_id
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.nextWasmDisassemblyChunk",
        "params": params,
    }
    json = yield cmd_dict
    return WasmDisassemblyChunk.from_json(json["chunk"])

pause()

Stops on the next JavaScript statement.

Source code in zendriver/cdp/debugger.py 
676
677
678
679
680
681
682
683
def pause() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Stops on the next JavaScript statement.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.pause",
    }
    json = yield cmd_dict

pause_on_async_call(parent_stack_trace_id)

.. deprecated:: 1.3

EXPERIMENTAL

Parameters:

Name Type Description Default
parent_stack_trace_id StackTraceId

Debugger will pause when async call with given stack trace is started.

 required
Source code in zendriver/cdp/debugger.py 
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
@deprecated(version="1.3")
def pause_on_async_call(
    parent_stack_trace_id: runtime.StackTraceId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """


    .. deprecated:: 1.3

    **EXPERIMENTAL**

    :param parent_stack_trace_id: Debugger will pause when async call with given stack trace is started.
    """
    params: T_JSON_DICT = dict()
    params["parentStackTraceId"] = parent_stack_trace_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.pauseOnAsyncCall",
        "params": params,
    }
    json = yield cmd_dict

remove_breakpoint(breakpoint_id)

Removes JavaScript breakpoint.

Parameters:

Name Type Description Default
breakpoint_id BreakpointId
required
Source code in zendriver/cdp/debugger.py 
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
def remove_breakpoint(
    breakpoint_id: BreakpointId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes JavaScript breakpoint.

    :param breakpoint_id:
    """
    params: T_JSON_DICT = dict()
    params["breakpointId"] = breakpoint_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.removeBreakpoint",
        "params": params,
    }
    json = yield cmd_dict

restart_frame(call_frame_id, mode=None)

Restarts particular call frame from the beginning. The old, deprecated behavior of restartFrame is to stay paused and allow further CDP commands after a restart was scheduled. This can cause problems with restarting, so we now continue execution immediatly after it has been scheduled until we reach the beginning of the restarted frame.

To stay back-wards compatible, restartFrame now expects a mode parameter to be present. If the mode parameter is missing, restartFrame errors out.

The various return values are deprecated and callFrames is always empty. Use the call frames from the Debugger#paused events instead, that fires once V8 pauses at the beginning of the restarted function.

Parameters:

Name Type Description Default
call_frame_id CallFrameId

Call frame identifier to evaluate on.

 required
mode Optional[str]

(EXPERIMENTAL) (Optional) The mode```` parameter must be present and set to 'StepInto', otherwise ````restartFrame will error out.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[List[CallFrame], Optional[StackTrace], Optional[StackTraceId]]]

A tuple with the following items: 0. callFrames - New stack trace. 1. asyncStackTrace - (Optional) Async stack trace, if any. 2. asyncStackTraceId - (Optional) Async stack trace, if any.
Source code in zendriver/cdp/debugger.py 
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
def restart_frame(
    call_frame_id: CallFrameId, mode: typing.Optional[str] = None
) -> typing.Generator[
    T_JSON_DICT,
    T_JSON_DICT,
    typing.Tuple[
        typing.List[CallFrame],
        typing.Optional[runtime.StackTrace],
        typing.Optional[runtime.StackTraceId],
    ],
]:
    """
    Restarts particular call frame from the beginning. The old, deprecated
    behavior of ``restartFrame`` is to stay paused and allow further CDP commands
    after a restart was scheduled. This can cause problems with restarting, so
    we now continue execution immediatly after it has been scheduled until we
    reach the beginning of the restarted frame.

    To stay back-wards compatible, ``restartFrame`` now expects a ``mode``
    parameter to be present. If the ``mode`` parameter is missing, ``restartFrame``
    errors out.

    The various return values are deprecated and ``callFrames`` is always empty.
    Use the call frames from the ``Debugger#paused`` events instead, that fires
    once V8 pauses at the beginning of the restarted function.

    :param call_frame_id: Call frame identifier to evaluate on.
    :param mode: **(EXPERIMENTAL)** *(Optional)* The ```mode```` parameter must be present and set to 'StepInto', otherwise ````restartFrame``` will error out.
    :returns: A tuple with the following items:

        0. **callFrames** - New stack trace.
        1. **asyncStackTrace** - *(Optional)* Async stack trace, if any.
        2. **asyncStackTraceId** - *(Optional)* Async stack trace, if any.
    """
    params: T_JSON_DICT = dict()
    params["callFrameId"] = call_frame_id.to_json()
    if mode is not None:
        params["mode"] = mode
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.restartFrame",
        "params": params,
    }
    json = yield cmd_dict
    return (
        [CallFrame.from_json(i) for i in json["callFrames"]],
        (
            runtime.StackTrace.from_json(json["asyncStackTrace"])
            if json.get("asyncStackTrace", None) is not None
            else None
        ),
        (
            runtime.StackTraceId.from_json(json["asyncStackTraceId"])
            if json.get("asyncStackTraceId", None) is not None
            else None
        ),
    )

resume(terminate_on_resume=None)

Resumes JavaScript execution.

Parameters:

Name Type Description Default
terminate_on_resume Optional[bool]

(Optional) Set to true to terminate execution upon resuming execution. In contrast to Runtime.terminateExecution, this will allows to execute further JavaScript (i.e. via evaluation) until execution of the paused code is actually resumed, at which point termination is triggered. If execution is currently not paused, this parameter has no effect.

 None
Source code in zendriver/cdp/debugger.py 
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
def resume(
    terminate_on_resume: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Resumes JavaScript execution.

    :param terminate_on_resume: *(Optional)* Set to true to terminate execution upon resuming execution. In contrast to Runtime.terminateExecution, this will allows to execute further JavaScript (i.e. via evaluation) until execution of the paused code is actually resumed, at which point termination is triggered. If execution is currently not paused, this parameter has no effect.
    """
    params: T_JSON_DICT = dict()
    if terminate_on_resume is not None:
        params["terminateOnResume"] = terminate_on_resume
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.resume",
        "params": params,
    }
    json = yield cmd_dict

search_in_content(script_id, query, case_sensitive=None, is_regex=None)

Searches for given string in script content.

Parameters:

Name Type Description Default
script_id ScriptId

Id of the script to search in.

 required
query str

String to search for.

 required
case_sensitive Optional[bool]

(Optional) If true, search is case sensitive.

 None
is_regex Optional[bool]

(Optional) If true, treats string parameter as regex.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, List[SearchMatch]]

List of search matches.
Source code in zendriver/cdp/debugger.py 
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
def search_in_content(
    script_id: runtime.ScriptId,
    query: str,
    case_sensitive: typing.Optional[bool] = None,
    is_regex: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[SearchMatch]]:
    """
    Searches for given string in script content.

    :param script_id: Id of the script to search in.
    :param query: String to search for.
    :param case_sensitive: *(Optional)* If true, search is case sensitive.
    :param is_regex: *(Optional)* If true, treats string parameter as regex.
    :returns: List of search matches.
    """
    params: T_JSON_DICT = dict()
    params["scriptId"] = script_id.to_json()
    params["query"] = query
    if case_sensitive is not None:
        params["caseSensitive"] = case_sensitive
    if is_regex is not None:
        params["isRegex"] = is_regex
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.searchInContent",
        "params": params,
    }
    json = yield cmd_dict
    return [SearchMatch.from_json(i) for i in json["result"]]

set_async_call_stack_depth(max_depth)

Enables or disables async call stacks tracking.

Parameters:

Name Type Description Default
max_depth int

Maximum depth of async call stacks. Setting to 0 will effectively disable collecting async call stacks (default).

 required
Source code in zendriver/cdp/debugger.py 
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
def set_async_call_stack_depth(
    max_depth: int,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Enables or disables async call stacks tracking.

    :param max_depth: Maximum depth of async call stacks. Setting to ```0``` will effectively disable collecting async call stacks (default).
    """
    params: T_JSON_DICT = dict()
    params["maxDepth"] = max_depth
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setAsyncCallStackDepth",
        "params": params,
    }
    json = yield cmd_dict

set_blackbox_patterns(patterns)

Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.

EXPERIMENTAL

Parameters:

Name Type Description Default
patterns List[str]

Array of regexps that will be used to check script url for blackbox state.

 required
Source code in zendriver/cdp/debugger.py 
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
def set_blackbox_patterns(
    patterns: typing.List[str],
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in
    scripts with url matching one of the patterns. VM will try to leave blackboxed script by
    performing 'step in' several times, finally resorting to 'step out' if unsuccessful.

    **EXPERIMENTAL**

    :param patterns: Array of regexps that will be used to check script url for blackbox state.
    """
    params: T_JSON_DICT = dict()
    params["patterns"] = [i for i in patterns]
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setBlackboxPatterns",
        "params": params,
    }
    json = yield cmd_dict

set_blackboxed_ranges(script_id, positions)

Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. Positions array contains positions where blackbox state is changed. First interval isn't blackboxed. Array should be sorted.

EXPERIMENTAL

Parameters:

Name Type Description Default
script_id ScriptId

Id of the script.

 required
positions List[ScriptPosition]
required
Source code in zendriver/cdp/debugger.py 
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
def set_blackboxed_ranges(
    script_id: runtime.ScriptId, positions: typing.List[ScriptPosition]
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted
    scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.
    Positions array contains positions where blackbox state is changed. First interval isn't
    blackboxed. Array should be sorted.

    **EXPERIMENTAL**

    :param script_id: Id of the script.
    :param positions:
    """
    params: T_JSON_DICT = dict()
    params["scriptId"] = script_id.to_json()
    params["positions"] = [i.to_json() for i in positions]
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setBlackboxedRanges",
        "params": params,
    }
    json = yield cmd_dict

set_breakpoint(location, condition=None)

Sets JavaScript breakpoint at a given location.

Parameters:

Name Type Description Default
location Location

Location to set breakpoint in.

 required
condition Optional[str]

(Optional) Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[BreakpointId, Location]]

A tuple with the following items: 0. breakpointId - Id of the created breakpoint for further reference. 1. actualLocation - Location this breakpoint resolved into.
Source code in zendriver/cdp/debugger.py 
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
def set_breakpoint(
    location: Location, condition: typing.Optional[str] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.Tuple[BreakpointId, Location]]:
    """
    Sets JavaScript breakpoint at a given location.

    :param location: Location to set breakpoint in.
    :param condition: *(Optional)* Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
    :returns: A tuple with the following items:

        0. **breakpointId** - Id of the created breakpoint for further reference.
        1. **actualLocation** - Location this breakpoint resolved into.
    """
    params: T_JSON_DICT = dict()
    params["location"] = location.to_json()
    if condition is not None:
        params["condition"] = condition
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setBreakpoint",
        "params": params,
    }
    json = yield cmd_dict
    return (
        BreakpointId.from_json(json["breakpointId"]),
        Location.from_json(json["actualLocation"]),
    )

set_breakpoint_by_url(line_number, url=None, url_regex=None, script_hash=None, column_number=None, condition=None)

Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this command is issued, all existing parsed scripts will have breakpoints resolved and returned in locations property. Further matching script parsing will result in subsequent breakpointResolved events issued. This logical breakpoint will survive page reloads.

Parameters:

Name Type Description Default
line_number int

Line number to set breakpoint at.

 required
url Optional[str]

(Optional) URL of the resources to set breakpoint on.

 None
url_regex Optional[str]

(Optional) Regex pattern for the URLs of the resources to set breakpoints on. Either url```` or ````urlRegex must be specified.

 None
script_hash Optional[str]

(Optional) Script hash of the resources to set breakpoint on.

 None
column_number Optional[int]

(Optional) Offset in the line to set breakpoint at.

 None
condition Optional[str]

(Optional) Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[BreakpointId, List[Location]]]

A tuple with the following items: 0. breakpointId - Id of the created breakpoint for further reference. 1. locations - List of the locations this breakpoint resolved into upon addition.
Source code in zendriver/cdp/debugger.py 
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
def set_breakpoint_by_url(
    line_number: int,
    url: typing.Optional[str] = None,
    url_regex: typing.Optional[str] = None,
    script_hash: typing.Optional[str] = None,
    column_number: typing.Optional[int] = None,
    condition: typing.Optional[str] = None,
) -> typing.Generator[
    T_JSON_DICT, T_JSON_DICT, typing.Tuple[BreakpointId, typing.List[Location]]
]:
    """
    Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this
    command is issued, all existing parsed scripts will have breakpoints resolved and returned in
    ``locations`` property. Further matching script parsing will result in subsequent
    ``breakpointResolved`` events issued. This logical breakpoint will survive page reloads.

    :param line_number: Line number to set breakpoint at.
    :param url: *(Optional)* URL of the resources to set breakpoint on.
    :param url_regex: *(Optional)* Regex pattern for the URLs of the resources to set breakpoints on. Either ```url```` or ````urlRegex``` must be specified.
    :param script_hash: *(Optional)* Script hash of the resources to set breakpoint on.
    :param column_number: *(Optional)* Offset in the line to set breakpoint at.
    :param condition: *(Optional)* Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
    :returns: A tuple with the following items:

        0. **breakpointId** - Id of the created breakpoint for further reference.
        1. **locations** - List of the locations this breakpoint resolved into upon addition.
    """
    params: T_JSON_DICT = dict()
    params["lineNumber"] = line_number
    if url is not None:
        params["url"] = url
    if url_regex is not None:
        params["urlRegex"] = url_regex
    if script_hash is not None:
        params["scriptHash"] = script_hash
    if column_number is not None:
        params["columnNumber"] = column_number
    if condition is not None:
        params["condition"] = condition
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setBreakpointByUrl",
        "params": params,
    }
    json = yield cmd_dict
    return (
        BreakpointId.from_json(json["breakpointId"]),
        [Location.from_json(i) for i in json["locations"]],
    )

set_breakpoint_on_function_call(object_id, condition=None)

Sets JavaScript breakpoint before each call to the given function. If another function was created from the same source as a given one, calling it will also trigger the breakpoint.

EXPERIMENTAL

Parameters:

Name Type Description Default
object_id RemoteObjectId

Function object id.

 required
condition Optional[str]

(Optional) Expression to use as a breakpoint condition. When specified, debugger will stop on the breakpoint if this expression evaluates to true.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, BreakpointId]

Id of the created breakpoint for further reference.
Source code in zendriver/cdp/debugger.py 
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
def set_breakpoint_on_function_call(
    object_id: runtime.RemoteObjectId, condition: typing.Optional[str] = None
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, BreakpointId]:
    """
    Sets JavaScript breakpoint before each call to the given function.
    If another function was created from the same source as a given one,
    calling it will also trigger the breakpoint.

    **EXPERIMENTAL**

    :param object_id: Function object id.
    :param condition: *(Optional)* Expression to use as a breakpoint condition. When specified, debugger will stop on the breakpoint if this expression evaluates to true.
    :returns: Id of the created breakpoint for further reference.
    """
    params: T_JSON_DICT = dict()
    params["objectId"] = object_id.to_json()
    if condition is not None:
        params["condition"] = condition
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setBreakpointOnFunctionCall",
        "params": params,
    }
    json = yield cmd_dict
    return BreakpointId.from_json(json["breakpointId"])

set_breakpoints_active(active)

Activates / deactivates all breakpoints on the page.

Parameters:

Name Type Description Default
active bool

New value for breakpoints active state.

 required
Source code in zendriver/cdp/debugger.py 
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
def set_breakpoints_active(
    active: bool,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Activates / deactivates all breakpoints on the page.

    :param active: New value for breakpoints active state.
    """
    params: T_JSON_DICT = dict()
    params["active"] = active
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setBreakpointsActive",
        "params": params,
    }
    json = yield cmd_dict

set_instrumentation_breakpoint(instrumentation)

Sets instrumentation breakpoint.

Parameters:

Name Type Description Default
instrumentation str

Instrumentation name.

 required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, BreakpointId]

Id of the created breakpoint for further reference.
Source code in zendriver/cdp/debugger.py 
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
def set_instrumentation_breakpoint(
    instrumentation: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, BreakpointId]:
    """
    Sets instrumentation breakpoint.

    :param instrumentation: Instrumentation name.
    :returns: Id of the created breakpoint for further reference.
    """
    params: T_JSON_DICT = dict()
    params["instrumentation"] = instrumentation
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setInstrumentationBreakpoint",
        "params": params,
    }
    json = yield cmd_dict
    return BreakpointId.from_json(json["breakpointId"])

set_pause_on_exceptions(state)

Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions, or caught exceptions, no exceptions. Initial pause on exceptions state is none.

Parameters:

Name Type Description Default
state str

Pause on exceptions mode.

 required
Source code in zendriver/cdp/debugger.py 
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
def set_pause_on_exceptions(
    state: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions,
    or caught exceptions, no exceptions. Initial pause on exceptions state is ``none``.

    :param state: Pause on exceptions mode.
    """
    params: T_JSON_DICT = dict()
    params["state"] = state
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setPauseOnExceptions",
        "params": params,
    }
    json = yield cmd_dict

set_return_value(new_value)

Changes return value in top frame. Available only at return break position.

EXPERIMENTAL

Parameters:

Name Type Description Default
new_value CallArgument

New return value.

 required
Source code in zendriver/cdp/debugger.py 
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
def set_return_value(
    new_value: runtime.CallArgument,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Changes return value in top frame. Available only at return break position.

    **EXPERIMENTAL**

    :param new_value: New return value.
    """
    params: T_JSON_DICT = dict()
    params["newValue"] = new_value.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setReturnValue",
        "params": params,
    }
    json = yield cmd_dict

set_script_source(script_id, script_source, dry_run=None, allow_top_frame_editing=None)

Edits JavaScript source live.

In general, functions that are currently on the stack can not be edited with a single exception: If the edited function is the top-most stack frame and that is the only activation of that function on the stack. In this case the live edit will be successful and a Debugger.restartFrame for the top-most function is automatically triggered.

Parameters:

Name Type Description Default
script_id ScriptId

Id of the script to edit.

 required
script_source str

New content of the script.

 required
dry_run Optional[bool]

(Optional) If true the change will not actually be applied. Dry run may be used to get result description without actually modifying the code.

 None
allow_top_frame_editing Optional[bool]

(EXPERIMENTAL) (Optional) If true, then ```scriptSource```` is allowed to change the function on top of the stack as long as the top-most stack frame is the only activation of that function.

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[Optional[List[CallFrame]], Optional[bool], Optional[StackTrace], Optional[StackTraceId], str, Optional[ExceptionDetails]]]

A tuple with the following items: 0. callFrames - (Optional) New stack trace in case editing has happened while VM was stopped. 1. stackChanged - (Optional) Whether current call stack was modified after applying the changes. 2. asyncStackTrace - (Optional) Async stack trace, if any. 3. asyncStackTraceId - (Optional) Async stack trace, if any. 4. status - Whether the operation was successful or not. Only Ok denotes a successful live edit while the other enum variants denote why the live edit failed. 5. exceptionDetails - (Optional) Exception details if any. Only present when status is ` CompileError.
Source code in zendriver/cdp/debugger.py 
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
def set_script_source(
    script_id: runtime.ScriptId,
    script_source: str,
    dry_run: typing.Optional[bool] = None,
    allow_top_frame_editing: typing.Optional[bool] = None,
) -> typing.Generator[
    T_JSON_DICT,
    T_JSON_DICT,
    typing.Tuple[
        typing.Optional[typing.List[CallFrame]],
        typing.Optional[bool],
        typing.Optional[runtime.StackTrace],
        typing.Optional[runtime.StackTraceId],
        str,
        typing.Optional[runtime.ExceptionDetails],
    ],
]:
    """
    Edits JavaScript source live.

    In general, functions that are currently on the stack can not be edited with
    a single exception: If the edited function is the top-most stack frame and
    that is the only activation of that function on the stack. In this case
    the live edit will be successful and a ``Debugger.restartFrame`` for the
    top-most function is automatically triggered.

    :param script_id: Id of the script to edit.
    :param script_source: New content of the script.
    :param dry_run: *(Optional)* If true the change will not actually be applied. Dry run may be used to get result description without actually modifying the code.
    :param allow_top_frame_editing: **(EXPERIMENTAL)** *(Optional)* If true, then ```scriptSource```` is allowed to change the function on top of the stack as long as the top-most stack frame is the only activation of that function.
    :returns: A tuple with the following items:

        0. **callFrames** - *(Optional)* New stack trace in case editing has happened while VM was stopped.
        1. **stackChanged** - *(Optional)* Whether current call stack  was modified after applying the changes.
        2. **asyncStackTrace** - *(Optional)* Async stack trace, if any.
        3. **asyncStackTraceId** - *(Optional)* Async stack trace, if any.
        4. **status** - Whether the operation was successful or not. Only `` Ok`` denotes a successful live edit while the other enum variants denote why the live edit failed.
        5. **exceptionDetails** - *(Optional)* Exception details if any. Only present when `` status`` is `` CompileError`.
    """
    params: T_JSON_DICT = dict()
    params["scriptId"] = script_id.to_json()
    params["scriptSource"] = script_source
    if dry_run is not None:
        params["dryRun"] = dry_run
    if allow_top_frame_editing is not None:
        params["allowTopFrameEditing"] = allow_top_frame_editing
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setScriptSource",
        "params": params,
    }
    json = yield cmd_dict
    return (
        (
            [CallFrame.from_json(i) for i in json["callFrames"]]
            if json.get("callFrames", None) is not None
            else None
        ),
        (
            bool(json["stackChanged"])
            if json.get("stackChanged", None) is not None
            else None
        ),
        (
            runtime.StackTrace.from_json(json["asyncStackTrace"])
            if json.get("asyncStackTrace", None) is not None
            else None
        ),
        (
            runtime.StackTraceId.from_json(json["asyncStackTraceId"])
            if json.get("asyncStackTraceId", None) is not None
            else None
        ),
        str(json["status"]),
        (
            runtime.ExceptionDetails.from_json(json["exceptionDetails"])
            if json.get("exceptionDetails", None) is not None
            else None
        ),
    )

set_skip_all_pauses(skip)

Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).

Parameters:

Name Type Description Default
skip bool

New value for skip pauses state.

 required
Source code in zendriver/cdp/debugger.py 
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
def set_skip_all_pauses(skip: bool) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).

    :param skip: New value for skip pauses state.
    """
    params: T_JSON_DICT = dict()
    params["skip"] = skip
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setSkipAllPauses",
        "params": params,
    }
    json = yield cmd_dict

set_variable_value(scope_number, variable_name, new_value, call_frame_id)

Changes value of variable in a callframe. Object-based scopes are not supported and must be mutated manually.

Parameters:

Name Type Description Default
scope_number int

0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch' scope types are allowed. Other scopes could be manipulated manually.

 required
variable_name str

Variable name.

 required
new_value CallArgument

New variable value.

 required
call_frame_id CallFrameId

Id of callframe that holds variable.

 required
Source code in zendriver/cdp/debugger.py 
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
def set_variable_value(
    scope_number: int,
    variable_name: str,
    new_value: runtime.CallArgument,
    call_frame_id: CallFrameId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Changes value of variable in a callframe. Object-based scopes are not supported and must be
    mutated manually.

    :param scope_number: 0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch' scope types are allowed. Other scopes could be manipulated manually.
    :param variable_name: Variable name.
    :param new_value: New variable value.
    :param call_frame_id: Id of callframe that holds variable.
    """
    params: T_JSON_DICT = dict()
    params["scopeNumber"] = scope_number
    params["variableName"] = variable_name
    params["newValue"] = new_value.to_json()
    params["callFrameId"] = call_frame_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.setVariableValue",
        "params": params,
    }
    json = yield cmd_dict

step_into(break_on_async_call=None, skip_list=None)

Steps into the function call.

Parameters:

Name Type Description Default
break_on_async_call Optional[bool]

(EXPERIMENTAL) (Optional) Debugger will pause on the execution of the first async task which was scheduled before next pause.

 None
skip_list Optional[List[LocationRange]]

(EXPERIMENTAL) (Optional) The skipList specifies location ranges that should be skipped on step into.

 None
Source code in zendriver/cdp/debugger.py 
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
def step_into(
    break_on_async_call: typing.Optional[bool] = None,
    skip_list: typing.Optional[typing.List[LocationRange]] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Steps into the function call.

    :param break_on_async_call: **(EXPERIMENTAL)** *(Optional)* Debugger will pause on the execution of the first async task which was scheduled before next pause.
    :param skip_list: **(EXPERIMENTAL)** *(Optional)* The skipList specifies location ranges that should be skipped on step into.
    """
    params: T_JSON_DICT = dict()
    if break_on_async_call is not None:
        params["breakOnAsyncCall"] = break_on_async_call
    if skip_list is not None:
        params["skipList"] = [i.to_json() for i in skip_list]
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.stepInto",
        "params": params,
    }
    json = yield cmd_dict

step_out()

Steps out of the function call.

Source code in zendriver/cdp/debugger.py 
1215
1216
1217
1218
1219
1220
1221
1222
def step_out() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Steps out of the function call.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.stepOut",
    }
    json = yield cmd_dict

step_over(skip_list=None)

Steps over the statement.

Parameters:

Name Type Description Default
skip_list Optional[List[LocationRange]]

(EXPERIMENTAL) (Optional) The skipList specifies location ranges that should be skipped on step over.

 None
Source code in zendriver/cdp/debugger.py 
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
def step_over(
    skip_list: typing.Optional[typing.List[LocationRange]] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Steps over the statement.

    :param skip_list: **(EXPERIMENTAL)** *(Optional)* The skipList specifies location ranges that should be skipped on step over.
    """
    params: T_JSON_DICT = dict()
    if skip_list is not None:
        params["skipList"] = [i.to_json() for i in skip_list]
    cmd_dict: T_JSON_DICT = {
        "method": "Debugger.stepOver",
        "params": params,
    }
    json = yield cmd_dict