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

cli/__about__.py

@@ -0,0 +1 @@
+VERSION = "0.0.0"

cli/__init__.py

@@ -0,0 +1,26 @@
+"""
+Only for use within __main__.py
+"""
+import io
+
+from rich.console import RenderableType
+from typing_extensions import Optional
+from scratchattach.cli.__about__ import VERSION
+from scratchattach.cli.namespace import ArgSpace
+from scratchattach.cli.context import ctx
+
+
+# noinspection PyPackageRequirements
+def try_get_img(image: bytes, size: tuple[int, int] | None = None) -> Optional[RenderableType]:
+    try:
+        from PIL import Image
+        from rich_pixels import Pixels
+
+        with Image.open(io.BytesIO(image)) as image:
+            if size is not None:
+                image = image.resize(size)
+
+            return Pixels.from_image(image)
+
+    except ImportError:
+        return ""

cli/cmd/__init__.py

@@ -0,0 +1,4 @@
+from .login import login
+from .group import group
+from .profile import profile
+from .sessions import sessions

cli/cmd/group.py

@@ -0,0 +1,127 @@
+from scratchattach.cli import db
+from scratchattach.cli.context import console, ctx
+
+from rich.markup import escape
+from rich.table import Table
+
+def _list():
+    table = Table(title="All groups")
+    table.add_column("Name")
+    table.add_column("Description")
+    table.add_column("Usernames")
+
+    db.cursor.execute("SELECT NAME, DESCRIPTION FROM GROUPS")
+    for name, description in db.cursor.fetchall():
+        db.cursor.execute("SELECT USERNAME FROM GROUP_USERS WHERE GROUP_NAME=?", (name,))
+        usernames = db.cursor.fetchall()
+
+        table.add_row(escape(name), escape(description),
+                      '\n'.join(f"{i}. {u}" for i, (u,) in enumerate(usernames)))
+
+    console.print(table)
+
+def add(group_name: str):
+    accounts = input("Add accounts (split by space): ").split()
+    for account in accounts:
+        ctx.db_add_to_group(group_name, account)
+
+def remove(group_name: str):
+    accounts = input("Remove accounts (split by space): ").split()
+    for account in accounts:
+        ctx.db_remove_from_group(group_name, account)
+
+def new():
+    console.rule(f"New group {escape(ctx.args.group_name)}")
+    if ctx.db_group_exists(ctx.args.group_name):
+        raise ValueError(f"Group {escape(ctx.args.group_name)} already exists")
+
+    db.conn.execute("BEGIN")
+    db.cursor.execute("INSERT INTO GROUPS (NAME, DESCRIPTION) "
+                      "VALUES (?, ?)", (ctx.args.group_name, input("Description: ")))
+    db.conn.commit()
+    add(ctx.args.group_name)
+
+    _group(ctx.args.group_name)
+
+def _group(group_name: str):
+    """
+    Display information about a group
+    """
+    db.cursor.execute(
+        "SELECT NAME, DESCRIPTION FROM GROUPS WHERE NAME = ?", (group_name,))
+    result = db.cursor.fetchone()
+    if result is None:
+        print("No group selected!!")
+        return
+
+    name, description = result
+
+    db.cursor.execute("SELECT USERNAME FROM GROUP_USERS WHERE GROUP_NAME = ?", (name,))
+    usernames = [name for (name,) in db.cursor.fetchall()]
+
+    table = Table(title=escape(group_name))
+    table.add_column(escape(name))
+    table.add_column('Usernames')
+
+    table.add_row(escape(description),
+                  '\n'.join(f"{i}. {u}" for i, u in enumerate(usernames)))
+
+    console.print(table)
+
+def switch():
+    console.rule(f"Switching to {escape(ctx.args.group_name)}")
+    if not ctx.db_group_exists(ctx.args.group_name):
+        raise ValueError(f"Group {escape(ctx.args.group_name)} does not exist")
+
+    ctx.current_group_name = ctx.args.group_name
+    _group(ctx.current_group_name)
+
+def delete(group_name: str):
+    print(f"Deleting {group_name}")
+    if not ctx.db_group_exists(group_name):
+        raise ValueError(f"Group {group_name} does not exist")
+    if ctx.db_group_count == 1:
+        raise ValueError(f"Make another group first")
+
+    ctx.db_group_delete(group_name)
+
+def copy(group_name: str, new_name: str):
+    print(f"Copying {group_name} as {new_name}")
+    if not ctx.db_group_exists(group_name):
+        raise ValueError(f"Group {group_name} does not exist")
+
+    ctx.db_group_copy(group_name, new_name)
+
+def rename(group_name: str, new_name: str):
+    copy(group_name, new_name)
+    delete(group_name)
+
+def group():
+    match ctx.args.group_command:
+        case "list":
+            _list()
+        case "new":
+            new()
+        case "switch":
+            switch()
+        case "add":
+            add(ctx.current_group_name)
+        case "remove":
+            remove(ctx.current_group_name)
+        case "delete":
+            if input("Are you sure? (y/N): ").lower() != "y":
+                return
+            delete(ctx.current_group_name)
+            new_current = ctx.db_first_group_name
+            print(f"Switching to {new_current}")
+            ctx.current_group_name = new_current
+            _group(new_current)
+
+        case "copy":
+            copy(ctx.current_group_name, ctx.args.group_name)
+        case "rename":
+            rename(ctx.current_group_name, ctx.args.group_name)
+            ctx.current_group_name = ctx.args.group_name
+            _group(ctx.args.group_name)
+        case None:
+            _group(ctx.current_group_name)

