azul-client 9.0.24__py3-none-any.whl

azul_client/api/plugins.py

@@ -0,0 +1,49 @@
+"""Mappings for the Azul plugins API."""
+
+import logging
+from http import HTTPMethod
+
+from azul_bedrock import models_restapi
+from pydantic import TypeAdapter
+
+from azul_client.api.base_api import BaseApiHandler
+
+logger = logging.getLogger(__name__)
+
+latest_plugin_list_adapter = TypeAdapter(list[models_restapi.LatestPluginWithVersions])
+latest_plugin_status_list_adapter = TypeAdapter(list[models_restapi.PluginStatusSummary])
+
+
+class Plugins(BaseApiHandler):
+    """API for listing out the plugins currently running in Azul, their configuration and latest statuses."""
+
+    def get_all_plugins(self) -> list[models_restapi.LatestPluginWithVersions]:
+        """Read names and versions of all registered plugins."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + "/api/v0/plugins",
+            method=HTTPMethod.GET,
+            response_model=latest_plugin_list_adapter,
+            get_data_only=True,
+        )
+
+    def get_all_plugin_statuses(self) -> list[models_restapi.PluginStatusSummary]:
+        """Read names and versions of all registered plugins and count statuses.
+
+        Note - the status count is inaccurate because it doesn't filter out duplicates.
+        A duplicate is where the same binary is submitted to a plugin with a different path.
+        """
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + "/api/v0/plugins/status",
+            method=HTTPMethod.GET,
+            response_model=latest_plugin_status_list_adapter,
+            get_data_only=True,
+        )
+
+    def get_plugin(self, name: str, version: str) -> models_restapi.PluginInfo:
+        """Get all the configuration information about a specific plugin by name and version."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + f"/api/v0/plugins/{name}/versions/{version}",
+            method=HTTPMethod.GET,
+            response_model=models_restapi.PluginInfo,
+            get_data_only=True,
+        )

azul_client/api/purge.py

@@ -0,0 +1,71 @@
+"""Mappings for the Azul purge API."""
+
+import logging
+from http import HTTPMethod
+
+import pendulum
+from azul_bedrock import models_restapi
+from pendulum.parsing.exceptions import ParserError
+
+from azul_client.api.base_api import BaseApiHandler
+
+logger = logging.getLogger(__name__)
+
+
+class Purge(BaseApiHandler):
+    """API for purging files out of Azul, this API requires a user who is an admin to use it.
+
+    NOTE - Purges should not be scripted as standard practice, they have a high cost to Azul
+    and too many purges or frequent re-purging will cause instability in Azul.
+    """
+
+    def purge_submission(
+        self, track_source_references: str, *, timestamp: str, purge: bool = False
+    ) -> models_restapi.PurgeSimulation | models_restapi.PurgeResults:
+        """Purge a set of submissions (requires admin privileges).
+
+        :param str source_data_kvs: Unique identifier for the submission set (submission source + all metadata).
+        :param str binary: Sha256 Id of the binary to purge from the submission (optional).
+        :param str timestamp: Timestamp of the submission to purge (optional).
+        :param bool purge: If true, perform the purge instead of a simulation (default False).
+        """
+        params = {"purge": purge}
+        if not timestamp:
+            raise ValueError("Timestamp is required to be set and cannot be None or and empty string.")
+        try:
+            pendulum.parse(timestamp)
+        except ParserError:
+            raise ValueError(f"Timestamp has an invalid value '{timestamp}' must be a")
+        params["timestamp"] = timestamp
+
+        if purge:
+            response_model = models_restapi.PurgeResults
+        else:
+            response_model = models_restapi.PurgeSimulation
+
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + f"/api/v0/purge/submission/{track_source_references}",
+            method=HTTPMethod.DELETE,
+            response_model=response_model,
+            params=params,
+            get_data_only=True,
+        )
+
+    def purge_link(
+        self, track_link: str, *, purge: bool = False
+    ) -> models_restapi.PurgeSimulation | models_restapi.PurgeResults:
+        """Purge a manually added relationship between binaries."""
+        params = {"purge": purge}
+
+        if purge:
+            response_model = models_restapi.PurgeResults
+        else:
+            response_model = models_restapi.PurgeSimulation
+
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + f"/api/v0/purge/link/{track_link}",
+            method=HTTPMethod.DELETE,
+            response_model=response_model,
+            params=params,
+            get_data_only=True,
+        )

azul_client/api/security.py

