openrelik-api-client 0.2.3__tar.gz → 0.2.4__tar.gz

{openrelik_api_client-0.2.3 → openrelik_api_client-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: openrelik-api-client
-Version: 0.2.3
+Version: 0.2.4
 Summary: API client that automatically handles token refresh
 Author: Johan Berggren
 Author-email: jberggren@gmail.com
@@ -9,6 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: requests_toolbelt (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown

{openrelik_api_client-0.2.3 → openrelik_api_client-0.2.4}/openrelik_api_client/api_client.py

@@ -12,14 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import tempfile
-from requests_toolbelt import MultipartEncoder
-from requests.exceptions import RequestException
-import requests
+import math
 import os
+import tempfile
+import time
 from pathlib import Path
+from typing import Any
 from uuid import uuid4
-import math
+
+import requests
+from requests.exceptions import RequestException
+from requests_toolbelt import MultipartEncoder
 
 
 class APIClient:
@@ -72,6 +75,13 @@ class APIClient:
         url = f"{self.base_url}{endpoint}"
         return self.session.delete(url, **kwargs)
 
+    def get_config(self) -> dict[str, Any]:
+        """Gets the current OpenRelik configuration."""
+        endpoint = f"{self.base_url}/config/system/"
+        response = self.session.get(endpoint)
+        response.raise_for_status()
+        return response.json()
+
     def download_file(self, file_id: int, filename: str) -> str | None:
         """Downloads a file from OpenRelik.
 
@@ -92,8 +102,7 @@ class APIClient:
         file.close()
         return file.name
 
-    def upload_file(
-        self, file_path: str, folder_id: int) -> int | None:
+    def upload_file(self, file_path: str, folder_id: int) -> int | None:
         """Uploads a file to the server.
 
         Args:
@@ -106,10 +115,13 @@ class APIClient:
         Raise:
             FileNotFoundError: if file_path is not found.
         """
+        MAX_CHUNK_RETRIES = 10  # Maximum number of retries for chunk upload
+        CHUNK_RETRY_INTERVAL = 0.5  # seconds
+
         file_id = None
         response = None
         endpoint = "/files/upload"
-        chunk_size = 1024000  # 1 MB
+        chunk_size = 10 * 1024 * 1024  # 10 MB
         resumableTotalChunks = 0
         resumableChunkNumber = 0
         resumableIdentifier = uuid4().hex
@@ -128,30 +140,46 @@ class APIClient:
             resumableTotalChunks = math.ceil(total_size / chunk_size)
             while chunk := fh.read(chunk_size):
                 resumableChunkNumber += 1
-                params = {
-                    "resumableRelativePath": resumableFilename,
-                    "resumableTotalSize": total_size,
-                    "resumableCurrentChunkSize": chunk_size,
-                    "resumableChunkSize": chunk_size,
-                    "resumableChunkNumber": resumableChunkNumber,
-                    "resumableTotalChunks": resumableTotalChunks,
-                    "resumableIdentifier": resumableIdentifier,
-                    "resumableFilename": resumableFilename,
-                    "folder_id": folder_id
-                }
-                encoder = MultipartEncoder(
-                    {"file": (file_path.name, chunk,
-                              "application/octet-stream")}
-                )
-                headers = {"Content-Type": encoder.content_type}
-                response = self.session.post(
-                    f"{self.base_url}{endpoint}",
-                    headers=headers,
-                    data=encoder.to_string(),
-                    params=params,
-                )
+                retry_count = 0
+                while retry_count < MAX_CHUNK_RETRIES:
+                    params = {
+                        "resumableRelativePath": resumableFilename,
+                        "resumableTotalSize": total_size,
+                        "resumableCurrentChunkSize": len(chunk),
+                        "resumableChunkSize": chunk_size,
+                        "resumableChunkNumber": resumableChunkNumber,
+                        "resumableTotalChunks": resumableTotalChunks,
+                        "resumableIdentifier": resumableIdentifier,
+                        "resumableFilename": resumableFilename,
+                        "folder_id": folder_id,
+                    }
+                    encoder = MultipartEncoder(
+                        {"file": (file_path.name, chunk, "application/octet-stream")}
+                    )
+                    headers = {"Content-Type": encoder.content_type}
+                    response = self.session.post(
+                        f"{self.base_url}{endpoint}",
+                        headers=headers,
+                        data=encoder.to_string(),
+                        params=params,
+                    )
+                    if response.status_code == 200 or response.status_code == 201:
+                        # Success, move to the next chunk
+                        break
+                    elif response.status_code == 503:
+                        # Server has issue saving the chunk, retry the upload.
+                        retry_count += 1
+                        time.sleep(CHUNK_RETRY_INTERVAL)
+                    elif response.status_code == 429:
+                        # Rate limit exceeded, cancel the upload and raise an error.
+                        raise RuntimeError("Upload failed, maximum retries exceeded")
+                    else:
+                        # Other errors, cancel the upload and raise an error.
+                        raise RuntimeError("Upload failed")
+
             if response and response.status_code == 201:
-                file_id = response.json().get('id')
+                file_id = response.json().get("id")
+
         return file_id
 
 
@@ -171,7 +199,7 @@ class TokenRefreshSession(requests.Session):
         if api_key:
             self.headers["x-openrelik-refresh-token"] = api_key
 
-    def request(self, method, url, **kwargs):
+    def request(self, method: str, url: str, **kwargs: dict[str, Any]) -> requests.Response:
         """Intercepts the request to handle token expiration.
 
         Args:
@@ -196,7 +224,7 @@ class TokenRefreshSession(requests.Session):
 
         return response
 
-    def _refresh_token(self):
+    def _refresh_token(self) -> bool:
         """Refreshes the access token using the refresh token."""
         refresh_url = f"{self.api_server_url}/auth/refresh"
         try:

openrelik_api_client-0.2.4/openrelik_api_client/folders.py

@@ -0,0 +1,184 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+from openrelik_api_client.api_client import APIClient
+
+
+class FoldersAPI:
+    def __init__(self, api_client: APIClient):
+        super().__init__()
+        self.api_client = api_client
+
+    def create_root_folder(self, display_name: str) -> int | None:
+        """Create a root folder.
+
+        Args:
+            display_name (str): Folder display name.
+
+        Returns:
+            int: Folder ID for the new root folder, or None otherwise.
+
+        Raises:
+            HTTPError: If the API request failed.
+        """
+        folder_id = None
+        endpoint = f"{self.api_client.base_url}/folders/"
+        params = {"display_name": display_name}
+        response = self.api_client.session.post(endpoint, json=params)
+        response.raise_for_status()
+        if response.status_code == 201:
+            folder_id = response.json().get("id")
+        return folder_id
+
+    def create_subfolder(self, folder_id: int, display_name: str) -> int | None:
+        """Create a subfolder within the given folder ID.
+
+        Args:
+            folder_id: The ID of the parent folder.
+            display_name: The name of the subfolder to check.
+
+        Returns:
+            int: Folder ID for the new root folder, or None.
+
+        Raises:
+            HTTPError: If the API request failed.
+        """
+        # Corrected: Use the passed folder_id in the endpoint URL
+        endpoint = f"{self.api_client.base_url}/folders/{folder_id}/folders/"
+        data = {"display_name": display_name}
+        response = self.api_client.session.post(endpoint, json=data)
+        response.raise_for_status()
+        # Corrected: assign to a different variable or use the return directly
+        new_folder_id = None
+        if response.status_code == 201:
+            new_folder_id = response.json().get("id")
+        return new_folder_id
+
+    def folder_exists(self, folder_id: int) -> bool:
+        """Checks if a folder with the given ID exists.
+
+        Args:
+            folder_id: The ID of the folder to check.
+
+        Returns:
+            True if the folder exists, False otherwise.
+
+        Raises:
+            HTTPError: If the API request failed.
+        """
+        endpoint = f"{self.api_client.base_url}/folders/{folder_id}"
+        response = self.api_client.session.get(endpoint)
+        response.raise_for_status()
+        return response.status_code == 200
+
+    def update_folder(
+        self, folder_id: int, folder_data: dict[str, Any]
+    ) -> dict[str, Any] | None:
+        """Updates an existing folder.
+
+        Args:
+            folder_id: The ID of the folder to update.
+            folder_data: The updated folder data.
+
+        Returns:
+            The updated folder data, or None.
+
+        Raises:
+            HTTPError: If the API request failed.
+        """
+        endpoint = f"{self.api_client.base_url}/folders/{folder_id}"
+        response = self.api_client.session.patch(endpoint, json=folder_data)
+        response.raise_for_status()
+        return response.json()
+
+    def delete_folder(self, folder_id: int) -> bool:
+        """Deletes an existing folder.
+
+        Args:
+            folder_id: The ID of the folder to update.
+
+        Returns:
+            True if the request was successful.
+
+        Raises:
+            HTTPError: If the API request failed.
+        """
+        endpoint = f"{self.api_client.base_url}/folders/{folder_id}"
+        response = self.api_client.session.delete(endpoint)
+        response.raise_for_status()
+        return response.status_code == 204
+
+    def share_folder(
+        self,
+        folder_id: int,
+        user_names: list[str] | None = None,
+        group_names: list[str] | None = None,
+        user_ids: list[int] | None = None,
+        group_ids: list[int] | None = None,
+        user_role: str | None = None,
+        group_role: str | None = None,
+    ) -> dict[str, Any] | None:
+        """Shares a folder with specified users and/or groups.
+
+        The server expects all fields in the FolderShareRequest schema to be present.
+        If user_role or group_role are not provided, they default to "viewer".
+
+        Args:
+            folder_id: The ID of the folder to share.
+            user_names: A list of usernames to share the folder with.
+            group_names: A list of group names to share the folder with.
+            user_ids: A list of user IDs to share the folder with.
+            group_ids: A list of group IDs to share the folder with.
+            user_role: The role to assign to the specified users (e.g., "viewer", "editor").
+                       Defaults to "viewer" if not provided.
+            group_role: The role to assign to the specified groups (e.g., "viewer", "editor").
+                        Defaults to "viewer" if not provided.
+
+        Returns:
+            None if the sharing operation was successful. The server returns a null body
+            which is deserialized to None.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed (e.g., folder not found,
+                                           invalid role, permission denied).
+        """
+        endpoint = f"{self.api_client.base_url}/folders/{folder_id}/roles"
+
+        # Ensure lists are not None for the payload
+        payload_user_ids = user_ids if user_ids is not None else []
+        payload_user_names = user_names if user_names is not None else []
+        payload_group_ids = group_ids if group_ids is not None else []
+        payload_group_names = group_names if group_names is not None else []
+
+        # Default roles to "viewer" if not provided, as the server schema requires these fields.
+        payload_user_role = user_role if user_role is not None else "viewer"
+        payload_group_role = group_role if group_role is not None else "viewer"
+
+        data = {
+            "user_ids": payload_user_ids,
+            "user_names": payload_user_names,
+            "group_ids": payload_group_ids,
+            "group_names": payload_group_names,
+            "user_role": payload_user_role,
+            "group_role": payload_group_role,
+        }
+        try:
+            response = self.api_client.session.post(endpoint, json=data)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            print(f"An error occurred: {e.response.json()}")
+            return None

openrelik_api_client-0.2.4/openrelik_api_client/groups.py

@@ -0,0 +1,190 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+from openrelik_api_client.api_client import APIClient
+
+
+class GroupsAPI:
+    """
+    Manages groups for Oppenrelik.
+    Provides functionalities for creating, retrieving, updating,
+    deleting groups, and managing group memberships.
+    """
+
+    def __init__(self, api_client: APIClient):
+        super().__init__()
+        self.api_client = api_client
+        self.groups_url = f"{self.api_client.base_url}/groups"
+
+    def create_group(self, name: str, description: str = "") -> dict[str, Any] | None:
+        """
+        Creates a new group.
+
+        Args:
+            name: The name of the group.
+            description: An optional description for the group.
+
+        Returns:
+            A dictionary representing the newly created group if successful,
+            None otherwise.
+
+        Raises:
+            ValueError: If the group name is empty.
+            requests.exceptions.HTTPError: If the API request failed.
+        """
+        if not name:
+            raise ValueError("Group name cannot be empty.")
+
+        endpoint = f"{self.groups_url}/"
+        data = {
+            "name": name,
+            "description": description,
+        }
+        response = self.api_client.session.post(endpoint, json=data)
+        response.raise_for_status()
+        if response.status_code == 201:
+            return response.json()
+        return None
+
+    def remove_group(self, group_name: str) -> bool:
+        """
+        Removes a group by its name.
+
+        Args:
+            group_name: The name of the group to remove.
+
+        Returns:
+            True if the group was successfully removed.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed.
+        """
+        endpoint = f"{self.groups_url}/{group_name}"
+        response = self.api_client.session.delete(endpoint)
+        response.raise_for_status()
+        return response.status_code == 204
+
+    def list_group_members(self, group_name: str) -> dict[str, Any] | None:
+        """
+        Retrieves a group by its name.
+
+        Args:
+            group_name: The name of the group to retrieve.
+
+        Returns:
+            A dictionary representing the group if found, None otherwise.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed (e.g., 404 Not Found).
+        """
+        endpoint = f"{self.groups_url}/{group_name}/users"
+        response = self.api_client.session.get(endpoint)
+        response.raise_for_status()
+        if response.status_code == 200:
+            return response.json()
+        return None
+
+    def list_groups(self) -> list[dict[str, Any]]:
+        """
+        Lists all existing groups.
+
+        Returns:
+            A list of dictionaries, where each dictionary represents a group.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed.
+        """
+        endpoint = f"{self.groups_url}/"
+        response = self.api_client.session.get(endpoint)
+        response.raise_for_status()
+        if response.status_code == 200:
+            return response.json()
+        return []
+
+    def delete_group(self, group_name: str) -> bool:
+        """
+        Deletes a group by its name.
+
+        Args:
+            group_name: The name of the group to delete.
+
+        Returns:
+            True if the group was successfully deleted.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed.
+        """
+        endpoint = f"{self.groups_url}/{group_name}"
+        response = self.api_client.session.delete(endpoint)
+        response.raise_for_status()
+        return response.status_code == 204
+
+    def add_users_to_group(self, group_name: str, users: list[str]) -> bool:
+        """
+        Adds a user to a group.
+
+        Args:
+            group_name: The name of the group.
+            users: The users to add.
+
+        Returns:
+            List of users that were added.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed (e.g., group not found, user already member).
+        """
+        endpoint = f"{self.groups_url}/{group_name}/users/"
+        response = self.api_client.session.post(endpoint, json=users)
+        response.raise_for_status()
+        return response.json()
+
+    def remove_users_from_group(self, group_name: int, users: list[str]) -> bool:
+        """
+        Removes a user from a group.
+
+        Args:
+            group_name: The name of the group.
+            users: The users to remove.
+
+        Returns:
+            List of users that were removed.
+
+        Raises:
+            requests.exceptions.HTTPError: If the API request failed (e.g., group/user not found).
+        """
+        endpoint = f"{self.groups_url}/{group_name}/users"
+        response = self.api_client.session.delete(endpoint, json=users)
+        response.raise_for_status()
+        return response.json()
+
+    def is_member(self, group_name: str, user_name: str) -> bool:
+        """
+        Checks if a user is a member of a specific group.
+
+        Args:
+            group_name: The ID of the group.
+            user_name: The ID of the user.
+
+        Returns:
+            True if the user is a member, False otherwise.
+        """
+        endpoint = f"{self.groups_url}/{group_name}/users/"
+        response = self.api_client.session.get(endpoint)
+        username = None
+        response.raise_for_status()  # Raises HTTPError for 4xx/5xx
+        for user in response.json():
+            username = user["username"]
+        return user_name == username

{openrelik_api_client-0.2.3 → openrelik_api_client-0.2.4}/openrelik_api_client/workflows.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import json
+from typing import Any
 
 from openrelik_api_client.api_client import APIClient
 
@@ -24,7 +25,8 @@ class WorkflowsAPI:
         self.folders_url = f"{self.api_client.base_url}/folders"
 
     def create_workflow(
-            self, folder_id: int, file_ids: list, template_id: int = None) -> int | None:
+        self, folder_id: int, file_ids: list, template_id: int = None
+    ) -> int | None:
         """Creates a new workflow.
 
         Args:
@@ -40,15 +42,18 @@ class WorkflowsAPI:
         """
         workflow_id = None
         endpoint = f"{self.folders_url}/{folder_id}/workflows/"
-        data = {"folder_id": folder_id,
-                "file_ids": file_ids, "template_id": template_id}
+        data = {
+            "folder_id": folder_id,
+            "file_ids": file_ids,
+            "template_id": template_id,
+        }
         response = self.api_client.session.post(endpoint, json=data)
         response.raise_for_status()
         if response.status_code == 200:
             workflow_id = response.json().get("id")
         return workflow_id
 
-    def get_workflow(self, folder_id: int, workflow_id: int):
+    def get_workflow(self, folder_id: int, workflow_id: int) -> dict[str, Any]:
         """Retrieves a workflow by ID.
 
         Args:
@@ -67,7 +72,9 @@ class WorkflowsAPI:
         if response.status_code == 200:
             return response.json()
 
-    def update_workflow(self, folder_id: int, workflow_id: int, workflow_data: dict):
+    def update_workflow(
+        self, folder_id: int, workflow_id: int, workflow_data: dict
+    ) -> dict[str, Any] | None:
         """Updates an existing workflow.
 
         Args:
@@ -107,7 +114,7 @@ class WorkflowsAPI:
         response.raise_for_status()
         return response.status_code == 204
 
-    def run_workflow(self, folder_id: int, workflow_id: int):
+    def run_workflow(self, folder_id: int, workflow_id: int) -> dict[str, Any] | None:
         """Runs an existing workflow.
 
         Args:
@@ -122,11 +129,10 @@ class WorkflowsAPI:
             HTTPError: If the API request failed.
         """
         workflow = None
-        endpoint = (
-            f"{self.folders_url}/{folder_id}/workflows/{workflow_id}/run/")
+        endpoint = f"{self.folders_url}/{folder_id}/workflows/{workflow_id}/run/"
         workflow = self.get_workflow(folder_id, workflow_id)
-        spec = json.loads(workflow.get('spec_json'))
-        data = {'workflow_spec': spec}
+        spec = json.loads(workflow.get("spec_json"))
+        data = {"workflow_spec": spec}
         response = self.api_client.session.post(endpoint, json=data)
         response.raise_for_status()
         if response.status_code == 200:

{openrelik_api_client-0.2.3 → openrelik_api_client-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openrelik-api-client"
-version = "0.2.3"
+version = "0.2.4"
 description = "API client that automatically handles token refresh"
 authors = ["Johan Berggren <jberggren@gmail.com>"]
 readme = "README.md"

openrelik_api_client-0.2.3/openrelik_api_client/folders.py

@@ -1,108 +0,0 @@
-# Copyright 2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import Any
-
-from openrelik_api_client.api_client import APIClient
-
-
-class FoldersAPI:
-
-    def __init__(self, api_client: APIClient):
-        super().__init__()
-        self.api_client = api_client
-
-    def create_root_folder(self, display_name: str) -> int | None:
-        """Create a root folder.
-
-        Args:
-            display_name (str): Folder display name.
-
-        Returns:
-            int: Folder ID for the new root folder, or None otherwise.
-
-        Raises:
-            HTTPError: If the API request failed.
-        """
-        folder_id = None
-        endpoint = f"{self.api_client.base_url}/folders/"
-        params = {"display_name": display_name}
-        response = self.api_client.session.post(endpoint, json=params)
-        response.raise_for_status()
-        if response.status_code == 201:
-            folder_id = response.json().get('id')
-        return folder_id
-
-    def create_subfolder(
-            self, folder_id: int, display_name: str) -> int | None:
-        """Create a subfolder within the given folder ID.
-
-        Args:
-            folder_id: The ID of the parent folder.
-            display_name: The name of the subfolder to check.
-
-        Returns:
-            int: Folder ID for the new root folder, or None.
-
-        Raises:
-            HTTPError: If the API request failed.
-        """
-        folder_id = None
-        endpoint = f"{self.api_client.base_url}/folders/{folder_id}/folders"
-        data = {"display_name": display_name}
-        response = self.api_client.session.post(endpoint, json=data)
-        response.raise_for_status()
-        if response.status_code == 201:
-            folder_id = response.json().get("id")
-        return folder_id
-
-    def folder_exists(self, folder_id: int) -> bool:
-        """Checks if a folder with the given ID exists.
-
-        Args:
-            folder_id: The ID of the folder to check.
-
-        Returns:
-            True if the folder exists, False otherwise.
-
-        Raises:
-            HTTPError: If the API request failed.
-        """
-        endpoint = f"{self.api_client.base_url}/folders/{folder_id}"
-        response = self.api_client.session.get(endpoint)
-        response.raise_for_status()
-        return response.status_code == 200
-
-    def update_folder(
-        self, folder_id: int, folder_data: dict[str, Any]
-    ):
-        """Updates an existing folder.
-
-        Args:
-            folder_id: The ID of the folder to update.
-            folder_data: The updated folder data.
-
-        Returns:
-            The updated folder data, or None.
-
-        Raises:
-            HTTPError: If the API request failed.
-        """
-        endpoint = f"{self.api_client.base_url}/folders/{folder_id}"
-        response = self.api_client.session.patch(
-            endpoint,
-            json=folder_data
-        )
-        response.raise_for_status()
-        return response.json()