cli/cmd/login.py

@@ -0,0 +1,60 @@
+from scratchattach.cli.context import ctx, console
+from scratchattach.cli import db
+from rich.markup import escape
+
+from getpass import getpass
+
+import scratchattach as sa
+import warnings
+
+warnings.filterwarnings("ignore", category=sa.LoginDataWarning)
+
+
+def login():
+    if ctx.args.sessid:
+        if isinstance(ctx.args.sessid, bool):
+            ctx.args.sessid = getpass("Session ID: ")
+
+        session = sa.login_by_id(ctx.args.sessid)
+        password = None
+    else:
+        username = input("Username: ")
+        password = getpass()
+
+        session = sa.login(username, password)
+
+    console.rule()
+    console.print(f"Logged in as [b]{session.username}[/]")
+
+    # register session
+    db.conn.execute("BEGIN")
+    db.cursor.execute(
+        "INSERT OR REPLACE INTO SESSIONS (ID, USERNAME, PASSWORD) "
+        "VALUES (?, ?, ?)", (session.id, session.username, password)
+    )
+    db.conn.commit()
+
+    # make new group
+    db.cursor.execute("SELECT NAME FROM GROUPS WHERE NAME = ?", (session.username,))
+    if not db.cursor.fetchone():
+        console.rule(f"Registering [b]{escape(session.username)}[/] as group")
+        db.conn.execute("BEGIN")
+        db.cursor.execute(
+            "INSERT INTO GROUPS (NAME, DESCRIPTION) "
+            "VALUES (?, ?)", (session.username, input(f"Description for {session.username}: "))
+        ).execute(
+            "INSERT INTO GROUP_USERS (GROUP_NAME, USERNAME) "
+            "VALUES (?, ?)", (session.username, session.username)
+        )
+
+        db.conn.commit()
+
+    console.rule()
+    if input("Add to current session group? (Y/n)").lower() not in ("y", ''):
+        return
+
+    db.conn.execute("BEGIN")
+    db.cursor.execute("INSERT INTO GROUP_USERS (GROUP_NAME, USERNAME) "
+                      "VALUES (?, ?)", (ctx.current_group_name, session.username))
+    db.conn.commit()
+    console.print(f"Added to [b]{escape(ctx.current_group_name)}[/]")

cli/cmd/profile.py

@@ -0,0 +1,7 @@
+from scratchattach.cli.context import ctx, console
+
+@ctx.sessionable
+def profile():
+    console.rule()
+    user = ctx.session.connect_linked_user()
+    console.print(user)

cli/cmd/sessions.py

@@ -0,0 +1,5 @@
+from scratchattach.cli.context import ctx, console
+
+@ctx.sessionable
+def sessions():
+    console.print(ctx.session)

cli/context.py

