kleinkram 0.38.1.dev20241125112529__py3-none-any.whl → 0.38.1.dev20250113080249__py3-none-any.whl

tests/test_query.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from uuid import uuid4
+
+import pytest
+
+from kleinkram.api.query import InvalidMissionQuery
+from kleinkram.api.query import InvalidProjectQuery
+from kleinkram.api.query import MissionQuery
+from kleinkram.api.query import ProjectQuery
+from kleinkram.api.query import check_mission_query_is_creatable
+from kleinkram.api.query import check_project_query_is_creatable
+from kleinkram.api.query import mission_query_is_unique
+from kleinkram.api.query import project_query_is_unique
+
+
+@pytest.mark.parametrize(
+    "query, expected",
+    [
+        pytest.param(MissionQuery(), False, id="match all"),
+        pytest.param(MissionQuery(patterns=["*"]), False, id="mission name match all"),
+        pytest.param(
+            MissionQuery(patterns=["test"]),
+            False,
+            id="mission name without project",
+        ),
+        pytest.param(
+            MissionQuery(patterns=["test"], project_query=ProjectQuery()),
+            False,
+            id="mission name with non-unique project",
+        ),
+        pytest.param(
+            MissionQuery(
+                patterns=["test"],
+                project_query=ProjectQuery(ids=[uuid4()]),
+            ),
+            True,
+            id="mission name with unique project",
+        ),
+        pytest.param(
+            MissionQuery(ids=[uuid4()]),
+            True,
+            id="mission by id",
+        ),
+        pytest.param(
+            MissionQuery(ids=[uuid4(), uuid4()]),
+            False,
+            id="multiple mission ids",
+        ),
+    ],
+)
+def test_mission_query_is_unique(query, expected):
+    assert mission_query_is_unique(query) == expected
+
+
+@pytest.mark.parametrize(
+    "query, expected",
+    [
+        pytest.param(ProjectQuery(), False, id="match all"),
+        pytest.param(ProjectQuery(patterns=["*"]), False, id="project name match all"),
+        pytest.param(
+            ProjectQuery(patterns=["test"]),
+            True,
+            id="project name",
+        ),
+        pytest.param(
+            ProjectQuery(ids=[uuid4()]),
+            True,
+            id="project by id",
+        ),
+        pytest.param(
+            ProjectQuery(ids=[uuid4(), uuid4()]),
+            False,
+            id="multiple project ids",
+        ),
+    ],
+)
+def test_project_query_is_unique(query, expected):
+    assert project_query_is_unique(query) == expected
+
+
+@pytest.mark.parametrize(
+    "query, valid",
+    [
+        pytest.param(
+            MissionQuery(patterns=["test"], project_query=ProjectQuery()),
+            False,
+            id="non-unique project",
+        ),
+        pytest.param(
+            MissionQuery(
+                patterns=["test"],
+                project_query=ProjectQuery(ids=[uuid4()]),
+            ),
+            True,
+            id="valid query",
+        ),
+        pytest.param(
+            MissionQuery(ids=[uuid4()]),
+            False,
+            id="mission by id",
+        ),
+    ],
+)
+def test_check_mission_query_is_createable(query, valid):
+    if not valid:
+        with pytest.raises(InvalidMissionQuery):
+            check_mission_query_is_creatable(query)
+    else:
+        check_mission_query_is_creatable(query)
+
+
+@pytest.mark.parametrize(
+    "query, valid",
+    [
+        pytest.param(
+            ProjectQuery(patterns=["test"]),
+            True,
+            id="project name",
+        ),
+        pytest.param(
+            ProjectQuery(ids=[uuid4()]),
+            False,
+            id="project by id",
+        ),
+        pytest.param(
+            ProjectQuery(ids=[uuid4(), uuid4()]),
+            False,
+            id="multiple project ids",
+        ),
+    ],
+)
+def test_check_project_query_is_creatable(query, valid):
+    if not valid:
+        with pytest.raises(InvalidProjectQuery):
+            check_project_query_is_creatable(query)
+    else:
+        check_project_query_is_creatable(query)

tests/test_utils.py

@@ -5,15 +5,18 @@ from tempfile import TemporaryDirectory
 from uuid import uuid4
 
 import pytest
+
 from kleinkram.errors import FileTypeNotSupported
 from kleinkram.utils import b64_md5
 from kleinkram.utils import check_file_paths
-from kleinkram.utils import filtered_by_patterns
+from kleinkram.utils import check_filename_is_sanatized
 from kleinkram.utils import get_filename
 from kleinkram.utils import get_filename_map
 from kleinkram.utils import is_valid_uuid4
