sprawdzai-cli 0.2.0__py3-none-any.whl

sai/commands/ds/rename.py

@@ -0,0 +1,54 @@
+import typer
+from typing import Optional
+from pathlib import Path
+from .utils import Datasets
+from ...utils.error_handler import handle_response_error
+
+def rename(
+    name_or_id: str = typer.Argument(
+        ...,
+        help=(
+            "Name or id of dataset to be renamed"
+        )
+    ),
+    new_name: str = typer.Argument(
+        ...,
+        help=(
+            "New name of the dataset"
+        )
+    ),
+    path: Path = typer.Option(
+        Path.cwd(),
+        "--location",
+        "-l",
+        help="Path where the task is located (defaults to current directory)."
+    ),
+    backend: Optional[str] = typer.Option(
+        None,
+        "--backend",
+        "-b",
+        help=(
+            "Use a different backend: "
+            "local (l, l1, l2, ...), "
+            "remote (r, r1, r2, ...) "
+            "or full URL (https://example.com)"
+        )
+    )
+):
+    """
+    Rename a dataset.
+    """
+
+    dss = Datasets(path, backend)
+    ds = dss.find(name_or_id)
+
+    data = {"type_": "dataset", "title": f"{dss.task['slug']} - {new_name}"}
+    resp = dss.client.patch(f'/files/{ds.id}', data=data)
+
+    if resp.status_code not in [200, 201]:
+        handle_response_error(resp)
+    
+    if ds.local:
+        ds.path.rename(ds.path.with_name(new_name))
+
+    Datasets(path, backend).show_warnings()

sai/commands/ds/send.py