@@ -0,0 +1,142 @@
+"""
+Handles data like current session for 'sessionable' commands.
+Holds objects that should be available for the whole CLI system
+Also provides wrappers for some SQL info.
+"""
+import argparse
+from dataclasses import dataclass, field
+
+import rich.console
+from typing_extensions import Optional
+
+from scratchattach.cli.namespace import ArgSpace
+from scratchattach.cli import db
+import scratchattach as sa
+
+
+@dataclass
+class _Ctx:
+    args: ArgSpace = field(default_factory=ArgSpace)
+    parser: argparse.ArgumentParser = field(default_factory=argparse.ArgumentParser)
+    _username: Optional[str] = None
+    _session: Optional[sa.Session] = None
+
+    # TODO: implement this
+    def sessionable(self, func):
+        """
+        Decorate a command that will be run for every session in the group.
+        """
+
+        def wrapper(*args, **kwargs):
+            for username in self.db_users_in_group(self.current_group_name):
+                self._username = username
+                self._session = None
+                func(*args, **kwargs)
+
+        return wrapper
+
+    @property
+    def username(self):
+        if not self._username:
+            self._username = self.db_users_in_group(self.current_group_name)[0]
+
+        return self._username
+
+    @property
+    def session(self):
+        if not self._session:
+            self._session = sa.login_by_id(self.db_get_sessid(self.username))
+
+        return self._session
+
+    # helper functions with DB
+    # if possible, put all db funcs here
+
+    @property
+    def current_group_name(self):
+        return db.cursor \
+            .execute("SELECT * FROM CURRENT WHERE GROUP_NAME IS NOT NULL") \
+            .fetchone()[0]
+
+    @current_group_name.setter
+    def current_group_name(self, value: str):
+        db.conn.execute("BEGIN")
+        db.cursor.execute("DELETE FROM CURRENT WHERE GROUP_NAME IS NOT NULL")
+        db.cursor.execute("INSERT INTO CURRENT (GROUP_NAME) VALUES (?)", (value,))
+        db.conn.commit()
+
+    @staticmethod
+    def db_group_exists(name: str) -> bool:
+        return db.cursor.execute("SELECT NAME FROM GROUPS WHERE NAME = ?", (name,)).fetchone() is not None
+
+    @staticmethod
+    def db_session_exists(name: str) -> bool:
+        return db.cursor.execute("SELECT USERNAME FROM SESSIONS WHERE USERNAME = ?", (name,)).fetchone() is not None
+
+    @staticmethod
+    def db_users_in_group(name: str) -> list[str]:
+        return [i for (i,) in db.cursor.execute(
+            "SELECT USERNAME FROM GROUP_USERS WHERE GROUP_NAME = ?", (name,)).fetchall()]
+
+    def db_remove_from_group(self, group_name: str, username: str):
+        if username in self.db_users_in_group(group_name):
+            db.conn.execute("BEGIN")
+            db.cursor.execute("DELETE FROM GROUP_USERS "
+                              "WHERE USERNAME = ? AND GROUP_NAME = ?", (username, group_name))
+            db.conn.commit()
+
+    @staticmethod
+    def db_get_sessid(username: str) -> Optional[str]:
+        ret = db.cursor.execute("SELECT ID FROM SESSIONS WHERE USERNAME = ?", (username,)).fetchone()
+        if ret:
+            ret = ret[0]
+        return ret
+
+    def db_add_to_group(self, group_name: str, username: str):
+        if username in self.db_users_in_group(group_name) or not self.db_session_exists(username):
+            return
+        db.conn.execute("BEGIN")
+        db.cursor.execute("INSERT INTO GROUP_USERS (GROUP_NAME, USERNAME) "
+                          "VALUES (?, ?)", (group_name, username))
+        db.conn.commit()
+
+    @staticmethod
+    def db_group_delete(group_name: str):
+        db.conn.execute("BEGIN")
+        # delete links to sessions first
+        db.cursor.execute("DELETE FROM GROUP_USERS WHERE GROUP_NAME = ?", (group_name,))
+        # delete group itself
+        db.cursor.execute("DELETE FROM GROUPS WHERE NAME = ?", (group_name,))
+        db.conn.commit()
+
+    @staticmethod
+    def db_group_copy(group_name: str, copy_name: str):
+        db.conn.execute("BEGIN")
+        # copy group metadata
+        db.cursor.execute("INSERT INTO GROUPS (NAME, DESCRIPTION) "
+                          "SELECT ?, DESCRIPTION FROM GROUPS WHERE NAME = ?", (copy_name, group_name,))
+        # copy sessions
+        db.cursor.execute("INSERT INTO GROUP_USERS (GROUP_NAME, USERNAME)  "
+                          "SELECT ?, USERNAME FROM GROUP_USERS WHERE GROUP_NAME = ?", (copy_name, group_name,))
+
+        db.conn.commit()
+
+    @property
+    def db_first_group_name(self) -> str:
+        """Just get a group, I don't care which"""
+        db.cursor.execute("SELECT NAME FROM GROUPS")
+        return db.cursor.fetchone()[0]
+
+    @property
+    def db_group_count(self):
+        db.cursor.execute("SELECT COUNT(*) FROM GROUPS")
+        return db.cursor.fetchone()[0]
+
+    def db_get_sess(self, sess_name: str):
+        if sess_id := self.db_get_sessid(sess_name):
+            return sa.login_by_id(sess_id)
+        return None
+
+
+ctx = _Ctx()
+console = rich.console.Console()

