scratchattach 2.1.14__py3-none-any.whl → 3.0.0b0__py3-none-any.whl

scratchattach/__init__.py

@@ -8,22 +8,30 @@ from .eventhandlers.cloud_storage import Database
 from .eventhandlers.combine import MultiEventHandler
 
 from .other.other_apis import *
-from .other.project_json_capabilities import ProjectBody, get_empty_project_pb, get_pb_from_dict, read_sb3_file, download_asset
+# from .other.project_json_capabilities import ProjectBody, get_empty_project_pb, get_pb_from_dict, read_sb3_file, download_asset
 from .utils.encoder import Encoding
 from .utils.enums import Languages, TTSVoices
-from .utils.exceptions import LoginDataWarning
+from .utils.exceptions import (
+    LoginDataWarning,
+    GetAuthenticationWarning,
+    StudioAuthenticationWarning,
+    ClassroomAuthenticationWarning,
+    ProjectAuthenticationWarning,
+    UserAuthenticationWarning)
 
-from .site.activity import Activity
+from .site.activity import Activity, ActivityTypes
 from .site.backpack_asset import BackpackAsset
-from .site.comment import Comment
+from .site.comment import Comment, CommentSource
 from .site.cloud_activity import CloudActivity
 from .site.forum import ForumPost, ForumTopic, get_topic, get_topic_list, youtube_link_to_scratch
 from .site.project import Project, get_project, search_projects, explore_projects
-from .site.session import Session, login, login_by_id, login_by_session_string, login_by_io, login_by_file, login_from_browser
+from .site.session import Session, login, login_by_id, login_by_session_string, login_by_io, login_by_file, \
+    login_from_browser
 from .site.studio import Studio, get_studio, search_studios, explore_studios
 from .site.classroom import Classroom, get_classroom
-from .site.user import User, get_user
+from .site.user import User, get_user, Rank
 from .site._base import BaseSiteComponent
 from .site.browser_cookies import Browser, ANY, FIREFOX, CHROME, CHROMIUM, VIVALDI, EDGE, EDGE_DEV, SAFARI
+from .site.placeholder import PlaceholderProject, get_placeholder_project, create_placeholder_project
 
 from . import editor

scratchattach/__main__.py

@@ -0,0 +1,93 @@
+"""
+Scratchattach CLI. Most source code is in the `cli` directory
+"""
+
+import argparse
+
+from scratchattach import cli
+from scratchattach.cli import db, cmd
+from scratchattach.cli.context import ctx, console
+
+import rich.traceback
+
+rich.traceback.install()
+
+
+# noinspection PyUnusedLocal
+def main():
+    parser = argparse.ArgumentParser(
+        prog="scratch",
+        description="Scratchattach CLI",
+        epilog=f"Running scratchattach CLI version {cli.VERSION}",
+    )
+
+    # Using walrus operator & ifs for artificial indentation
+    if commands := parser.add_subparsers(dest="command"):
+        commands.add_parser("profile", help="View your profile")
+        commands.add_parser("sessions", help="View session list")
+        if login := commands.add_parser("login", help="Login to Scratch"):
+            login.add_argument("--sessid", dest="sessid", nargs="?", default=False, const=True,
+                               help="Login by session ID")
+        if group := commands.add_parser("group", help="View current session group"):
+            if group_commands := group.add_subparsers(dest="group_command"):
+                group_commands.add_parser("list", help="List all session groups")
+                group_commands.add_parser("add", help="Add sessions to group")
+                group_commands.add_parser("remove", help="Remove sessions from a group")
+                group_commands.add_parser("delete", help="Delete current group")
+                if group_copy := group_commands.add_parser("copy", help="Copy current group with a new name"):
+                    group_copy.add_argument("group_name", help="New group name")
+                if group_rename := group_commands.add_parser("rename", help="Rename current group"):
+                    group_rename.add_argument("group_name", help="New group name")
+                if group_new := group_commands.add_parser("new", help="Create a new group"):
+                    group_new.add_argument("group_name")
+                if group_switch := group_commands.add_parser("switch", help="Change the current group"):
+                    group_switch.add_argument("group_name")
+
+    parser.add_argument("-U", "--username", dest="username", help="Name of user to look at")
+    parser.add_argument("-P", "--project", dest="project_id", help="ID of project to look at")
+    parser.add_argument("-S", "--studio", dest="studio_id", help="ID of studio to look at")
+    parser.add_argument("-L", "--session_name", dest="session_name",
+                        help="Name of (registered) session/login to look at")
+
+    args = parser.parse_args(namespace=cli.ArgSpace())
+    cli.ctx.args = args
+    cli.ctx.parser = parser
+
+    match args.command:
+        case "sessions":
+            cmd.sessions()
+        case "login":
+            cmd.login()
+        case "group":
+            cmd.group()
+        case "profile":
+            cmd.profile()
+        case None:
+            if args.username:
+                user = ctx.session.connect_user(args.username)
+                console.print(cli.try_get_img(user.icon, (30, 30)))
+                console.print(user)
+                return
+            if args.studio_id:
+                studio = ctx.session.connect_studio(args.studio_id)
+                console.print(cli.try_get_img(studio.thumbnail, (34, 20)))
+                console.print(studio)
+                return
+            if args.project_id:
+                project = ctx.session.connect_project(args.project_id)
+                console.print(cli.try_get_img(project.thumbnail, (30, 23)))
+                console.print(project)
+                return
+            if args.session_name:
+                if sess := ctx.db_get_sess(args.session_name):
+                    console.print(sess)
+                else:
+                    raise ValueError(f"No session logged in called {args.session_name!r} "
+                                     f"- try using `scratch sessions` to see available sessions")
+                return
+
+            parser.print_help()
+
+
+if __name__ == '__main__':
+    main()