@@ -0,0 +1,161 @@
+import typer
+from typing import Optional
+from pathlib import Path
+from .utils import Datasets, Dataset
+import zipfile
+from ...utils.error_handler import write_error, warn, handle_response_error
+import tempfile
+from tqdm.auto import tqdm
+
+def format_mem(sz):
+    sz = int(sz)
+    if sz <= 10240:
+        return f'{sz}B'
+    sz = sz / 1024
+    if sz <= 10240:
+        return f'{sz:.2f}KB'
+    sz = sz / 1024
+    if sz <= 10240:
+        return f'{sz:.2f}MB'
+    sz = sz / 1024
+    return f'{sz:.2f}GB'
+
+def send(
+    name_or_id: Optional[str] = typer.Argument(
+        None,
+        help=(
+            "Send dataset with specific name or id. "
+            "If this argument is not specified, it will send all datasets you have locally."
+        )
+    ),
+    no_zip: bool = typer.Option(
+        False,
+        "--no-zip",
+        "-n",
+        help=(
+            "If there is just one file in the dataset, with this flag you can make a dataset to be this one file "
+            "instead of being a zip containing a single file. "
+            "It will throw an error if there is not exactly one file in a dataset folder. "
+        )
+    ),
+    detach: bool = typer.Option(
+        False,
+        "--detach",
+        "-d",
+        help=(
+            "Instead of writing to the current dataset on backend, "
+            "it will create a new dataset and write to it, leaving the current dataset unchanged on backend. "
+            "Please do not use unless having a specific reason, "
+            "because it can make mess in datasets and lose a lot of disk space since it will create a new dataset during each call with this flag."
+        )
+    ),
+    zip_method: str = typer.Option(
+        "deflated",
+        "--zip-method",
+        "-z",
+        help="Compression method to use when sending datasets (`stored` - no compression, `deflated`, `bz2`, `lzma`)"
+    ),
+    path: Path = typer.Option(
+        Path.cwd(),
+        "--location",
+        "-l",
+        help="Path where the task is located (defaults to current directory)."
+    ),
+    backend: Optional[str] = typer.Option(
+        None,
+        "--backend",
+        "-b",
+        help=(
+            "Use a different backend: "
+            "local (l, l1, l2, ...), "
+            "remote (r, r1, r2, ...) "
+            "or full URL (https://example.com)"
+        )
+    )
+):
+    """
+    Send a dataset or all datasets you have pulled locally.
+    """
+
+    dss = Datasets(path, backend)
+
+    zip_method_dict = {
+        'stored': zipfile.ZIP_STORED,
+        'deflated': zipfile.ZIP_DEFLATED,
+        'bz2': zipfile.ZIP_BZIP2,
+        'lzma': zipfile.ZIP_LZMA
+    }
+    if zip_method not in zip_method_dict:
+        write_error(f'Got unexpected zip compression method {zip_method}, expected one of: {", ".join(list(zip_method_dict.keys()))}')
+    zip_method_int = zip_method_dict[zip_method]
+
+    tsend: list[Dataset] = []
+    if name_or_id is None:
+        if len(dss.dss) == 0:
+            warn('There are no datasets linked to this task, so no dataset can be sent.')
+        else:
+            for ds in dss.dss.values():
+                if ds.local:
+                    tsend.append(ds)
+            if len(dss.dss) == 0:
+                warn('You do not have any datasets pulled locally, so no dataset can be sent.')
+    else:
+        tsend = [dss.find(name_or_id)]
+    
+    if len(tsend) >= 2:
+        typer.echo(f'Sending {len(tsend)} datasets...')
+    
+    for ds in tsend:
+        typer.echo(f'{" - " if len(tsend) >= 2 else ""}Sending {str(ds)}...')
+
+        dir_path = path / ds.name
+        filename = f'{ds.name}.zip'
+        files = list(dir_path.rglob("*"))
+        
+        if no_zip:
+            if len(files) == 0:
+                write_error(f'Error: --no-zip flag was passed, but {str(ds)} dataset has zero files (expected exactly one)')
+            if len(files) > 1:
+                write_error(f'Error: --no-zip flag was passed, but {str(ds)} dataset has more than one file (expected exactly one)')
+            file = files[0]
+            filename = file.name
+            to_send = file
+        else:
+            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
+            to_send = Path(tmp.name)
+            with zipfile.ZipFile(to_send, 'w', zip_method_int) as zipf:
+                if len(files) == 0:
+                    typer.echo('Dataset is empty.')
+                else:
+                    for file_path in tqdm(files, desc=f"Zipping"):
+                        zipf.write(file_path, arcname=file_path.relative_to(dir_path))
+            tmp.close()
+
+        try:
+            size = to_send.stat().st_size
+            typer.echo(f'Uploading ({format_mem(size)})...')
+            with open(to_send, "rb") as f:
+                files_req = {"file": (filename, f)}
+
+                if detach:
+                    data = {"type_": "dataset", "title": ds.orig_name}
+                    resp = dss.client.post('/files', data=data, files=files_req)
+                else:
+                    data = {"type_": "dataset", "title": ds.orig_name}
+                    resp = dss.client.patch(f'/files/{ds.id}', data=data, files=files_req)
+                
+                if resp.status_code not in [200, 201]:
+                    typer.echo(f'Error while sending {str(ds)}:')
+                    handle_response_error(resp)
+                
+                res = resp.json()
+
+                if detach:
+                    ds.id = res['id']
+                    typer.echo(f'Detached to id {ds.id}')
+                    dss.update(dss.dss.values())
+        finally:
+            if to_send.exists() and not no_zip:
+                to_send.unlink()
+
+    Datasets(path, backend).show_warnings()

sai/commands/ds/unlink.py

