kleinkram 0.0.111__tar.gz → 0.0.114__tar.gz

{kleinkram-0.0.111 → kleinkram-0.0.114}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kleinkram
-Version: 0.0.111
+Version: 0.0.114
 Summary: A CLI for the ETH project kleinkram
 Project-URL: Homepage, https://github.com/leggedrobotics/kleinkram
 Project-URL: Issues, https://github.com/leggedrobotics/kleinkram/issues

{kleinkram-0.0.111 → kleinkram-0.0.114}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kleinkram"
-version = "0.0.111"
+version = "0.0.114"
 authors = [
   { name="Johann Schwabe", email="jschwab@ethz.ch" },
 ]

{kleinkram-0.0.111 → kleinkram-0.0.114}/src/kleinkram/auth.py

@@ -63,7 +63,6 @@ class OAuthCallbackHandler(BaseHTTPRequestHandler):
         if self.path.startswith("/cli/callback"):
             query = urllib.parse.urlparse(self.path).query
             params = urllib.parse.parse_qs(query)
-            print(params)
             self.server.tokens = {
                 AUTH_TOKEN: params.get(AUTH_TOKEN)[0],
                 REFRESH_TOKEN: params.get(REFRESH_TOKEN)[0],
@@ -108,10 +107,9 @@ class AuthenticatedClient(httpx.Client):
         if not refresh_token:
             print("No refresh token found. Please login again.")
             raise Exception("No refresh token found.")
-
+        self.cookies.set(REFRESH_TOKEN, refresh_token,)
         response = self.post(
             "/auth/refresh-token",
-            json={REFRESH_TOKEN: refresh_token},
         )
         response.raise_for_status()
         new_access_token = response.cookies.get(AUTH_TOKEN)
@@ -132,7 +130,7 @@ class AuthenticatedClient(httpx.Client):
         if response.status_code == 401:
             print("Token expired, refreshing token...")
             self.refresh_token()
-            response = super().request(method, url, *args, **kwargs)
+            response = super().request(method, self.tokenfile.endpoint + url, *args, **kwargs)
         return response
 
 
@@ -163,3 +161,8 @@ def endpoint(endpoint: Annotated[str, typer.Argument()]):
     tokenfile = TokenFile()
     tokenfile.endpoint = endpoint
     tokenfile.writeToFile()
+
+def setCliKey(key: Annotated[str, typer.Argument()]):
+    tokenfile = TokenFile()
+    tokenfile.tokens[tokenfile.endpoint][CLI_KEY] = key
+    tokenfile.writeToFile()

{kleinkram-0.0.111 → kleinkram-0.0.114}/src/kleinkram/helper.py

@@ -1,5 +1,3 @@
-import fnmatch
-import math
 import os
 import threading
 import glob
@@ -45,7 +43,9 @@ def uploadFiles(files: Dict[str, str], paths: Dict[str, str], nrThreads: int):
 def uploadFile(_queue: queue.Queue, paths: Dict[str, str], pbar: tqdm):
     while True:
         try:
-            filename, url = _queue.get(timeout=3)
+            filename, info = _queue.get(timeout=3)
+            url = info["url"]
+            uuid = info["uuid"]
             filepath = paths[filename]
             headers = {"Content-Type": "application/octet-stream"}
             with open(filepath, "rb") as f:
@@ -54,7 +54,7 @@ def uploadFile(_queue: queue.Queue, paths: Dict[str, str], pbar: tqdm):
                     response = cli.put(url, content=f, headers=headers)
                     if response.status_code == 200:
                         pbar.update(100)  # Update progress for each file
-                        client.post("/queue/confirmUpload", json={"filename": filename})
+                        client.post("/queue/confirmUpload", json={"uuid": uuid})
                     else:
                         print(f"Failed to upload {filename}. HTTP status: {response.status_code}")
             _queue.task_done()

{kleinkram-0.0.111 → kleinkram-0.0.114}/src/kleinkram/main.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timedelta
 import os
 
 import httpx
@@ -9,34 +10,40 @@ from rich.table import Table
 
 from .helper import uploadFiles, expand_and_match
 
-from .auth import login, client, endpoint
+from .auth import login, client, endpoint, setCliKey
 
 app = typer.Typer()
 projects = typer.Typer(name="projects")
-runs = typer.Typer(name="runs")
+missions = typer.Typer(name="missions")
 files = typer.Typer(name="files")
 topics = typer.Typer(name="topics")
 queue = typer.Typer(name="queue")
 user = typer.Typer(name="users")
+tagtypes = typer.Typer(name="tagtypes")
+tag = typer.Typer(name="tag")
+
 
 app.add_typer(projects)
-app.add_typer(runs)
+app.add_typer(missions)
 app.add_typer(topics)
 app.add_typer(files)
 app.add_typer(queue)
 app.add_typer(user)
+app.add_typer(tagtypes)
+app.add_typer(tag)
 app.command()(login)
 app.command()(endpoint)
+app.command()(setCliKey)
 
 
 @files.command("list")
 def list_files(
-    project: Annotated[str, typer.Option()] = None,
-    run: Annotated[str, typer.Option()] = None,
-    topics: Annotated[List[str], typer.Option()] = None,
+        project: Annotated[str, typer.Option()] = None,
+        mission: Annotated[str, typer.Option()] = None,
+        topics: Annotated[List[str], typer.Option()] = None,
 ):
     """
-    List all files with optional filters for project, run, or topics.
+    List all files with optional filters for project, mission, or topics.
     """
     try:
         url = f"/file/filteredByNames"
@@ -44,36 +51,36 @@ def list_files(
             url,
             params={
                 "projectName": project,
-                "runName": run,
+                "missionName": mission,
                 "topics": topics,
             },
         )
         response.raise_for_status()
         data = response.json()
-        runs_by_project_uuid = {}
-        files_by_run_uuid = {}
+        missions_by_project_uuid = {}
+        files_by_mission_uuid = {}
         for file in data:
-            run_uuid = file["run"]["uuid"]
-            project_uuid = file["run"]["project"]["uuid"]
-            if project_uuid not in runs_by_project_uuid:
-                runs_by_project_uuid[project_uuid] = []
-            if run_uuid not in runs_by_project_uuid[project_uuid]:
-                runs_by_project_uuid[project_uuid].append(run_uuid)
-            if run_uuid not in files_by_run_uuid:
-                files_by_run_uuid[run_uuid] = []
-            files_by_run_uuid[run_uuid].append(file)
-
-        print("Files by Run & Project:")
-        for project_uuid, runs in runs_by_project_uuid.items():
-            first_file = files_by_run_uuid[runs[0]][0]
-            print(f"* {first_file['run']['project']['name']}")
-            for run in runs:
-                print(f"  - {files_by_run_uuid[run][0]['run']['name']}")
-                for file in files_by_run_uuid[run]:
+            mission_uuid = file["mission"]["uuid"]
+            project_uuid = file["mission"]["project"]["uuid"]
+            if project_uuid not in missions_by_project_uuid:
+                missions_by_project_uuid[project_uuid] = []
+            if mission_uuid not in missions_by_project_uuid[project_uuid]:
+                missions_by_project_uuid[project_uuid].append(mission_uuid)
+            if mission_uuid not in files_by_mission_uuid:
+                files_by_mission_uuid[mission_uuid] = []
+            files_by_mission_uuid[mission_uuid].append(file)
+
+        print("Files by mission & Project:")
+        for project_uuid, missions in missions_by_project_uuid.items():
+            first_file = files_by_mission_uuid[missions[0]][0]
+            print(f"* {first_file['mission']['project']['name']}")
+            for mission in missions:
+                print(f"  - {files_by_mission_uuid[mission][0]['mission']['name']}")
+                for file in files_by_mission_uuid[mission]:
                     print(f"    - '{file['filename']}'")
 
     except httpx.HTTPError as e:
-        print(f"Failed to fetch runs: {e}")
+        print(f"Failed to fetch missions: {e}")
 
 
 @projects.command("list")
@@ -93,15 +100,16 @@ def list_projects():
         print(f"Failed to fetch projects: {e}")
 
 
-@runs.command("list")
-def list_runs(
-    project: Annotated[str, typer.Option()] = None,
+@missions.command("list")
+def list_missions(
+        project: Annotated[str, typer.Option()] = None,
+        verbose: Annotated[bool, typer.Option()] = False,
 ):
     """
-    List all runs with optional filter for project.
+    List all missions with optional filter for project.
     """
     try:
-        url = "/run"
+        url = "/mission"
         if project:
             url += f"/filteredByProjectName/{project}"
         else:
@@ -109,45 +117,58 @@ def list_runs(
         response = client.get(url)
         response.raise_for_status()
         data = response.json()
-        runs_by_project_uuid = {}
-        for run in data:
-            project_uuid = run["project"]["uuid"]
-            if project_uuid not in runs_by_project_uuid:
-                runs_by_project_uuid[project_uuid] = []
-            runs_by_project_uuid[project_uuid].append(run)
-
-        print("Runs by Project:")
-        for project_uuid, runs in runs_by_project_uuid.items():
-            print(f"* {runs_by_project_uuid[project_uuid][0]['project']['name']}")
-            for run in runs:
-                print(f"  - {run['name']}")
+        missions_by_project_uuid = {}
+        for mission in data:
+            project_uuid = mission["project"]["uuid"]
+            if project_uuid not in missions_by_project_uuid:
+                missions_by_project_uuid[project_uuid] = []
+            missions_by_project_uuid[project_uuid].append(mission)
+
+        print("missions by Project:")
+        if not verbose:
+            for project_uuid, missions in missions_by_project_uuid.items():
+                print(f"* {missions_by_project_uuid[project_uuid][0]['project']['name']}")
+                for mission in missions:
+                    print(f"  - {mission['name']}")
+        else:
+            table = Table("UUID", "name", "project", "creator", "createdAt")
+            for project_uuid, missions in missions_by_project_uuid.items():
+                for mission in missions:
+                    table.add_row(
+                        mission["uuid"],
+                        mission["name"],
+                        mission["project"]["name"],
+                        mission["creator"]["name"],
+                        mission["createdAt"],
+                    )
+            print(table)
 
     except httpx.HTTPError as e:
-        print(f"Failed to fetch runs: {e}")
+        print(f"Failed to fetch missions: {e}")
 
 
-@runs.command("byUUID")
-def run_by_uuid(
-    uuid: Annotated[str, typer.Argument()],
+@missions.command("byUUID")
+def mission_by_uuid(
+        uuid: Annotated[str, typer.Argument()],
 ):
     try:
-        url = "/run/byUUID"
+        url = "/mission/byUUID"
         response = client.get(url, params={"uuid": uuid})
         response.raise_for_status()
         data = response.json()
-        print(f"Run: {data['name']}")
+        print(f"mission: {data['name']}")
         print(f"Creator: {data['creator']['name']}")
         table = Table("Filename", "Size", "date")
         for file in data["files"]:
             table.add_row(file["filename"], f"{file['size']}", file["date"])
     except httpx.HTTPError as e:
-        print(f"Failed to fetch runs: {e}")
+        print(f"Failed to fetch missions: {e}")
 
 
 @topics.command("list")
 def topics(
-    file: Annotated[str, typer.Option()] = None,
-    full: Annotated[bool, typer.Option()] = False,
+        file: Annotated[str, typer.Option()] = None,
+        full: Annotated[bool, typer.Option()] = False,
 ):
     try:
         url = "/file/byName"
@@ -187,12 +208,12 @@ def create_project(name: Annotated[str, typer.Option()]):
 
 @app.command("upload")
 def upload(
-    path: Annotated[str, typer.Option(prompt=True)],
-    project: Annotated[str, typer.Option(prompt=True)],
-    run: Annotated[str, typer.Option(prompt=True)],
+        path: Annotated[str, typer.Option(prompt=True)],
+        project: Annotated[str, typer.Option(prompt=True)],
+        mission: Annotated[str, typer.Option(prompt=True)],
 ):
     files = expand_and_match(path)
-    filenames = list(map(lambda x: x.split("/")[-1], files))
+    filenames = list(map(lambda x: x.split("/")[-1], filter(lambda x: not os.path.isdir(x),files)))
     filepaths = {}
     for path in files:
         if not os.path.isdir(path):
@@ -209,31 +230,32 @@ def upload(
             print(f"Project not found: {project}")
             return
 
-        get_run_url = "/run/byName"
-        run_response = client.get(get_run_url, params={"name": run})
-        run_response.raise_for_status()
-        if run_response.content:
-            run_json = run_response.json()
-            if run_json["uuid"]:
+        get_mission_url = "/mission/byName"
+        mission_response = client.get(get_mission_url, params={"name": mission})
+        mission_response.raise_for_status()
+        if mission_response.content:
+            mission_json = mission_response.json()
+            if mission_json["uuid"]:
                 print(
-                    f"Run: {run_json['uuid']} already exists. Delete it or select another name."
+                    f"mission: {mission_json['uuid']} already exists. Delete it or select another name."
                 )
                 return
             print(f"Something failed, should not happen")
             return
 
-        create_run_url = "/run/create"
-        new_run = client.post(
-            create_run_url, json={"name": run, "projectUUID": project_json["uuid"]}
+        create_mission_url = "/mission/create"
+        new_mission = client.post(
+            create_mission_url, json={"name": mission, "projectUUID": project_json["uuid"]}
         )
-        new_run.raise_for_status()
-        new_run_data = new_run.json()
-        print(f"Created run: {new_run_data['name']}")
+        new_mission.raise_for_status()
+        new_mission_data = new_mission.json()
+        print(f"Created mission: {new_mission_data['name']}")
 
         get_presigned_url = "/queue/createPreSignedURLS"
+
         response_2 = client.post(
             get_presigned_url,
-            json={"filenames": filenames, "runUUID": new_run_data["uuid"]},
+            json={"filenames": filenames, "missionUUID": new_mission_data["uuid"]},
         )
         response_2.raise_for_status()
         presigned_urls = response_2.json()
@@ -260,6 +282,31 @@ def clear_queue():
         print("Operation cancelled.")
 
 
+@queue.command("list")
+def list_queue():
+    """List current Queue entities"""
+    try:
+        url = "/queue/active"
+        startDate = datetime.now().date() - timedelta(days=1)
+        response = client.get(url, params={"startDate": startDate})
+        response.raise_for_status()
+        data = response.json()
+        table = Table("UUID", "filename", "mission", "state", "origin", "createdAt")
+        for topic in data:
+            table.add_row(
+                topic["uuid"],
+                topic["filename"],
+                topic["mission"]["name"],
+                topic["state"],
+                topic["location"],
+                topic["createdAt"],
+            )
+        print(table)
+
+    except httpx.HTTPError as e:
+        print(e)
+
+
 @files.command("clear")
 def clear_queue():
     """Clear queue"""
@@ -289,7 +336,7 @@ def wipe():
         response_queue = client.delete("/queue/clear")
         response_file = client.delete("/file/clear")
         response_analysis = client.delete("/analysis/clear")
-        response_run = client.delete("/run/clear")
+        response_mission = client.delete("/mission/clear")
         response_project = client.delete("/project/clear")
 
         if response_queue.status_code >= 400:
@@ -301,9 +348,9 @@ def wipe():
         elif response_analysis.status_code >= 400:
             print("Failed to clear analysis.")
             print(response_analysis.text)
-        elif response_run.status_code >= 400:
-            print("Failed to clear runs.")
-            print(response_run.text)
+        elif response_mission.status_code >= 400:
+            print("Failed to clear missions.")
+            print(response_mission.text)
         elif response_project.status_code >= 400:
             print("Failed to clear projects.")
             print(response_project.text)
@@ -355,15 +402,67 @@ def demote(email: Annotated[str, typer.Option()]):
 
 @files.command("download")
 def download(
-    runuuid: Annotated[str, typer.Argument()],
+        missionuuid: Annotated[str, typer.Argument()],
 ):
     try:
-        response = client.get("/file/downloadWithToken", params={"uuid": runuuid})
+        response = client.get("/file/downloadWithToken", params={"uuid": missionuuid})
         response.raise_for_status()
         print(response.json())
     except:
         print("Failed to download file")
 
+@missions.command('tag')
+def addTag(
+        missionuuid: Annotated[str, typer.Argument()],
+        tagtypeuuid: Annotated[str, typer.Argument()],
+        value: Annotated[str, typer.Argument()],
+):
+    try:
+        response = client.post("/tag/addTag", json={"mission": missionuuid, "tagType": tagtypeuuid, "value": value})
+        if response.status_code < 400:
+            print("Tagged mission")
+        else:
+            print(response.json())
+            print("Failed to tag mission")
+    except:
+        print("Failed to tag mission"
+)
+
+@tagtypes.command('list')
+def tagTypes(
+        verbose: Annotated[bool, typer.Option()] = False,
+):
+    try:
+        response = client.get("/tag/all")
+        response.raise_for_status()
+        data = response.json()
+        if verbose:
+            table = Table("UUID","Name", "Datatype")
+            for tagtype in data:
+                table.add_row(tagtype["uuid"], tagtype["name"], tagtype["datatype"])
+        else:
+            table = Table("Name", "Datatype")
+            for tagtype in data:
+                table.add_row(tagtype["name"], tagtype["datatype"])
+        print(table)
+    except:
+        print("Failed to fetch tagtypes")
+
+@tag.command('delete')
+def deleteTag(
+        taguuid: Annotated[str, typer.Argument()],
+):
+    try:
+        response = client.delete("/tag/deleteTag", params={"uuid": taguuid})
+        if response.status_code < 400:
+            print("Deleted tag")
+        else:
+            print(response)
+            print("Failed to delete tag")
+    except:
+        print("Failed to delete tag"
+)
+
 
 if __name__ == "__main__":
     app()