scratchattach 2.1.15b0__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

{scratchattach/utils → utils}/commons.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import string
 
-from typing import Optional, Final, Any, TypeVar, Callable, TYPE_CHECKING, Union
+from typing import Optional, Final, Any, TypeVar, Callable, TYPE_CHECKING, Union, overload
 from threading import Event as ManualResetEvent
 from threading import Lock
 
@@ -162,19 +162,28 @@ def _get_object(identificator_name, identificator, __class: type[C], NotFoundExc
     except Exception as e:
         raise e
 
+I = TypeVar("I")
+@overload
+def webscrape_count(raw: str, text_before: str, text_after: str, cls: type[I]) -> I:
+    pass
 
-def webscrape_count(raw, text_before, text_after, cls: type = int) -> int | Any:
+@overload
+def webscrape_count(raw: str, text_before: str, text_after: str) -> int:
+    pass
+
+def webscrape_count(raw, text_before, text_after, cls = int):
     return cls(raw.split(text_before)[1].split(text_after)[0])
 
 
 if TYPE_CHECKING:
     C = TypeVar("C", bound=_base.BaseSiteComponent)
 
-def parse_object_list(raw, __class: type[C], session=None, primary_key="id") -> list[C]:
+def parse_object_list(raw, /, __class: type[C], session=None, primary_key="id") -> list[C]:
     results = []
     for raw_dict in raw:
         try:
             _obj = __class(**{primary_key: raw_dict[primary_key], "_session": session})
+            # noinspection PyProtectedMember
             _obj._update_from_dict(raw_dict)
             results.append(_obj)
         except Exception as e:
@@ -252,4 +261,3 @@ def b62_decode(s: str):
         ret = ret * 62 + chars.index(char)
 
     return ret
-

{scratchattach/utils → utils}/encoder.py

@@ -122,11 +122,14 @@ class Encoding:
         try:
             inp = str(inp)
         except Exception:
-            raise(exceptions.InvalidDecodeInput)
+            raise exceptions.InvalidDecodeInput
+
         outp = ""
-        for i in range(0, math.floor(len(inp) / 2)):
-            letter = letters[int(f"{inp[i*2]}{inp[(i*2)+1]}")]
-            outp = f"{outp}{letter}"
+        # print(f"Encoding.decode({inp=})")
+        # This loops through a string like 'abCDefGHijKLmnOP' like so: l1+l2=ab, CD, ef, GH, etc.
+        for l1, l2 in zip(inp[::2], inp[1::2]):
+            outp += letters[int(l1 + l2)]
+
         return outp
 
     @staticmethod

{scratchattach/utils → utils}/enums.py

@@ -18,6 +18,7 @@ class Language:
     single_gender: bool = None
 
 
+# should this underscore be removed
 class _EnumWrapper(Enum):
     @classmethod
     def find(cls, value, by: str, apply_func: Optional[Callable] = None):

{scratchattach/utils → utils}/exceptions.py

@@ -232,9 +232,43 @@ class LoginDataWarning(UserWarning):
     Warns you not to accidentally share your login data.
     """
 
-class AnonymousSiteComponentWarning(UserWarning):
+class InvalidUpdateWarning(UserWarning):
     """
-    Warns about a usage of an anonymous site component.
+    Warns you that something cannot be updated.
+    """
+    
+class GetAuthenticationWarning(UserWarning):
+    """
+    All authentication warnings.
+    """
+    
+class UserAuthenticationWarning(GetAuthenticationWarning):
+    """
+    Warns you to use session.connect_user instead of user.get_user
+    for actions that require authentication.
+    """
+
+class ProjectAuthenticationWarning(GetAuthenticationWarning):
+    """
+    Warns you to use session.connect_project instead of project.get_project 
+    for actions that require authentication.
+    """
+
+class StudioAuthenticationWarning(GetAuthenticationWarning):
+    """
+    Warns you to use session.connect_studio instead of studio.get_studio 
+    for actions that require authentication.
+    """
+
+class ClassroomAuthenticationWarning(GetAuthenticationWarning):
+    """
+    Warns you to use session.connect_classroom or session.connect_classroom_from_token instead of classroom.get_classroom 
+    for actions that require authentication.
+    """
+
+class CloudAuthenticationWarning(GetAuthenticationWarning):
+    """
+    Warns you about usage of 
     """
 
 class UnexpectedWebsocketEventWarning(RuntimeWarning):

utils/optional_async.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Generator, Callable
+from typing import Generic, TypeVar, ParamSpec, Optional, Union, Any
+from functools import wraps
+import asyncio
+import time
+
+from . import requests
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+class CallableAwaitable(Generic[R], ABC, Awaitable[R]):
+    result: R
+    
+    @abstractmethod
+    def sync_impl(self) -> R:
+        pass
+    
+    def __pos__(self) -> R:
+        return self.sync_impl()
+    
+    @abstractmethod
+    async def async_impl(self) -> R:
+        pass
+    
+    def __await__(self) -> Generator[None, None, R]:
+        return self.async_impl().__await__()
+
+class OptionallyAsync(Generic[P, R], ABC):
+    @abstractmethod
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> CallableAwaitable[R]:
+        pass
+
+def optionally_async(func: Callable[P, Generator[CallableAwaitable, None, R]]) -> OptionallyAsync[P, R]:
+    class Wrapped(OptionallyAsync[P, R]):
+        def __call__(self, *args: P.args, **kwargs: P.kwargs) -> CallableAwaitable[R]:
+            class Implementation(CallableAwaitable[R]):
+                def sync_impl(self) -> R:
+                    i = func(*args, **kwargs)
+                    try:
+                        while True:
+                            c = next(i)
+                            c.result = +c
+                    except StopIteration as excp:
+                        return excp.value
+                
+                async def async_impl(self) -> R:
+                    i = func(*args, **kwargs)
+                    try:
+                        while True:
+                            c = next(i)
+                            c.result = await c
+                    except StopIteration as excp:
+                        return excp.value
+            
+            return Implementation()
+    return Wrapped()
+
+def make_async(func: Callable[P, Generator[CallableAwaitable, None, R]]) -> Callable[P, Awaitable[R]]:
+    @wraps(func)
+    async def async_impl(*args: P.args, **kwargs: P.kwargs) -> R:
+        i = func(*args, **kwargs)
+        try:
+            while True:
+                c = next(i)
+                c.result = await c
+        except StopIteration as excp:
+            return excp.value
+    return async_impl
+
+def make_sync(func: Callable[P, Generator[CallableAwaitable, None, R]]) -> Callable[P, R]:
+    @wraps(func)
+    def sync_impl(*args: P.args, **kwargs: P.kwargs) -> R:
+        i = func(*args, **kwargs)
+        try:
+            while True:
+                c = next(i)
+                c.result = +c
+        except StopIteration as excp:
+            return excp.value
+    return sync_impl
+
+class CASleep(CallableAwaitable[bool]):
+    amount: float
+    
+    def __init__(self, amount: float) -> None:
+        self.amount = amount
+    
+    def sync_impl(self):
+        time.sleep(self.amount)
+        return True
+    
+    async def async_impl(self):
+        await asyncio.sleep(self.amount)
+        return True
+
+def oa_sleep(amount: float):
+    return CASleep(amount)
+
+class CARequest(CallableAwaitable["requests.AnyHTTPResponse"]):
+    requests_session: requests.OAHTTPSession
+    method: requests.HTTPMethod
+    url: str
+    cookies: Optional[dict[str, str]]
+    headers: Optional[dict[str, str]]
+    params: Optional[dict[str, str]]
+    data: Optional[Union[dict[str, str], str]]
+    json: Optional[dict[str, str]]
+    
+    def __init__(
+        self,
+        requests_session: requests.OAHTTPSession,
+        method: requests.HTTPMethod,
+        url: str,
+        *,
+        cookies: Optional[dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        params: Optional[dict[str, str]] = None,
+        data: Optional[Union[dict[str, str], str]] = None,
+        json: Optional[Any] = None
+    ) -> None:
+        self.requests_session = requests_session
+        self.method = method
+        self.url = url
+        self.cookies = cookies
+        self.headers = headers
+        self.params = params
+        self.data = data
+        self.json = json
+    
+    def sync_impl(self):
+        return self.requests_session.sync_request(
+            method = self.method,
+            url = self.url,
+            cookies = self.cookies,
+            headers = self.headers,
+            params = self.params,
+            data = self.data,
+            json = self.json
+        )
+    
+    async def async_impl(self):
+        return await self.requests_session.async_request(
+            method = self.method,
+            url = self.url,
+            cookies = self.cookies,
+            headers = self.headers,
+            params = self.params,
+            data = self.data,
+            json = self.json
+        )

utils/requests.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+from collections.abc import MutableMapping, Iterator
+from abc import ABC, abstractmethod
+from types import TracebackType
+from typing import Optional, Any, Self, Union
+from contextlib import contextmanager
+from enum import Enum, auto
+from dataclasses import dataclass, field
+import json
+
+from aiohttp.cookiejar import DummyCookieJar
+from typing_extensions import override
+from requests import Session as HTTPSession
+from requests import Response
+import aiohttp
+
+from . import exceptions
+from . import optional_async
+
+proxies: Optional[MutableMapping[str, str]] = None
+
+class HTTPMethod(Enum):
+    GET = auto()
+    POST = auto()
+    PUT = auto()
+    DELETE = auto()
+    HEAD = auto()
+    OPTIONS = auto()
+    PATCH = auto()
+    TRACE = auto()
+    @classmethod
+    def of(cls, name: str) -> HTTPMethod:
+        member_map = {
+            "GET": cls.GET,
+            "POST": cls.POST,
+            "PUT": cls.PUT,
+            "DELETE": cls.DELETE,
+            "HEAD": cls.HEAD,
+            "OPTIONS": cls.OPTIONS,
+            "PATCH": cls.PATCH,
+            "TRACE": cls.TRACE
+        }
+        return member_map[name]
+
+class AnyHTTPResponse(ABC):
+    request_method: HTTPMethod
+    status_code: int
+    content: bytes
+    text: str
+    headers: dict[str, str]
+    
+    def json(self) -> Any:
+        return json.loads(self.text)
+
+@dataclass
+class HTTPResponse(AnyHTTPResponse):
+    request_method: HTTPMethod = field(kw_only=True)
+    status_code: int = field(kw_only=True)
+    content: bytes = field(kw_only=True)
+    text: str = field(kw_only=True)
+    headers: dict[str, str] = field(kw_only=True)
+
+class OAHTTPSession(ABC):
+    error_handling: bool = True
+    @abstractmethod
+    def sync_request(
+        self,
+        method: HTTPMethod,
+        url: str,
+        *,
+        cookies: Optional[dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        params: Optional[dict[str, str]] = None,
+        data: Optional[Union[dict[str, str], str]] = None,
+        json: Optional[Any] = None
+    ) -> AnyHTTPResponse:
+        pass
+    
+    @abstractmethod
+    async def async_request(
+        self,
+        method: HTTPMethod,
+        url: str,
+        *,
+        cookies: Optional[dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        params: Optional[dict[str, str]] = None,
+        data: Optional[Union[dict[str, str], str]] = None,
+        json: Optional[Any] = None
+    ) -> AnyHTTPResponse:
+        pass
+
+    def check_response(self, r: AnyHTTPResponse):
+        if r.status_code == 403 or r.status_code == 401:
+            raise exceptions.Unauthorized(f"Request content: {r.content!r}")
+        if r.status_code == 500:
+            raise exceptions.APIError("Internal Scratch server error")
+        if r.status_code == 429:
+            raise exceptions.Response429("You are being rate-limited (or blocked) by Scratch")
+        if r.json() == {"code":"BadRequest","message":""}:
+            raise exceptions.BadRequest("Make sure all provided arguments are valid")
+    
+    
+    def request(
+        self,
+        method: Union[HTTPMethod, str],
+        url: str,
+        *,
+        cookies: Optional[dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        params: Optional[dict[str, str]] = None,
+        data: Optional[Union[dict[str, str], str]] = None,
+        json: Optional[Any] = None
+    ) -> optional_async.CARequest:
+        if isinstance(method, str):
+            method = HTTPMethod.of(method.upper())
+        return optional_async.CARequest(
+            self,
+            method,
+            url,
+            cookies = cookies,
+            headers = headers,
+            params = params,
+            data = data,
+            json = json
+        )
+    
+    @contextmanager
+    def no_error_handling(self) -> Iterator[None]:
+        val_before = self.error_handling
+        self.error_handling = False
+        try:
+            yield
+        finally:
+            self.error_handling = val_before
+    
+    @contextmanager
+    def yes_error_handling(self) -> Iterator[None]:
+        val_before = self.error_handling
+        self.error_handling = True
+        try:
+            yield
+        finally:
+            self.error_handling = val_before
+
+class SyncRequests(OAHTTPSession):
+    @override
+    def sync_request(self, method, url, *, cookies = None, headers = None, params = None, data = None, json = None):
+        try:
+            r = requests.request(
+                method.name,
+                url,
+                cookies = cookies,
+                headers = headers,
+                params = params,
+                data = data,
+                json = json,
+                proxies = proxies
+            )
+        except Exception as e:
+            raise exceptions.FetchError(e)
+        response = HTTPResponse(
+            request_method=method,
+            status_code=r.status_code,
+            content=r.content,
+            text=r.text,
+            headers=r.headers
+        )
+        if self.error_handling:
+            self.check_response(response)
+        return response
+    
+    async def async_request(self, method, url, *, cookies = None, headers = None, params = None, data = None, json = None):
+        raise NotImplementedError()
+
+class AsyncRequests(OAHTTPSession):
+    client_session: aiohttp.ClientSession
+    async def __aenter__(self) -> Self:
+        self.client_session = await aiohttp.ClientSession(cookie_jar=DummyCookieJar()).__aenter__()
+        return self
+    
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]] = None,
+        exc_val: Optional[BaseException] = None,
+        exc_tb: Optional[TracebackType] = None
+    ) -> None:
+        await self.client_session.__aexit__(exc_type, exc_val, exc_tb)
+    
+    @override
+    def sync_request(self, method, url, *, cookies = None, headers = None, params = None, data = None, json = None):
+        raise NotImplementedError()
+    
+    async def async_request(self, method, url, *, cookies = None, headers = None, params = None, data = None, json = None):
+        proxy = None
+        if url.startswith("http"):
+            proxy = proxies.get("http")
+        if url.startswith("https"):
+            proxy = proxies.get("https")
+        async with self.client_session.request(
+            method.name,
+            url,
+            cookies = cookies,
+            headers = headers,
+            params = params,
+            data = data,
+            json = json,
+            proxy = proxy
+        ) as resp:
+            assert isinstance(resp, aiohttp.ClientResponse)
+            content = await resp.read()
+            try:
+                text = content.decode(resp.get_encoding())
+            except Exception:
+                text = ""
+            response = HTTPResponse(
+                request_method=method,
+                status_code=resp.status,
+                content=content,
+                text=text,
+                headers=resp.headers
+            )
+            if self.error_handling:
+                self.check_response(response)
+            return response
+
+class Requests(HTTPSession):
+    """
+    Centralized HTTP request handler (for better error handling and proxies)
+    """
+    error_handling: bool = True
+
+    def check_response(self, r: Response):
+        if r.status_code == 403 or r.status_code == 401:
+            raise exceptions.Unauthorized(f"Request content: {r.content!r}")
+        if r.status_code == 500:
+            raise exceptions.APIError("Internal Scratch server error")
+        if r.status_code == 429:
+            raise exceptions.Response429("You are being rate-limited (or blocked) by Scratch")
+        if r.json() == {"code":"BadRequest","message":""}:
+            raise exceptions.BadRequest("Make sure all provided arguments are valid")
+
+    @override
+    def get(self, *args, **kwargs):
+        kwargs.setdefault("proxies", proxies)
+        try:
+            r = super().get(*args, **kwargs)
+        except Exception as e:
+            raise exceptions.FetchError(e)
+        if self.error_handling:
+            self.check_response(r)
+        return r
+
+    @override
+    def post(self, *args, **kwargs):
+        kwargs.setdefault("proxies", proxies)
+        try:
+            r = super().post(*args, **kwargs)
+        except Exception as e:
+            raise exceptions.FetchError(e)
+        if self.error_handling:
+            self.check_response(r)
+        return r
+
+    @override
+    def delete(self, *args, **kwargs):
+        kwargs.setdefault("proxies", proxies)
+        try:
+            r = super().delete(*args, **kwargs)
+        except Exception as e:
+            raise exceptions.FetchError(e)
+        if self.error_handling:
+            self.check_response(r)
+        return r
+
+    @override
+    def put(self, *args, **kwargs):
+        kwargs.setdefault("proxies", proxies)
+        try:
+            r = super().put(*args, **kwargs)
+        except Exception as e:
+            raise exceptions.FetchError(e)
+        if self.error_handling:
+            self.check_response(r)
+        return r
+    
+    @contextmanager
+    def no_error_handling(self) -> Iterator[None]:
+        val_before = self.error_handling
+        self.error_handling = False
+        try:
+            yield
+        finally:
+            self.error_handling = val_before
+    
+    @contextmanager
+    def yes_error_handling(self) -> Iterator[None]:
+        val_before = self.error_handling
+        self.error_handling = True
+        try:
+            yield
+        finally:
+            self.error_handling = val_before
+
+requests = Requests()

scratchattach/__init__.py

@@ -1,29 +0,0 @@
-from .cloud.cloud import ScratchCloud, TwCloud, get_cloud, get_scratch_cloud, get_tw_cloud
-from .cloud._base import BaseCloud, AnyCloud
-
-from .eventhandlers.cloud_server import init_cloud_server
-from .eventhandlers._base import BaseEventHandler
-from .eventhandlers.filterbot import Filterbot, HardFilter, SoftFilter, SpamFilter
-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 .utils.encoder import Encoding
-from .utils.enums import Languages, TTSVoices
-from .utils.exceptions import LoginDataWarning
-
-from .site.activity import Activity
-from .site.backpack_asset import BackpackAsset
-from .site.comment import Comment
-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.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._base import BaseSiteComponent
-from .site.browser_cookies import Browser, ANY, FIREFOX, CHROME, CHROMIUM, VIVALDI, EDGE, EDGE_DEV, SAFARI
-
-from . import editor