@@ -0,0 +1,132 @@
+import typer
+from typing import Optional
+from pathlib import Path
+from .utils import Datasets
+from ...utils.error_handler import write_error
+
+def unlink(
+    name_or_id: str = typer.Argument(
+        ...,
+        help=(
+            "Name or id of dataset to be unlinked"
+        )
+    ),
+    valid: bool = typer.Option(
+        False,
+        "--valid",
+        "-v",
+    ),
+    test: bool = typer.Option(
+        False,
+        "--test",
+        "-t",
+    ),
+    nb: bool = typer.Option(
+        False,
+        "--notebook",
+        "-n",
+    ),
+    chk: bool = typer.Option(
+        False,
+        "--checker",
+        "-c",
+    ),
+    path: Path = typer.Option(
+        Path.cwd(),
+        "--location",
+        "-l",
+        help="Path where the task is located (defaults to current directory)."
+    ),
+    backend: Optional[str] = typer.Option(
+        None,
+        "--backend",
+        "-b",
+        help=(
+            "Use a different backend: "
+            "local (l, l1, l2, ...), "
+            "remote (r, r1, r2, ...) "
+            "or full URL (https://example.com)"
+        )
+    )
+):
+    """
+    Unlink a dataset to from a task or a stage of this task.
+
+    sai ds unlink name/id -> completely unlink the dataset from this task
+    sai ds unlink name/id --notebook/--checker/--valid/--test or -n/-c/-v/-t -> unlink dataset from 2 corresponding stages
+
+    When passing two flags it will unlink dataset from this one stage, e.g.:
+    sai ds unlink name/id --notebook --test -> unlink dataset from test notebook stage
+    """
+
+    dss = Datasets(path, backend)
+
+    ds = dss.find(name_or_id)
+
+    def unlinkk(s1: str, s2: str):
+        if not ds.stages[s1][s2]:
+            typer.secho(f'Already unlinked from {s2} {"notebook" if s1 == "nb" else "checker"}.', fg='yellow')
+        else:
+            typer.secho(f'Unlinked from {s2} {"notebook" if s1 == "nb" else "checker"}!', fg='green')
+            ds.stages[s1][s2] = False
+    
+    if nb and chk:
+        write_error('Expected one or none of flags --notebook and --checker, but got both.')
+    if valid and test:
+        write_error('Expected one or none of flags --valid and --test, but got both.')
+    
+    flags = []
+    if nb:
+        flags.append('nb')
+    if chk:
+        flags.append('chk')
+    if valid:
+        flags.append('valid')
+    if test:
+        flags.append('test')
+    
+    if len(flags) == 0:
+        unlinkk('nb', 'valid')
+        unlinkk('nb', 'test')
+        unlinkk('chk', 'valid')
+        unlinkk('chk', 'test')
+    elif len(flags) == 1:
+        if flags[0] in ['nb', 'chk']:
+            unlinkk(flags[0], 'valid')
+            unlinkk(flags[0], 'test')
+        else:
+            unlinkk('nb', flags[0])
+            unlinkk('chk', flags[0])
+    else:
+        if nb and valid:
+            unlinkk('nb', 'valid')
+        elif nb and test:
+            unlinkk('nb', 'test')
+        elif chk and valid:
+            unlinkk('chk', 'valid')
+        elif chk and test:
+            unlinkk('chk', 'test')
+    
+    any_link = False
+    for s1 in ['nb', 'chk']:
+        for s2 in ['valid', 'test']:
+            if ds.stages[s1][s2]:
+                any_link = True
+    
+    if not any_link:
+        typer.secho('Warning:', fg='red')
+        typer.echo('This operation will leed the dataset to be completely unlinked from the task.')
+        typer.echo('Sai does not track datasets that are not linked to any stage of the task. After running this operation, the dataset folder will be kept as is, but sai will treat it as any normal directory and not a dataset.')
+        typer.echo(f'You will still be able to relink the dataset just like any normal external dataset with `sai link {ds.id}`')
+        res = typer.prompt(f'Do you wish to continue? [y]es/[n]o')
+        if type(res) != str or (res.lower() not in ['y', 'yes']):
+            typer.secho("Operation aborted", fg='red')
+            return
+    
+    dss.update(dss.dss.values())
+    
+    if not any_link:
+        typer.secho(f'./{ds.name} folder is no longer tracked and considered as a dataset by sai. You can remove it if you want.', fg='green')
+
+    Datasets(path, backend).show_warnings()
+    

sai/commands/ds/utils.py