cli/db.py

@@ -0,0 +1,66 @@
+"""
+Basic connections to the scratch.sqlite file
+"""
+import sqlite3
+import sys
+import os
+
+from pathlib import Path
+
+from typing_extensions import LiteralString
+
+
+def _gen_appdata_folder() -> Path:
+    name = "scratchattach"
+    match sys.platform:
+        case "win32":
+            return Path(os.getenv('APPDATA')) / name
+        case "linux":
+            return Path.home() / f".{name}"
+        case plat:
+            raise NotImplementedError(f"No 'appdata' folder implemented for {plat}")
+
+_path = _gen_appdata_folder()
+_path.mkdir(parents=True, exist_ok=True)
+
+conn = sqlite3.connect(_path / "cli.sqlite")
+cursor = conn.cursor()
+
+# Init any tables
+def add_col(table: LiteralString, column: LiteralString, _type: LiteralString):
+    try:
+        # strangely, using `?` here doesn't seem to work. Make sure to use LiteralStrings, not str
+        return cursor.execute(f"ALTER TABLE {table} ADD COLUMN {column} {_type}")
+    except sqlite3.OperationalError as e:
+        if "duplicate column name" not in str(e).lower():
+            raise
+
+# NOTE: IF YOU WANT TO ADD EXTRA KEYS TO A TABLE RETROACTIVELY, USE add_col
+# note: avoide using select * with tuple unpacking/indexing, because if fields are added, things will break.
+conn.execute("BEGIN")
+cursor.executescript("""
+    CREATE TABLE IF NOT EXISTS SESSIONS (
+        ID TEXT NOT NULL,
+        USERNAME TEXT NOT NULL PRIMARY KEY
+    );
+        
+    CREATE TABLE IF NOT EXISTS GROUPS (
+        NAME TEXT NOT NULL PRIMARY KEY,
+        DESCRIPTION TEXT
+        -- If you want to add users to a group, you add to the next table
+    );
+    
+    CREATE TABLE IF NOT EXISTS GROUP_USERS (
+        GROUP_NAME TEXT NOT NULL,
+        USERNAME TEXT NOT NULL
+    );
+    
+    -- stores info like current group, last project/studio, etc
+    CREATE TABLE IF NOT EXISTS CURRENT (
+        GROUP_NAME TEXT NOT NULL
+    );
+""")
+add_col("SESSIONS", "PASSWORD", "TEXT")
+
+
+conn.commit()

cli/namespace.py

@@ -0,0 +1,14 @@
+import argparse
+from typing_extensions import Optional, Literal
+
+
+class ArgSpace(argparse.Namespace):
+    command: Optional[Literal['login', 'group', 'profile', 'sessions']]
+    sessid: bool | str
+    username: Optional[str]
+    studio_id: Optional[str]
+    project_id: Optional[str]
+    session_name: Optional[str]
+
+    group_command: Optional[Literal['list', 'new', 'switch', 'add', 'remove',  'delete', 'copy', 'rename']]
+    group_name: str