+from kleinkram.utils import parse_path_like
+from kleinkram.utils import parse_uuid_like
+from kleinkram.utils import singleton_list
 from kleinkram.utils import split_args
-from kleinkram.utils import to_name_or_uuid
 
 
 def test_split_args():
@@ -53,23 +56,14 @@ def test_check_file_paths():
         assert check_file_paths([exists_bag, exits_mcap]) is None
 
 
-@pytest.mark.parametrize(
-    "names, patterns, expected",
-    [
-        pytest.param(["a.bag", "b.mcap"], ["*.bag"], ["a.bag"], id="one pattern"),
-        pytest.param(["a", "b", "c"], ["*"], ["a", "b", "c"], id="match all"),
-        pytest.param(["a", "b", "c"], ["*.bag"], [], id="no match"),
-        pytest.param(
-            ["a.bag", "b.mcap"],
-            ["*.bag", "*.mcap"],
-            ["a.bag", "b.mcap"],
-            id="all match",
-        ),
-        pytest.param(["a", "b", "c"], ["a", "b"], ["a", "b"], id="full name match"),
-    ],
-)
-def test_filtered_by_patterns(names, patterns, expected):
-    assert filtered_by_patterns(names, patterns) == expected
+def test_check_filename_is_sanatized():
+    valid = "t_-est"
+    invalid = "test%"
+    too_long = "a" * 100
+
+    assert check_filename_is_sanatized(valid)
+    assert not check_filename_is_sanatized(invalid)
+    assert not check_filename_is_sanatized(too_long)
 
 
 def test_is_valid_uuid4():
@@ -119,9 +113,25 @@ def test_b64_md5():
         assert b64_md5(file) == "XrY7u+Ae7tCTyyK7j1rNww=="
 
 
-def test_to_name_or_uuid():
-    id_ = uuid4()
-    not_id = "not an id"
+def test_singleton_list() -> None:
+    assert [] == singleton_list(None)
+    assert [1] == singleton_list(1)
+    assert [[1]] == singleton_list([1])
+    assert [True] == singleton_list(True)
+
+    ob = object()
+    assert [ob] == singleton_list(ob)
+
+
+def test_parse_uuid_like() -> None:
+    _id = uuid4()
+    assert parse_uuid_like(str(_id)) == _id
+    assert parse_uuid_like(_id) == _id
+
+    with pytest.raises(ValueError):
+        parse_uuid_like("invalid")
+
 
-    assert to_name_or_uuid(str(id_)) == id_
-    assert to_name_or_uuid(not_id) == not_id
+def test_parse_path_like() -> None:
+    assert parse_path_like("test") == Path("test")
+    assert parse_path_like(Path("test")) == Path("test")

tests/test_wrappers.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from uuid import uuid4
+
+from kleinkram.api.query import FileQuery
+from kleinkram.api.query import MissionQuery
+from kleinkram.api.query import ProjectQuery
+from kleinkram.wrappers import _args_to_file_query
+from kleinkram.wrappers import _args_to_mission_query
+from kleinkram.wrappers import _args_to_project_query
+
+
+def test_args_to_project_query() -> None:
+    assert _args_to_project_query() == ProjectQuery()
+    assert _args_to_project_query(project_names=["test"]) == ProjectQuery(
+        patterns=["test"]
+    )
+
+    _id = uuid4()
+    assert _args_to_project_query(project_ids=[_id]) == ProjectQuery(ids=[_id])
+    assert _args_to_project_query(
+        project_names=["test"], project_ids=[_id]
+    ) == ProjectQuery(patterns=["test"], ids=[_id])
+    assert _args_to_project_query(project_ids=[str(_id)]) == ProjectQuery(ids=[_id])
+
+
+def test_args_to_mission_query() -> None:
+    assert _args_to_mission_query() == MissionQuery()
+    assert _args_to_mission_query(mission_names=["test"]) == MissionQuery(
+        patterns=["test"]
+    )
+
+    _id = uuid4()
+    assert _args_to_mission_query(mission_ids=[_id]) == MissionQuery(ids=[_id])
+    assert _args_to_mission_query(
+        mission_names=["test"], mission_ids=[_id]
+    ) == MissionQuery(patterns=["test"], ids=[_id])
+    assert _args_to_mission_query(mission_ids=[str(_id)]) == MissionQuery(ids=[_id])
+
+    assert _args_to_mission_query(project_names=["test"]) == MissionQuery(
+        project_query=ProjectQuery(patterns=["test"])
+    )
+    assert _args_to_mission_query(project_ids=[_id]) == MissionQuery(
+        project_query=ProjectQuery(ids=[_id])
+    )
+
+
+def test_args_to_file_query() -> None:
+    assert _args_to_file_query() == FileQuery()
+    assert _args_to_file_query(file_names=["test"]) == FileQuery(patterns=["test"])
+
+    _id = uuid4()
+    assert _args_to_file_query(file_ids=[_id]) == FileQuery(ids=[_id])
+    assert _args_to_file_query(file_names=["test"], file_ids=[_id]) == FileQuery(
+        patterns=["test"], ids=[_id]
+    )
+    assert _args_to_file_query(file_ids=[str(_id)]) == FileQuery(ids=[_id])
+
+    assert _args_to_file_query(mission_names=["test"]) == FileQuery(
+        mission_query=MissionQuery(patterns=["test"])
+    )
+    assert _args_to_file_query(mission_ids=[_id]) == FileQuery(
+        mission_query=MissionQuery(ids=[_id])
+    )
+
+    assert _args_to_file_query(project_names=["test"]) == FileQuery(
+        mission_query=MissionQuery(project_query=ProjectQuery(patterns=["test"]))
+    )
+    assert _args_to_file_query(project_ids=[_id]) == FileQuery(
+        mission_query=MissionQuery(project_query=ProjectQuery(ids=[_id]))
+    )