@@ -0,0 +1,137 @@
+from ...state import resolve_backend
+from typing import Optional
+from ...utils.error_handler import warn, handle_response_error, write_error
+from ...utils.client import APIClient
+from ..sync import read_dotsai
+from pathlib import Path
+import json
+
+class Dataset:
+    def __init__(self, ds, path: Path):
+        self.id: str = ds['id']
+        self.author: str = ds['author']
+        self.url: str = ds['direct_url']
+        self.filename: str = ds['name']
+        self.orig_name: str = ds['title']
+        self.hash: str = ds['hash_md5']
+
+        self.stages = {
+            'nb': {'valid': False, 'test': False},
+            'chk': {'valid': False, 'test': False}
+        }
+        self.apply_stage(ds['type_'])
+
+        self.name = self.orig_name.split(" - ", 1)[1] if " - " in self.orig_name else self.orig_name
+        self.path = path / self.name
+        if self.path.is_file():
+            write_error(f'Dataset ./{self.name} ({self.url}) exists locally, but is a file and not a folder! Please do something with the file, or rename the dataset manually on the website.')
+        self.local = self.path.exists()
+    
+    def apply_stage(self, type_: str):
+        if type_ == 'notebook_nonfinal':
+            self.stages['nb']['valid'] = True
+        if type_ == 'notebook_final':
+            self.stages['nb']['test'] = True
+        if type_ == 'checker_nonfinal':
+            self.stages['chk']['valid'] = True
+        if type_ == 'checker_final':
+            self.stages['chk']['test'] = True
+    
+    def __str__(self):
+        return f'{self.name} ({self.url})'
+
+class Datasets:
+    def __init__(self, path: Path, backend: Optional[str]):
+        self.backend = resolve_backend(backend)
+        self.client = APIClient(self.backend)
+        self.path = path
+
+        self.dotsai = read_dotsai(path)
+        self.id = self.dotsai['id']
+        
+        task_resp = self.client.get(f'/tasks/{self.id}')
+        if task_resp.status_code != 200:
+            handle_response_error(task_resp)
+        self.task = task_resp.json()
+
+        self.dss: dict[str, Dataset] = {}
+        for ds_dict in self.task['datasets']:
+            ds = Dataset(ds_dict, path)
+            if ds.name in self.dss:
+                if ds.id == self.dss[ds.name].id:
+                    self.dss[ds.name].apply_stage(ds_dict['type_'])
+                else:
+                    write_error(f'Datasets {ds.id} and {self.dss[ds.name].id} were assigned the same name by sai ({ds.name}). Sai does not support two datasets having the same name. Please edit the names manually on the website.')
+            else:
+                self.dss[ds.name] = ds
+
+        self.missing = [ds for ds in self.dss.values() if not ds.local]
+    
+    def show_warnings(self):
+        if len(self.missing) == 1:
+            warn(f'Found a missing dataset {str(self.missing[0])} which is linked to this task, but is not pulled locally.')
+            warn(f'Use `sai ds pull --missing` to pull this dataset.')
+        elif len(self.missing) > 1:
+            warn(f'Found {len(self.missing)} missing datasets which are linked to this task, but not pulled locally:')
+            for ds in self.missing:
+                warn(str(ds))
+            warn(f'Use `sai ds pull --missing` to pull all these datasets, or `sai ds pull name/id` to pull one of them.')
+    
+    def find(self, name_or_id: str, raise_not_found=True):
+        if name_or_id in self.dss:
+            return self.dss[name_or_id]
+        
+        for ds in self.dss.values():
+            if ds.id == name_or_id:
+                return ds
+        
+        if raise_not_found:
+            write_error('Could not find dataset with specified name or id.')
+        return None
+
+    def update(self, dss: list[Dataset]):
+        task_resp = self.client.get(f'/tasks/{self.id}')
+        if task_resp.status_code != 200:
+            handle_response_error(task_resp)
+        task = task_resp.json()
+
+        new_dss = []
+        for ds in dss:
+            for s1, n1 in [('nb', 'notebook'), ('chk', 'checker')]:
+                for s2, n2 in [('valid', 'nonfinal'), ('test', 'final')]:
+                    if ds.stages[s1][s2]:
+                        new_dss.append({
+                            'file_id': ds.id,
+                            'type': f'{n1}_{n2}'
+                        })
+
+        resp = self.client.put(f'/tasks/{self.id}', data={
+            'title': task['title'],
+            'short_description': task['short_description'],
+            'slug': task['slug'],
+            'tags_ids': [tag['id'] for tag in task['tags']],
+            'difficulty': task['difficulty'],
+
+            'notebook_config': json.dumps(task['notebook_config']),
+            'checker_config': json.dumps(task['checker_config']),
+
+            'compute': task['compute'],
+            'submission_files': json.dumps(task['submission_files']),
+
+            'nonfinal_submissions_per_day': task['nonfinal_submissions_per_day'],
+            'nonfinal_notes_char_limit': task['nonfinal_notes_char_limit'],
+            'nonfinal_stdout_char_limit': task['nonfinal_stdout_char_limit'],
+            'nonfinal_stderr_char_limit': task['nonfinal_stderr_char_limit'],
+            'final_submissions_per_day': task['final_submissions_per_day'],
+            'final_notes_char_limit': task['final_notes_char_limit'],
+            'final_stdout_char_limit': task['final_stdout_char_limit'],
+            'final_stderr_char_limit': task['final_stderr_char_limit'],
+
+            'display_ranking': task['display_ranking'],
+            'score_mode': task['score_mode'],
+            'baseline_score': task['baseline_score'],
+
+            'datasets': json.dumps(new_dss)
+        })
+        if resp.status_code != 200:
+            handle_response_error(resp)

