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

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,37 +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,
-    GetAuthenticationWarning,
-    StudioAuthenticationWarning,
-    ClassroomAuthenticationWarning,
-    ProjectAuthenticationWarning,
-    UserAuthenticationWarning)
-
-from .site.activity import Activity, ActivityTypes
-from .site.backpack_asset import BackpackAsset
-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.studio import Studio, get_studio, search_studios, explore_studios
-from .site.classroom import Classroom, get_classroom
-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

@@ -1,93 +0,0 @@
-"""
-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-3.0.0b0.dist-info/RECORD

@@ -1,8 +0,0 @@
-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-3.0.0b0.dist-info/top_level.txt

@@ -1 +0,0 @@
-scratchattach