kleinkram/api/parsing.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-from typing import Dict
-from typing import Optional
-from uuid import UUID
-
-from kleinkram.errors import ParsingError
-from kleinkram.models import File
-from kleinkram.models import FileState
-from kleinkram.models import Mission
-from kleinkram.models import Project
-
-__all__ = [
-    "_parse_project",
-    "_parse_mission",
-    "_parse_file",
-]
-
-
-def _parse_project(project: Dict[str, Any]) -> Project:
-    try:
-        project_id = UUID(project["uuid"], version=4)
-        project_name = project["name"]
-        project_description = project["description"]
-
-        parsed = Project(
-            id=project_id, name=project_name, description=project_description
-        )
-    except Exception:
-        raise ParsingError(f"error parsing project: {project}")
-    return parsed
-
-
-def _parse_mission(
-    mission: Dict[str, Any], project: Optional[Project] = None
-) -> Mission:
-    try:
-        mission_id = UUID(mission["uuid"], version=4)
-        mission_name = mission["name"]
-
-        project_id = (
-            project.id if project else UUID(mission["project"]["uuid"], version=4)
-        )
-        project_name = project.name if project else mission["project"]["name"]
-
-        parsed = Mission(
-            id=mission_id,
-            name=mission_name,
-            project_id=project_id,
-            project_name=project_name,
-        )
-    except Exception:
-        raise ParsingError(f"error parsing mission: {mission}")
-    return parsed
-
-
-def _parse_file(file: Dict[str, Any], mission: Optional[Mission] = None) -> File:
-    try:
-        filename = file["filename"]
-        file_id = UUID(file["uuid"], version=4)
-        file_size = file["size"]
-        file_hash = file["hash"]
-
-        project_id = (
-            mission.project_id if mission else UUID(file["project"]["uuid"], version=4)
-        )
-        project_name = mission.project_name if mission else file["project"]["name"]
-
-        mission_id = mission.id if mission else UUID(file["mission"]["uuid"], version=4)
-        mission_name = mission.name if mission else file["mission"]["name"]
-
-        parsed = File(
-            id=file_id,
-            name=filename,
-            size=file_size,
-            hash=file_hash,
-            project_id=project_id,
-            project_name=project_name,
-            mission_id=mission_id,
-            mission_name=mission_name,
-            state=FileState(file["state"]),
-        )
-    except Exception:
-        raise ParsingError(f"error parsing file: {file}")
-    return parsed

kleinkram/commands/__init__.py

@@ -1 +0,0 @@
-from __future__ import annotations