sai/commands/login.py

@@ -0,0 +1,44 @@
+import typer
+from ..state import resolve_backend, set_token
+from ..utils.error_handler import handle_response_error
+import requests
+from typing import Optional
+from ..utils.client import APIClient
+
+def login(
+    backend: Optional[str] = typer.Option(
+        None,
+        "--backend",
+        "-b",
+        help=(
+            "Use a different backend: "
+            "local (l, l1, l2, ...), "
+            "remote (r, r1, r2, ...) "
+            "or full URL (https://example.com)"
+        )
+    )
+):
+    """
+    Login on the current backend.
+
+    Note that backends like https://sprawdzai.org, remote, r, r1, r2 (which all point to the same address)
+    will store separate authentication tokens.
+    This lets you login on different accounts on r1, r2, ... or l1, l2, ... for convenience.
+
+    Default backend is remote.
+    """
+    backend = resolve_backend(backend)
+    client = APIClient(backend or None)
+
+    username = typer.prompt("Username")
+    password = typer.prompt("Password", hide_input=True)
+
+    url = f"{client.base_url}/auth/login"
+    resp = requests.post(url, json={"username": username, "password": password})
+
+    if resp.status_code == 200:
+        data = resp.json()
+        set_token(backend, data["access_token"], data["expires_in"])
+        typer.secho("Login successful.", fg=typer.colors.GREEN)
+    else:
+        handle_response_error(resp)

sai/commands/logout.py

@@ -0,0 +1,37 @@
+import typer
+from ..state import resolve_backend, clear_token, clear_all_tokens
+from typing import Optional
+
+def logout(
+    backend: Optional[str] = typer.Option(
+        None,
+        "--backend",
+        "-b",
+        help=(
+            "Use a different backend: "
+            "local (l, l1, l2, ...), "
+            "remote (r, r1, r2, ...) "
+            "or full URL (https://example.com)"
+        )
+    ),
+    all: bool = typer.Option(
+        False,
+        "--all",
+        help="Logout from all backends (clears all stored tokens)"
+    )
+):
+    """
+    Logout from the current backend or all backends.
+
+    Use --all to logout from all backends.
+    """
+
+    backend = resolve_backend(backend)
+
+    if all:
+        clear_all_tokens()
+        typer.echo("Logged out from all backends.")
+        return
+
+    clear_token(resolve_backend(backend))
+    typer.echo(f"Logged out from backend {backend}.")

sai/commands/me.py

@@ -0,0 +1,48 @@
+import typer
+from ..state import resolve_backend
+from typing import Optional
+from ..utils.error_handler import handle_response_error
+from ..utils.client import APIClient
+
+def me(
+    backend: Optional[str] = typer.Option(
+        None,
+        "--backend",
+        "-b",
+        help=(
+            "Use a different backend: "
+            "local (l, l1, l2, ...), "
+            "remote (r, r1, r2, ...) "
+            "or full URL (https://example.com)"
+        )
+    ),
+    all: bool = typer.Option(
+        False, 
+        "--all", 
+        help="Show all information"
+    )
+):
+    """
+    Show account information.
+
+    Use --all to show all available information.
+    """
+
+    backend = resolve_backend(backend)
+    client = APIClient(backend)
+
+    resp = client.get("/auth/me")
+
+    if resp.status_code == 200:
+        res = resp.json()
+        if all:
+            typer.echo('\n'.join(f'{k}: {v}' for k, v in res.items()))
+        else:
+            typer.echo(f'Username: {res["username"]} (id={res["id"]})')
+            typer.echo(f'Discord username: {res["discord_username"]} (id={res["discord_id"]})')
+            typer.echo(f'Admin: {"yes" if res["is_admin"] else "no"}')
+            typer.echo(f'Verified: {"yes" if res["verified"] else "no"}')
+            typer.echo(f'Can add datasets: {"yes" if res["can_add_datasets"] else "no"}')
+            typer.echo(f'Can see admin panel: {"yes" if res["can_see_admin_panel"] else "no"}')
+    else:
+        handle_response_error(resp)

sai/commands/open.py

@@ -0,0 +1 @@
+# opens task in browser and shows path with id