{scratchattach-2.1.14.dist-info → scratchattach-3.0.0b0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: scratchattach
-Version: 2.1.14
+Version: 3.0.0b0
 Summary: A Scratch API Wrapper
 Author: TimMcCool
-Author-email: 
+License-Expression: MIT
 Project-URL: Source, https://github.com/timmccool/scratchattach
 Project-URL: Homepage, https://scratchattach.tim1de.net
 Keywords: scratch api,scratchattach,scratch api python,scratch python,scratch for python,scratch,scratch cloud,scratch cloud variables,scratch bot
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websocket-client
@@ -21,18 +22,13 @@ Requires-Dist: bs4
 Requires-Dist: SimpleWebSocketServer
 Requires-Dist: typing-extensions
 Requires-Dist: browser_cookie3
+Requires-Dist: aiohttp
+Requires-Dist: rich
+Provides-Extra: cli
+Requires-Dist: rich-pixels; extra == "cli"
 Provides-Extra: lark
 Requires-Dist: lark; extra == "lark"
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: keywords
 Dynamic: license-file
-Dynamic: project-url
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 **scratchattach is a Scratch API wrapper with support for almost all site features.** Created by [TimMcCool](https://scratch.mit.edu/users/TimMcCool/).
 

scratchattach-3.0.0b0.dist-info/RECORD

@@ -0,0 +1,8 @@
+scratchattach/__init__.py,sha256=K26DsJHYlj7atN0WVQOmtN7d1rNAnmLcO3ljA1UD1lc,1849
+scratchattach/__main__.py,sha256=K520LnmXe5WAlr8UZQE1Owrm8BDncy19QQ5GJ75V9FM,4054
+scratchattach-3.0.0b0.dist-info/licenses/LICENSE,sha256=1PRKLhZU4wYt5M-C9f7q0W3go3u_ojnZMNOdR3g3J-E,1080
+scratchattach-3.0.0b0.dist-info/METADATA,sha256=qapruF1xW-anLx5HiFgZ8B1k6oH_a1YcV2WHGRsU5PI,5633
+scratchattach-3.0.0b0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+scratchattach-3.0.0b0.dist-info/entry_points.txt,sha256=vNXuP05TQKEoIzmzmUzS7zbtSZx0p3JmeUW3QhNdYfg,56
+scratchattach-3.0.0b0.dist-info/top_level.txt,sha256=gIwCwW39ohXn0JlnvSzAjV7VtL3qPlRnHiRqBbxsEUE,14
+scratchattach-3.0.0b0.dist-info/RECORD,,

{scratchattach-2.1.14.dist-info → scratchattach-3.0.0b0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

scratchattach-3.0.0b0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scratch = scratchattach.__main__:main

scratchattach/cloud/__init__.py

@@ -1,2 +0,0 @@
-from .cloud import *
-from ._base import *

scratchattach/cloud/_base.py

@@ -1,458 +0,0 @@
-from __future__ import annotations
-
-import json
-import ssl
-import time
-from typing import Optional, Union, TypeVar, Generic, TYPE_CHECKING, Any
-from abc import ABC, abstractmethod, ABCMeta
-from threading import Lock
-from collections.abc import Iterator
-import warnings
-
-if TYPE_CHECKING:
-    from _typeshed import SupportsRead
-else:
-    T = TypeVar("T")
-    class SupportsRead(ABC, Generic[T]):
-        @abstractmethod
-        def read(self) -> T:
-            pass
-
-class SupportsClose(ABC):
-    @abstractmethod
-    def close(self) -> None:
-        pass
-
-import websocket
-
-from scratchattach.site import session
-from scratchattach.eventhandlers import cloud_recorder
-from scratchattach.utils import exceptions
-from scratchattach.eventhandlers.cloud_requests import CloudRequests
-from scratchattach.eventhandlers.cloud_events import CloudEvents
-from scratchattach.eventhandlers.cloud_storage import CloudStorage
-from scratchattach.site import cloud_activity
-
-T = TypeVar("T")
-
-class EventStream(SupportsRead[Iterator[dict[str, Any]]], SupportsClose):
-    """
-    Allows you to stream events
-    """
-
-class AnyCloud(ABC, Generic[T]):
-    """
-    Represents a cloud that is not necessarily using a websocket.
-    """
-    active_connection: bool
-    var_stets_since_first: int
-    _session: Optional[session.Session]
-    
-    @abstractmethod
-    def connect(self):
-        pass
-
-    @abstractmethod
-    def disconnect(self):
-        pass
-
-    def reconnect(self):
-        self.disconnect()
-        self.connect()
-        
-    @abstractmethod
-    def _enforce_ratelimit(self, *, n: int) -> None:
-        pass
-
-    @abstractmethod
-    def set_var(self, variable: str, value: T) -> None:
-        """
-        Sets a cloud variable.
-
-        Args:
-            variable (str): The name of the cloud variable that should be set (provided without the cloud emoji)
-            value (Any): The value the cloud variable should be set to
-        """
-
-    @abstractmethod
-    def set_vars(self, var_value_dict: dict[str, T], *, intelligent_waits: bool = True):
-        """
-        Sets multiple cloud variables at once (works for an unlimited amount of variables).
-
-        Args:
-            var_value_dict (dict): variable:value dictionary with the variables / values to set. The dict should like this: {"var1":"value1", "var2":"value2", ...}
-        
-        Kwargs:
-            intelligent_waits (boolean): When enabled, the method will automatically decide how long to wait before performing this cloud variable set, to make sure no rate limits are triggered
-        """
-
-    @abstractmethod
-    def get_var(self, var, *, recorder_initial_values={}) -> T:
-        pass
-
-    @abstractmethod
-    def get_all_vars(self, *, recorder_initial_values={}) -> dict[str, T]:
-        pass
-
-    def events(self) -> CloudEvents:
-        return CloudEvents(self)
-
-    def requests(self, *, no_packet_loss: bool = False, used_cloud_vars: list[str] = ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
-                 respond_order="receive", debug: bool = False) -> CloudRequests:
-        return CloudRequests(self, used_cloud_vars=used_cloud_vars, no_packet_loss=no_packet_loss,
-                             respond_order=respond_order, debug=debug)
-
-    def storage(self, *, no_packet_loss: bool = False, used_cloud_vars: list[str] = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]) -> CloudStorage:
-        return CloudStorage(self, used_cloud_vars=used_cloud_vars, no_packet_loss=no_packet_loss)
-    
-    @abstractmethod
-    def create_event_stream(self) -> EventStream:
-        pass
-
-class WebSocketEventStream(EventStream):
-    packets_left: list[Union[str, bytes]]
-    source_cloud: BaseCloud
-    reading: Lock
-    def __init__(self, cloud: BaseCloud):
-        super().__init__()
-        self.source_cloud = type(cloud)(project_id=cloud.project_id)
-        self.source_cloud._session = cloud._session
-        self.source_cloud.cookie = cloud.cookie
-        self.source_cloud.header = cloud.header
-        self.source_cloud.origin = cloud.origin
-        self.source_cloud.username = cloud.username
-        self.source_cloud.ws_timeout = None # No timeout -> allows continous listening
-        self.reading = Lock()
-        try:
-            self.source_cloud.connect()
-        except exceptions.CloudConnectionError:
-            warnings.warn("Initial cloud connection attempt failed, retrying...", exceptions.UnexpectedWebsocketEventWarning)
-        self.packets_left = []
-
-    def receive_new(self, non_blocking: bool = False):
-        if non_blocking:
-            self.source_cloud.websocket.settimeout(0)
-            try:
-                received = self.source_cloud.websocket.recv().splitlines()
-                self.packets_left.extend(received)
-            except Exception:
-                pass
-            return
-        self.source_cloud.websocket.settimeout(None)
-        received = self.source_cloud.websocket.recv().splitlines()
-        self.packets_left.extend(received)
-    
-    def read(self, amount: int = -1) -> Iterator[dict[str, Any]]:
-        i = 0
-        with self.reading:
-            try:
-                self.receive_new(amount != -1)
-                while (self.packets_left and amount == -1) or (amount != -1 and i < amount):
-                    if not self.packets_left and amount != -1:
-                        self.receive_new()
-                    yield json.loads(self.packets_left.pop(0))
-                    i += 1
-            except Exception:
-                self.source_cloud.reconnect()
-                self.receive_new(amount != -1)
-                while (self.packets_left and amount == -1) or (amount != -1 and i < amount):
-                    if not self.packets_left and amount != -1:
-                        self.receive_new()
-                    yield json.loads(self.packets_left.pop(0))
-                    i += 1
-    
-    def close(self) -> None:
-        self.source_cloud.disconnect()
-
-class BaseCloud(AnyCloud[Union[str, int]]):
-    """
-    Base class for a project's cloud variables. Represents a cloud.
-
-    When inheriting from this class, the __init__ function of the inherited class:
-    - must first call the constructor of the super class: super().__init__()
-    - must then set some attributes
-
-    Attributes that must be specified in the __init__ function a class inheriting from this one:
-        project_id: Project id of the cloud variables
-
-        cloud_host: URL of the websocket server ("wss://..." or "ws://...")
-
-    Attributes that can, but don't have to be specified in the __init__ function:
-
-        _session: Either None or a scratchattach.site.session.Session object. Defaults to None.
-
-        ws_shortterm_ratelimit: The wait time between cloud variable sets. Defaults to 0.1
-
-        ws_longterm_ratelimit: The amount of cloud variable set that can be performed long-term without ever getting ratelimited
-
-        allow_non_numeric: Whether non-numeric cloud variable values are allowed. Defaults to False
-
-        length_limit: Length limit for cloud variable values. Defaults to 100000
-
-        username: The username to send during handshake. Defaults to "scratchattach"
-
-        header: The header to send. Defaults to None
-
-        cookie: The cookie to send. Defaults to None
-
-        origin: The origin to send. Defaults to None
-
-        print_connect_messages: Whether to print a message on every connect to the cloud server. Defaults to False.
-    """
-    project_id: Optional[Union[str, int]]
-    cloud_host: str
-    ws_shortterm_ratelimit: float
-    ws_longterm_ratelimit: float
-    allow_non_numeric: bool
-    length_limit: int
-    username: str
-    header: Optional[dict]
-    cookie: Optional[dict]
-    origin: Optional[str]
-    print_connect_message: bool
-    ws_timeout: Optional[int]
-    websocket: websocket.WebSocket
-    event_stream: Optional[EventStream] = None
-
-    def __init__(self, *, project_id: Optional[Union[int, str]] = None, _session=None):
-
-        # Required internal attributes that every object representing a cloud needs to have (no matter what cloud is represented):
-        self._session = _session
-        self.active_connection = False #whether a connection to a cloud variable server is currently established
-
-        self.websocket = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
-        self.recorder = None  # A CloudRecorder object that records cloud activity for the values to be retrieved later,
-        # which will be saved in this attribute as soon as .get_var is called
-        self.first_var_set = 0
-        self.last_var_set = 0
-        self.var_stets_since_first = 0
-
-        # Set default values for attributes that save configurations specific to the represented cloud:
-        # (These attributes can be specifically in the constructors of classes inheriting from this base class)
-        self.ws_shortterm_ratelimit = 0.06667
-        self.ws_longterm_ratelimit = 0.1
-        self.ws_timeout = 3  # Timeout for send operations (after the timeout,
-        # the connection will be renewed and the operation will be retried 3 times)
-        self.allow_non_numeric = False
-        self.length_limit = 100000
-        self.username = "scratchattach"
-        self.header = None
-        self.cookie = None
-        self.origin = None
-        self.print_connect_message = False
-        
-        self.project_id = project_id
-
-    def _assert_auth(self):
-        if self._session is None:
-            raise exceptions.Unauthenticated(
-                "You need to use session.connect_cloud (NOT get_cloud) in order to perform this operation.")
-
-    def _send_packet(self, packet):
-        try:
-            self.websocket.send(json.dumps(packet) + "\n")
-        except Exception:
-            time.sleep(0.1)
-            self.connect()
-            time.sleep(0.1)
-            try:
-                self.websocket.send(json.dumps(packet) + "\n")
-            except Exception:
-                time.sleep(0.2)
-                self.connect()
-                time.sleep(0.2)
-                try:
-                    self.websocket.send(json.dumps(packet) + "\n")
-                except Exception:
-                    time.sleep(1.6)
-                    self.connect()
-                    time.sleep(1.4)
-                    try:
-                        self.websocket.send(json.dumps(packet) + "\n")
-                    except Exception:
-                        self.active_connection = False
-                        raise exceptions.CloudConnectionError(f"Sending packet failed three times in a row: {packet}")
-
-    def _send_packet_list(self, packet_list):
-        packet_string = "".join([json.dumps(packet) + "\n" for packet in packet_list])
-        try:
-            self.websocket.send(packet_string)
-        except Exception:
-            time.sleep(0.1)
-            self.connect()
-            time.sleep(0.1)
-            try:
-                self.websocket.send(packet_string)
-            except Exception:
-                time.sleep(0.2)
-                self.connect()
-                time.sleep(0.2)
-                try:
-                    self.websocket.send(packet_string)
-                except Exception:
-                    time.sleep(1.6)
-                    self.connect()
-                    time.sleep(1.4)
-                    try:
-                        self.websocket.send(packet_string)
-                    except Exception:
-                        self.active_connection = False
-                        raise exceptions.CloudConnectionError(
-                            f"Sending packet list failed four times in a row: {packet_list}")
-
-    def _handshake(self):
-        packet = {"method": "handshake", "user": self.username, "project_id": self.project_id}
-        self._send_packet(packet)
-
-    def connect(self):
-        self.websocket = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
-        self.websocket.connect(
-            self.cloud_host,
-            cookie=self.cookie,
-            origin=self.origin,
-            enable_multithread=True,
-            timeout=self.ws_timeout,
-            header=self.header
-        )
-        self._handshake()
-        self.active_connection = True
-        if self.print_connect_message:
-            print("Connected to cloud server ", self.cloud_host)
-
-    def disconnect(self):
-        self.active_connection = False
-        if self.recorder is not None:
-            self.recorder.stop()
-            self.recorder.disconnect()
-            self.recorder = None
-        try:
-            self.websocket.close()
-        except Exception:
-            pass
-
-    def _assert_valid_value(self, value):
-        if not (value in [True, False, float('inf'), -float('inf')]):
-            value = str(value)
-            if len(value) > self.length_limit:
-                raise (exceptions.InvalidCloudValue(
-                    f"Value exceeds length limit: {str(value)}"
-                ))
-            if not self.allow_non_numeric:
-                x = value.replace(".", "")
-                x = x.replace("-", "")
-                if not (x.isnumeric() or x == ""):
-                    raise (exceptions.InvalidCloudValue(
-                        "Value not numeric"
-                    ))
-
-    def _enforce_ratelimit(self, *, n):
-        # n is the amount of variables being set
-        if (time.time() - self.first_var_set) / (
-                self.var_stets_since_first + 1) > self.ws_longterm_ratelimit:  # if the average delay between cloud variable sets has been bigger than the long-term rate-limit, cloud variables can be set fast (wait time smaller than long-term rate limit) again
-            self.var_stets_since_first = 0
-            self.first_var_set = time.time()
-
-        wait_time = self.ws_shortterm_ratelimit * n
-        if time.time() - self.first_var_set > 25:  # if cloud variables have been continously set fast (wait time smaller than long-term rate limit) for 25 seconds, they should be set slow now (wait time = long-term rate limit) to avoid getting rate-limited
-            wait_time = self.ws_longterm_ratelimit * n
-        while self.last_var_set + wait_time >= time.time():
-            time.sleep(0.001)
-
-    def set_var(self, variable, value):
-        """
-        Sets a cloud variable.
-
-        Args:
-            variable (str): The name of the cloud variable that should be set (provided without the cloud emoji)
-            value (str): The value the cloud variable should be set to
-        """
-        self._assert_valid_value(value)
-        if not isinstance(variable, str):
-            raise ValueError("cloud var name must be a string")
-        variable = variable.removeprefix("☁ ")
-        if not self.active_connection:
-            self.connect()
-        self._enforce_ratelimit(n=1)
-
-        self.var_stets_since_first += 1
-
-        packet = {
-            "method": "set",
-            "name": "☁ " + variable,
-            "value": value,
-            "user": self.username,
-            "project_id": self.project_id,
-        }
-        self._send_packet(packet)
-        self.last_var_set = time.time()
-
-    def set_vars(self, var_value_dict, *, intelligent_waits=True):
-        """
-        Sets multiple cloud variables at once (works for an unlimited amount of variables).
-
-        Args:
-            var_value_dict (dict): variable:value dictionary with the variables / values to set. The dict should like this: {"var1":"value1", "var2":"value2", ...}
-        
-        Kwargs:
-            intelligent_waits (boolean): When enabled, the method will automatically decide how long to wait before performing this cloud variable set, to make sure no rate limits are triggered
-        """
-        if not self.active_connection:
-            self.connect()
-        if intelligent_waits:
-            self._enforce_ratelimit(n=len(list(var_value_dict.keys())))
-
-        self.var_stets_since_first += len(list(var_value_dict.keys()))
-
-        packet_list = []
-        for variable in var_value_dict:
-            value = var_value_dict[variable]
-            variable = variable.removeprefix("☁ ")
-            self._assert_valid_value(value)
-            if not isinstance(variable, str):
-                raise ValueError("cloud var name must be a string")
-            packet = {
-                "method": "set",
-                "name": "☁ " + variable,
-                "value": value,
-                "user": self.username,
-                "project_id": self.project_id,
-            }
-            packet_list.append(packet)
-        self._send_packet_list(packet_list)
-        self.last_var_set = time.time()
-
-    def get_var(self, var, *, recorder_initial_values={}):
-        var = "☁ "+var.removeprefix("☁ ")
-        if self.recorder is None:
-            self.recorder = cloud_recorder.CloudRecorder(self, initial_values=recorder_initial_values)
-            self.recorder.start()
-            start_time = time.time()
-            while not (self.recorder.cloud_values != {} or start_time < time.time() - 5):
-                time.sleep(0.01)
-        return self.recorder.get_var(var)
-
-    def get_all_vars(self, *, recorder_initial_values={}):
-        if self.recorder is None:
-            self.recorder = cloud_recorder.CloudRecorder(self, initial_values=recorder_initial_values)
-            self.recorder.start()
-            start_time = time.time()
-            while not (self.recorder.cloud_values != {} or start_time < time.time() - 5):
-                time.sleep(0.01)
-        return self.recorder.get_all_vars()
-
-    def create_event_stream(self):
-        if self.event_stream:
-            raise ValueError("Cloud already has an event stream.")
-        self.event_stream = WebSocketEventStream(self)
-        return self.event_stream
-
-class LogCloudMeta(ABCMeta):
-    def __instancecheck__(cls, instance) -> bool:
-        if hasattr(instance, "logs"):
-            return isinstance(instance, BaseCloud)
-        return False
-
-class LogCloud(BaseCloud, metaclass=LogCloudMeta):
-    @abstractmethod
-    def logs(self, *, filter_by_var_named: Optional[str] = None, limit: int = 100, offset: int = 0) -> list[cloud_activity.CloudActivity]:
-        pass