kleinkram/commands/endpoint.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-import typer
-from kleinkram.auth import Config
-
-HELP = """\
-Get or set the current endpoint.
-
-The endpoint is used to determine the API server to connect to\
-(default is the API server of https://datasets.leggedrobotics.com).
-"""
-
-endpoint_typer = typer.Typer(
-    name="endpoint",
-    help=HELP,
-    no_args_is_help=True,
-    context_settings={"help_option_names": ["-h", "--help"]},
-)
-
-
-@endpoint_typer.command("set")
-def set_endpoint(endpoint: str = typer.Argument(None, help="API endpoint to use")):
-    """
-    Use this command to switch between different API endpoints.\n
-    Standard endpoints are:\n
-    - http://localhost:3000\n
-    - https://api.datasets.leggedrobotics.com\n
-    - https://api.datasets.dev.leggedrobotics.com
-    """
-
-    if not endpoint:
-        raise ValueError("No endpoint provided.")
-
-    tokenfile = Config()
-    tokenfile.endpoint = endpoint
-    tokenfile.save()
-
-    print(f"Endpoint set to: {endpoint}")
-    if tokenfile.endpoint not in tokenfile.credentials:
-        print("\nLogin with `klein login`.")
-
-
-@endpoint_typer.command("list")
-def list_endpoints():
-    """
-    Get the current endpoint
-
-    Also displays all endpoints with saved tokens.
-    """
-    config = Config()
-    print(f"Current endpoint: {config.endpoint}\n", file=sys.stderr)
-
-    if not config.credentials:
-        print("No saved credentials found.", file=sys.stderr)
-        return
-
-    print("Found Credentials for:", file=sys.stderr)
-    for ep in config.credentials.keys():
-        print(" - ", file=sys.stderr, end="", flush=True)
-        print(ep, file=sys.stdout, flush=True)

kleinkram/commands/mission.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-import typer
-from kleinkram.api.client import AuthenticatedClient
-from kleinkram.api.routes import _update_mission_metadata
-from kleinkram.errors import MissionNotFound
-from kleinkram.resources import get_missions_by_spec
-from kleinkram.resources import mission_spec_is_unique
-from kleinkram.resources import MissionSpec
-from kleinkram.resources import ProjectSpec
-from kleinkram.utils import load_metadata
-from kleinkram.utils import split_args
-
-mission_typer = typer.Typer(
-    no_args_is_help=True, context_settings={"help_option_names": ["-h", "--help"]}
-)
-
-
-UPDATE_HELP = """\
-Update a mission.
-"""
-
-NOT_IMPLEMENTED_YET = "Not implemented yet"
-
-
-@mission_typer.command(help=UPDATE_HELP)
-def update(
-    project: Optional[str] = typer.Option(
-        None, "--project", "-p", help="project id or name"
-    ),
-    mission: str = typer.Option(..., "--mission", "-m", help="mission id or name"),
-    metadata: str = typer.Option(help="path to metadata file (json or yaml)"),
-) -> None:
-    mission_ids, mission_patterns = split_args([mission])
-    project_ids, project_patterns = split_args([project] if project else [])
-
-    project_spec = ProjectSpec(ids=project_ids, patterns=project_patterns)
-    mission_spec = MissionSpec(
-        ids=mission_ids,
-        patterns=mission_patterns,
-        project_spec=project_spec,
-    )
-
-    if not mission_spec_is_unique(mission_spec):
-        raise ValueError(f"mission spec is not unique: {mission_spec}")
-
-    client = AuthenticatedClient()
-    missions = get_missions_by_spec(client, mission_spec)
-
-    if not missions:
-        raise MissionNotFound(f"Mission {mission} does not exist")
-    elif len(missions) > 1:
-        raise RuntimeError(f"Multiple missions found: {missions}")  # unreachable
-
-    metadata_dct = load_metadata(Path(metadata))
-    _update_mission_metadata(client, missions[0].id, metadata=metadata_dct)
-
-
-@mission_typer.command(help=NOT_IMPLEMENTED_YET)
-def create() -> None:
-    raise NotImplementedError("Not implemented yet")
-
-
-@mission_typer.command(help=NOT_IMPLEMENTED_YET)
-def delete() -> None:
-    raise NotImplementedError("Not implemented yet")

kleinkram/commands/project.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-import typer
-
-project_typer = typer.Typer(
-    no_args_is_help=True, context_settings={"help_option_names": ["-h", "--help"]}
-)
-
-NOT_IMPLEMENTED_YET = "Not implemented yet"
-
-
-@project_typer.command(help=NOT_IMPLEMENTED_YET)
-def update() -> None:
-    raise NotImplementedError("Not implemented yet")
-
-
-@project_typer.command(help=NOT_IMPLEMENTED_YET)
-def create() -> None:
-    raise NotImplementedError("Not implemented yet")
-
-
-@project_typer.command(help=NOT_IMPLEMENTED_YET)
-def delete() -> None:
-    raise NotImplementedError("Not implemented yet")