@@ -0,0 +1,29 @@
+"""Module for interacting with security endpoints."""
+
+from http import HTTPMethod
+
+from azul_client.api.base_api import BaseApiHandler
+
+
+class Security(BaseApiHandler):
+    """Interact with binary endpoints."""
+
+    def get_security_settings(self) -> dict:
+        """Get the current Azul security settings."""
+        return self._request(method=HTTPMethod.GET, url=self.cfg.azul_url + "/api/v0/security").json()
+
+    def normalise(self, security: str) -> str:
+        """Validates and normalises a security string."""
+        return self._request(
+            method=HTTPMethod.POST, url=self.cfg.azul_url + "/api/v1/security/normalise", json={"security": security}
+        ).json()
+
+    def get_max_security_string(self, security_strings: list[str]) -> str:
+        """Get the max security from the provided security strings."""
+        return self._request(
+            method=HTTPMethod.POST, url=self.cfg.azul_url + "/api/v1/security/max", json=security_strings
+        ).json()
+
+    def get_is_user_an_admin(self) -> bool:
+        """Get a boolean value indicating if the authenticated user is an admin or not."""
+        return self._request(method=HTTPMethod.GET, url=self.cfg.azul_url + "/api/v0/security/is_admin").json()

azul_client/api/sources.py

@@ -0,0 +1,51 @@
+"""Mappings for the Azul sources API."""
+
+import logging
+from http import HTTPMethod
+
+from azul_bedrock import models_restapi
+from azul_bedrock import models_settings as azs
+from pydantic import TypeAdapter
+
+from azul_client.api.base_api import BaseApiHandler
+
+logger = logging.getLogger(__name__)
+
+
+source_dict_type_adapter = TypeAdapter(dict[str, azs.Source])
+
+
+class Sources(BaseApiHandler):
+    """API for accessing information about the sources configured in Azul."""
+
+    def get_all_sources(self) -> dict[str, azs.Source]:
+        """Get a list of all sources from Azul."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + "/api/v0/sources",
+            method=HTTPMethod.GET,
+            response_model=source_dict_type_adapter,
+            get_data_only=True,
+        )
+
+    def check_source_exists(self, source_id: str) -> bool:
+        """Check if the provided source exists in Azul."""
+        return self._generic_head_request(self.cfg.azul_url + f"/api/v0/sources/{source_id}")
+
+    def read_source(self, source_id: str) -> models_restapi.Source:
+        """Read the information for the requested source."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + f"/api/v0/sources/{source_id}",
+            method=HTTPMethod.GET,
+            response_model=models_restapi.Source,
+            get_data_only=True,
+        )
+
+    def read_source_references(self, source_id: str, *, term: str = "") -> models_restapi.References:
+        """Read source references for a source_id with an optional term query."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + f"/api/v0/sources/{source_id}/references",
+            method=HTTPMethod.GET,
+            response_model=models_restapi.References,
+            params={"term": term},
+            get_data_only=True,
+        )

azul_client/api/statistics.py

@@ -0,0 +1,23 @@
+"""Mappings for the Azul statistics API."""
+
+import logging
+from http import HTTPMethod
+
+from azul_bedrock import models_restapi
+
+from azul_client.api.base_api import BaseApiHandler
+
+logger = logging.getLogger(__name__)
+
+
+class Statistics(BaseApiHandler):
+    """API for accessing statistics about Azul from the Azul restapi."""
+
+    def get_statistics(self) -> models_restapi.StatisticSummary:
+        """Get statistics about the current state of azul."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + "/api/v0/statistics",
+            method=HTTPMethod.GET,
+            response_model=models_restapi.StatisticSummary,
+            get_data_only=True,
+        )

azul_client/api/users.py

@@ -0,0 +1,29 @@
+"""Mappings for the Azul user API."""
+
+import logging
+from http import HTTPMethod
+
+from azul_bedrock import models_restapi
+from azul_bedrock.models_auth import UserInfo
+
+from azul_client.api.base_api import BaseApiHandler
+
+logger = logging.getLogger(__name__)
+
+
+class Users(BaseApiHandler):
+    """API for accessing user information of Azul."""
+
+    def get_opensearch_user_info(self) -> models_restapi.UserAccess:
+        """Get Opensearch User info through Azul's restapi."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + "/api/v0/users/me/opensearch",
+            method=HTTPMethod.GET,
+            response_model=models_restapi.UserAccess,
+        )
+
+    def get_user_info(self) -> UserInfo:
+        """Get user information for the current Token that Azul cares about."""
+        return self._request_with_pydantic_model_response(
+            url=self.cfg.azul_url + "/api/v0/users/me", method=HTTPMethod.GET, response_model=UserInfo
+        )