chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/io/methods/service.py

@@ -0,0 +1,54 @@
+"""CDP IO Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class IOMethods:
+    """
+    Methods for the IO domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the IO methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def close(self, params: Optional[closeParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Close the stream, discard any temporary backing storage.    
+        Args:
+            params (closeParameters, optional): Parameters for the close method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the close call.
+        """
+        return await self.client.send(method="IO.close", params=params,session_id=session_id)
+    async def read(self, params: Optional[readParameters]=None,session_id: Optional[str] = None) -> readReturns:
+        """
+    Read a chunk of the stream    
+        Args:
+            params (readParameters, optional): Parameters for the read method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    readReturns: The result of the read call.
+        """
+        return await self.client.send(method="IO.read", params=params,session_id=session_id)
+    async def resolve_blob(self, params: Optional[resolveBlobParameters]=None,session_id: Optional[str] = None) -> resolveBlobReturns:
+        """
+    Return UUID of Blob object specified by a remote object id.    
+        Args:
+            params (resolveBlobParameters, optional): Parameters for the resolveBlob method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    resolveBlobReturns: The result of the resolveBlob call.
+        """
+        return await self.client.send(method="IO.resolveBlob", params=params,session_id=session_id)

cdp/protocol/io/methods/types.py

@@ -0,0 +1,33 @@
+"""CDP IO Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.io.types import StreamHandle
+    from cdp.protocol.runtime.types import RemoteObjectId
+
+class closeParameters(TypedDict, total=True):
+    handle: 'StreamHandle'
+    """Handle of the stream to close."""
+class readParameters(TypedDict, total=True):
+    handle: 'StreamHandle'
+    """Handle of the stream to read."""
+    offset: NotRequired['int']
+    """Seek to the specified offset before reading (if not specified, proceed with offset following the last read). Some types of streams may only support sequential reads."""
+    size: NotRequired['int']
+    """Maximum number of bytes to read (left upon the agent discretion if not specified)."""
+class resolveBlobParameters(TypedDict, total=True):
+    objectId: 'RemoteObjectId'
+    """Object id of a Blob object wrapper."""
+
+class readReturns(TypedDict):
+    base64Encoded: 'bool'
+    """Set if the data is base64-encoded"""
+    data: 'str'
+    """Data that were read."""
+    eof: 'bool'
+    """Set if the end-of-file condition occurred while reading."""
+class resolveBlobReturns(TypedDict):
+    uuid: 'str'
+    """UUID of the specified Blob."""

cdp/protocol/io/service.py

@@ -0,0 +1,21 @@
+"""CDP IO Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import IOMethods
+from .events.service import IOEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class IO(IOMethods, IOEvents):
+    """
+    Input/Output operations for streams produced by DevTools.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the IO domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        IOMethods.__init__(self, client)
+        IOEvents.__init__(self, client)

cdp/protocol/io/types.py

@@ -0,0 +1,6 @@
+"""CDP IO Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+StreamHandle = str
+"""This is either obtained from another method or specified as blob:<uuid> where <uuid> is an UUID of a Blob."""

cdp/protocol/layer_tree/events/service.py

@@ -0,0 +1,37 @@
+"""CDP LayerTree Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class LayerTreeEvents:
+    """
+    Events for the LayerTree domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the LayerTree events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_layer_painted(self, callback: Callable[[layerPaintedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for layerPainted.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: layerPaintedEvent, session_id: Optional[str]).
+        """
+        self.client.on('LayerTree.layerPainted', callback)
+    def on_layer_tree_did_change(self, callback: Callable[[layerTreeDidChangeEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for layerTreeDidChange.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: layerTreeDidChangeEvent, session_id: Optional[str]).
+        """
+        self.client.on('LayerTree.layerTreeDidChange', callback)

cdp/protocol/layer_tree/events/types.py

@@ -0,0 +1,18 @@
+"""CDP LayerTree Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import Rect
+    from cdp.protocol.layer_tree.types import Layer
+    from cdp.protocol.layer_tree.types import LayerId
+
+class layerPaintedEvent(TypedDict, total=True):
+    layerId: 'LayerId'
+    """The id of the painted layer."""
+    clip: 'Rect'
+    """Clip rectangle."""
+class layerTreeDidChangeEvent(TypedDict, total=False):
+    layers: NotRequired['List[Layer]']
+    """Layer tree, absent if not in the compositing mode."""

cdp/protocol/layer_tree/methods/service.py

@@ -0,0 +1,120 @@
+"""CDP LayerTree Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class LayerTreeMethods:
+    """
+    Methods for the LayerTree domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the LayerTree methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def compositing_reasons(self, params: Optional[compositingReasonsParameters]=None,session_id: Optional[str] = None) -> compositingReasonsReturns:
+        """
+    Provides the reasons why the given layer was composited.    
+        Args:
+            params (compositingReasonsParameters, optional): Parameters for the compositingReasons method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    compositingReasonsReturns: The result of the compositingReasons call.
+        """
+        return await self.client.send(method="LayerTree.compositingReasons", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables compositing tree inspection.    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="LayerTree.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables compositing tree inspection.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="LayerTree.enable", params=params,session_id=session_id)
+    async def load_snapshot(self, params: Optional[loadSnapshotParameters]=None,session_id: Optional[str] = None) -> loadSnapshotReturns:
+        """
+    Returns the snapshot identifier.    
+        Args:
+            params (loadSnapshotParameters, optional): Parameters for the loadSnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    loadSnapshotReturns: The result of the loadSnapshot call.
+        """
+        return await self.client.send(method="LayerTree.loadSnapshot", params=params,session_id=session_id)
+    async def make_snapshot(self, params: Optional[makeSnapshotParameters]=None,session_id: Optional[str] = None) -> makeSnapshotReturns:
+        """
+    Returns the layer snapshot identifier.    
+        Args:
+            params (makeSnapshotParameters, optional): Parameters for the makeSnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    makeSnapshotReturns: The result of the makeSnapshot call.
+        """
+        return await self.client.send(method="LayerTree.makeSnapshot", params=params,session_id=session_id)
+    async def profile_snapshot(self, params: Optional[profileSnapshotParameters]=None,session_id: Optional[str] = None) -> profileSnapshotReturns:
+        """
+    No description available for profileSnapshot.    
+        Args:
+            params (profileSnapshotParameters, optional): Parameters for the profileSnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    profileSnapshotReturns: The result of the profileSnapshot call.
+        """
+        return await self.client.send(method="LayerTree.profileSnapshot", params=params,session_id=session_id)
+    async def release_snapshot(self, params: Optional[releaseSnapshotParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Releases layer snapshot captured by the back-end.    
+        Args:
+            params (releaseSnapshotParameters, optional): Parameters for the releaseSnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the releaseSnapshot call.
+        """
+        return await self.client.send(method="LayerTree.releaseSnapshot", params=params,session_id=session_id)
+    async def replay_snapshot(self, params: Optional[replaySnapshotParameters]=None,session_id: Optional[str] = None) -> replaySnapshotReturns:
+        """
+    Replays the layer snapshot and returns the resulting bitmap.    
+        Args:
+            params (replaySnapshotParameters, optional): Parameters for the replaySnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    replaySnapshotReturns: The result of the replaySnapshot call.
+        """
+        return await self.client.send(method="LayerTree.replaySnapshot", params=params,session_id=session_id)
+    async def snapshot_command_log(self, params: Optional[snapshotCommandLogParameters]=None,session_id: Optional[str] = None) -> snapshotCommandLogReturns:
+        """
+    Replays the layer snapshot and returns canvas log.    
+        Args:
+            params (snapshotCommandLogParameters, optional): Parameters for the snapshotCommandLog method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    snapshotCommandLogReturns: The result of the snapshotCommandLog call.
+        """
+        return await self.client.send(method="LayerTree.snapshotCommandLog", params=params,session_id=session_id)

cdp/protocol/layer_tree/methods/types.py

@@ -0,0 +1,70 @@
+"""CDP LayerTree Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import Rect
+    from cdp.protocol.layer_tree.types import LayerId
+    from cdp.protocol.layer_tree.types import PaintProfile
+    from cdp.protocol.layer_tree.types import PictureTile
+    from cdp.protocol.layer_tree.types import SnapshotId
+
+class compositingReasonsParameters(TypedDict, total=True):
+    layerId: 'LayerId'
+    """The id of the layer for which we want to get the reasons it was composited."""
+
+
+class loadSnapshotParameters(TypedDict, total=True):
+    tiles: 'List[PictureTile]'
+    """An array of tiles composing the snapshot."""
+class makeSnapshotParameters(TypedDict, total=True):
+    layerId: 'LayerId'
+    """The id of the layer."""
+class profileSnapshotParameters(TypedDict, total=True):
+    snapshotId: 'SnapshotId'
+    """The id of the layer snapshot."""
+    minRepeatCount: NotRequired['int']
+    """The maximum number of times to replay the snapshot (1, if not specified)."""
+    minDuration: NotRequired['float']
+    """The minimum duration (in seconds) to replay the snapshot."""
+    clipRect: NotRequired['Rect']
+    """The clip rectangle to apply when replaying the snapshot."""
+class releaseSnapshotParameters(TypedDict, total=True):
+    snapshotId: 'SnapshotId'
+    """The id of the layer snapshot."""
+class replaySnapshotParameters(TypedDict, total=True):
+    snapshotId: 'SnapshotId'
+    """The id of the layer snapshot."""
+    fromStep: NotRequired['int']
+    """The first step to replay from (replay from the very start if not specified)."""
+    toStep: NotRequired['int']
+    """The last step to replay to (replay till the end if not specified)."""
+    scale: NotRequired['float']
+    """The scale to apply while replaying (defaults to 1)."""
+class snapshotCommandLogParameters(TypedDict, total=True):
+    snapshotId: 'SnapshotId'
+    """The id of the layer snapshot."""
+class compositingReasonsReturns(TypedDict):
+    compositingReasons: 'List[str]'
+    """A list of strings specifying reasons for the given layer to become composited."""
+    compositingReasonIds: 'List[str]'
+    """A list of strings specifying reason IDs for the given layer to become composited."""
+
+
+class loadSnapshotReturns(TypedDict):
+    snapshotId: 'SnapshotId'
+    """The id of the snapshot."""
+class makeSnapshotReturns(TypedDict):
+    snapshotId: 'SnapshotId'
+    """The id of the layer snapshot."""
+class profileSnapshotReturns(TypedDict):
+    timings: 'List[PaintProfile]'
+    """The array of paint profiles, one per run."""
+
+class replaySnapshotReturns(TypedDict):
+    dataURL: 'str'
+    """A data: URL for resulting image."""
+class snapshotCommandLogReturns(TypedDict):
+    commandLog: 'List[Dict[str, Any]]'
+    """The array of canvas function calls."""

cdp/protocol/layer_tree/service.py

@@ -0,0 +1,21 @@
+"""CDP LayerTree Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import LayerTreeMethods
+from .events.service import LayerTreeEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class LayerTree(LayerTreeMethods, LayerTreeEvents):
+    """
+    Access the LayerTree domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the LayerTree domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        LayerTreeMethods.__init__(self, client)
+        LayerTreeEvents.__init__(self, client)

cdp/protocol/layer_tree/types.py

@@ -0,0 +1,73 @@
+"""CDP LayerTree Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import BackendNodeId
+    from cdp.protocol.dom.types import Rect
+
+LayerId = str
+"""Unique Layer identifier."""
+SnapshotId = str
+"""Unique snapshot identifier."""
+class ScrollRect(TypedDict, total=True):
+    """Rectangle where scrolling happens on the main thread."""
+    rect: 'Rect'
+    """Rectangle itself."""
+    type: 'Literal["RepaintsOnScroll", "TouchEventHandler", "WheelEventHandler"]'
+    """Reason for rectangle to force scrolling on the main thread"""
+class StickyPositionConstraint(TypedDict, total=True):
+    """Sticky position constraints."""
+    stickyBoxRect: 'Rect'
+    """Layout rectangle of the sticky element before being shifted"""
+    containingBlockRect: 'Rect'
+    """Layout rectangle of the containing block of the sticky element"""
+    nearestLayerShiftingStickyBox: NotRequired['LayerId']
+    """The nearest sticky layer that shifts the sticky box"""
+    nearestLayerShiftingContainingBlock: NotRequired['LayerId']
+    """The nearest sticky layer that shifts the containing block"""
+class PictureTile(TypedDict, total=True):
+    """Serialized fragment of layer picture along with its offset within the layer."""
+    x: 'float'
+    """Offset from owning layer left boundary"""
+    y: 'float'
+    """Offset from owning layer top boundary"""
+    picture: 'str'
+    """Base64-encoded snapshot data. (Encoded as a base64 string when passed over JSON)"""
+class Layer(TypedDict, total=True):
+    """Information about a compositing layer."""
+    layerId: 'LayerId'
+    """The unique id for this layer."""
+    offsetX: 'float'
+    """Offset from parent layer, X coordinate."""
+    offsetY: 'float'
+    """Offset from parent layer, Y coordinate."""
+    width: 'float'
+    """Layer width."""
+    height: 'float'
+    """Layer height."""
+    paintCount: 'int'
+    """Indicates how many time this layer has painted."""
+    drawsContent: 'bool'
+    """Indicates whether this layer hosts any content, rather than being used for transform/scrolling purposes only."""
+    parentLayerId: NotRequired['LayerId']
+    """The id of parent (not present for root)."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """The backend id for the node associated with this layer."""
+    transform: NotRequired['List[float]']
+    """Transformation matrix for layer, default is identity matrix"""
+    anchorX: NotRequired['float']
+    """Transform anchor point X, absent if no transform specified"""
+    anchorY: NotRequired['float']
+    """Transform anchor point Y, absent if no transform specified"""
+    anchorZ: NotRequired['float']
+    """Transform anchor point Z, absent if no transform specified"""
+    invisible: NotRequired['bool']
+    """Set if layer is not visible."""
+    scrollRects: NotRequired['List[ScrollRect]']
+    """Rectangles scrolling on main thread only."""
+    stickyPositionConstraint: NotRequired['StickyPositionConstraint']
+    """Sticky position constraint information"""
+PaintProfile = List['float']
+"""Array of timings, one per paint step."""

cdp/protocol/log/events/service.py

@@ -0,0 +1,29 @@
+"""CDP Log Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class LogEvents:
+    """
+    Events for the Log domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Log events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_entry_added(self, callback: Callable[[entryAddedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when new message was logged.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: entryAddedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Log.entryAdded', callback)

cdp/protocol/log/events/types.py

@@ -0,0 +1,11 @@
+"""CDP Log Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.log.types import LogEntry
+
+class entryAddedEvent(TypedDict, total=True):
+    entry: 'LogEntry'
+    """The entry."""

cdp/protocol/log/methods/service.py

@@ -0,0 +1,76 @@
+"""CDP Log Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class LogMethods:
+    """
+    Methods for the Log domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Log methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def clear(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears the log.    
+        Args:
+            params (None, optional): Parameters for the clear method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clear call.
+        """
+        return await self.client.send(method="Log.clear", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables log domain, prevents further log entries from being reported to the client.    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="Log.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables log domain, sends the entries collected so far to the client by means of the `entryAdded` notification.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="Log.enable", params=params,session_id=session_id)
+    async def start_violations_report(self, params: Optional[startViolationsReportParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    start violation reporting.    
+        Args:
+            params (startViolationsReportParameters, optional): Parameters for the startViolationsReport method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startViolationsReport call.
+        """
+        return await self.client.send(method="Log.startViolationsReport", params=params,session_id=session_id)
+    async def stop_violations_report(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Stop violation reporting.    
+        Args:
+            params (None, optional): Parameters for the stopViolationsReport method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopViolationsReport call.
+        """
+        return await self.client.send(method="Log.stopViolationsReport", params=params,session_id=session_id)

cdp/protocol/log/methods/types.py

@@ -0,0 +1,14 @@
+"""CDP Log Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.log.types import ViolationSetting
+
+
+
+
+class startViolationsReportParameters(TypedDict, total=True):
+    config: 'List[ViolationSetting]'
+    """Configuration for violations."""

cdp/protocol/log/service.py

@@ -0,0 +1,21 @@
+"""CDP Log Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import LogMethods
+from .events.service import LogEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Log(LogMethods, LogEvents):
+    """
+    Provides access to log entries.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Log domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        LogMethods.__init__(self, client)
+        LogEvents.__init__(self, client)