howler-api 4.0.0.dev679__tar.gz → 4.0.0.dev740__tar.gz

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: howler-api
-Version: 4.0.0.dev679
+Version: 4.0.0.dev740
 Summary: Howler - API server
 License: MIT
 Keywords: howler,alerting,gc,canada,cse-cst,cse,cst,cyber,cccs
@@ -49,7 +49,7 @@ Requires-Dist: pytz (>=2025.2,<2026.0)
 Requires-Dist: pyyaml (==6.0.3)
 Requires-Dist: redis (==4.6.0)
 Requires-Dist: requests (==2.32.5)
-Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
+Requires-Dist: tzdata (>=2026.1,<2027.0)
 Requires-Dist: validators (>=0.34,<0.36)
 Requires-Dist: wsproto (==1.2.0)
 Project-URL: Documentation, https://cybercentrecanada.github.io/howler/developer/backend/

howler_api-4.0.0.dev740/howler/actions/add_to_case.py

@@ -0,0 +1,136 @@
+from typing import Optional
+
+import chevron
+
+from howler.common.exceptions import InvalidDataException, NotFoundException
+from howler.common.loader import datastore
+from howler.odm.models.action import VALID_TRIGGERS
+from howler.services import case_service
+
+OPERATION_ID = "add_to_case"
+
+
+def execute(
+    query: str,
+    case_id: Optional[str] = None,
+    path: str = "related",
+    title_template: str = "{{howler.analytic}} ({{howler.id}})",
+    **kwargs,
+):
+    """Add matching alerts to a given case.
+
+    Args:
+        query (str): The query on which to apply this automation.
+        case_id (str): The ID of the case to add the alerts to.
+        path (str): The path within the case at which to place the alerts. Defaults to "related".
+        title_template (str): A Mustache-compatible template string used to generate each item's
+            path suffix (title). The hit's fields are available as template variables.
+            Defaults to "{{howler.analytic}} ({{howler.id}})".
+    """
+    if not case_id:
+        return [
+            {
+                "query": query,
+                "outcome": "error",
+                "title": "Missing Case ID",
+                "message": "A case_id must be provided.",
+            }
+        ]
+
+    ds = datastore()
+
+    if ds.case.get(case_id) is None:
+        return [
+            {
+                "query": query,
+                "outcome": "error",
+                "title": "Case Not Found",
+                "message": f"No case with ID '{case_id}' exists.",
+            }
+        ]
+
+    hits = ds.hit.search(query, rows=1000)["items"]
+
+    if not hits:
+        return [
+            {
+                "query": query,
+                "outcome": "skipped",
+                "title": "No Matching Hits",
+                "message": "No hits matched the query, so the action was skipped.",
+            }
+        ]
+
+    report = []
+    skipped = []
+    added = []
+
+    normalized_path = path.rstrip("/")
+
+    for hit in hits:
+        hit_data = hit.as_primitives()
+        title = chevron.render(title_template, hit_data)
+        item_path = f"{normalized_path}/{title}" if normalized_path else title
+
+        try:
+            case_service.append_case_item(
+                case_id,
+                item_type="hit",
+                item_value=hit.howler.id,
+                item_path=item_path,
+            )
+            added.append(hit.howler.id)
+        except InvalidDataException as e:
+            skipped.append(f"{hit.howler.id}: {e}")
+        except NotFoundException as e:
+            skipped.append(f"{hit.howler.id}: {e}")
+        except Exception as e:
+            skipped.append(f"{hit.howler.id}: {e}")
+
+    if added:
+        report.append(
+            {
+                "query": f"howler.id:({' OR '.join(added)})",
+                "outcome": "success",
+                "title": "Added to Case",
+                "message": f"{len(added)} alert(s) successfully added to case '{case_id}'.",
+            }
+        )
+
+    if skipped:
+        report.append(
+            {
+                "query": query,
+                "outcome": "skipped",
+                "title": "Skipped Alerts",
+                "message": f"{len(skipped)} alert(s) could not be added: {'; '.join(skipped)}",
+            }
+        )
+
+    return report
+
+
+def specification():
+    """Specify various properties of the action, such as title, descriptions, permissions and input steps."""
+    return {
+        "id": OPERATION_ID,
+        "title": "Add to Case",
+        "priority": 9,
+        "i18nKey": f"operations.{OPERATION_ID}",
+        "description": {
+            "short": "Add matching alerts to a case",
+            "long": execute.__doc__,
+        },
+        "roles": ["automation_basic"],
+        "steps": [
+            {
+                "args": {
+                    "case_id": [],
+                    "path": [],
+                    "title_template": [],
+                },
+                "options": {},
+            }
+        ],
+        "triggers": VALID_TRIGGERS,
+    }

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/api/v1/auth.py

@@ -347,23 +347,23 @@ def login(**_):  # noqa: C901
     # For sanity's sake, we throw exceptions throughout the authentication code and simply catch the exceptions here to
     # return the corresponding HTTP Code to the user
     except (OAuthError, AuthenticationException) as err:
-        logger.warning(f"Authentication failure. (U:{user} - IP:{ip}) [{err}]")
+        logger.warning("Authentication failure. (U:%s - IP:%s) [%s]", user, ip, err)
         return unauthorized(err=str(err))
 
     except AccessDeniedException as err:
-        logger.warning(f"Authorization failure. (U:{user} - IP:{ip}) [{err}]")
+        logger.warning("Authorization failure. (U:%s - IP:%s) [%s]", user, ip, err)
         return forbidden(err=err.message)
 
     except InvalidDataException as err:
         return bad_request(err=err.message or str(err))
 
     except HowlerException:
-        logger.exception(f"Internal Authentication Error. (U:{user} - IP:{ip})")
+        logger.exception("Internal Authentication Error. (U:%s - IP:%s)", user, ip)
         return internal_error(
             err="Unhandled exception occured while Authenticating. Contact your administrator.",
         )
 
-    logger.info(f"Login successful. (U:{logged_in_uname} - IP:{ip})")
+    logger.info("Login successful. (U:%s - IP:%s)", logged_in_uname, ip)
 
     xsrf_token = generate_random_secret()
 

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/api/v1/clue.py

@@ -91,7 +91,7 @@ def proxy_to_clue(path, **kwargs):
                 timeout=5 * 60,
             )
 
-    logger.debug(f"Request to clue completed in {round(time.perf_counter() - start)}ms")
+    logger.debug("Request to clue completed in %s ms", round(time.perf_counter() - start))
 
     if not response.ok:
         return bad_gateway(response.json(), err="Something went wrong when connecting to clue")

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/api/v1/hit.py

@@ -99,7 +99,7 @@ def create_hits(user: User, **kwargs):
     response_body: dict[str, list[Any]] = {"valid": [], "invalid": []}
     odms = []
     ignore_extra_values: bool = bool(request.args.get("ignore_extra_values", False, type=lambda v: v.lower() == "true"))
-    logger.debug(f"ignore_extra_values = {ignore_extra_values}")
+    logger.debug("ignore_extra_values = %s", ignore_extra_values)
     warnings = []
     for hit in hits:
         try:
@@ -108,7 +108,7 @@ def create_hits(user: User, **kwargs):
             odms.append(odm)
             warnings.extend(_warnings)
         except HowlerException as e:
-            logger.warning(f"{type(e).__name__} when saving new hit!")
+            logger.warning("%s when saving new hit!", type(e).__name__)
             logger.warning(e)
             response_body["invalid"].append({"input": hit, "error": str(e)})
 

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/api/v1/tool.py

@@ -67,7 +67,7 @@ def create_one_or_many_hits(tool_name: str, user: User, **kwargs):  # noqa: C901
     field_map = data.pop("map", None)
     hits = data.pop("hits", None)
     ignore_extra_values: bool = bool(request.args.get("ignore_extra_values", False, type=lambda v: v.lower() == "true"))
-    logger.debug(f"ignore_extra_values = {ignore_extra_values}")
+    logger.debug("ignore_extra_values = %s", ignore_extra_values)
     # Check data type
     if not isinstance(field_map, dict):
         return bad_request(err="Invalid: 'map' field is missing or invalid.")
@@ -114,7 +114,7 @@ def create_one_or_many_hits(tool_name: str, user: User, **kwargs):  # noqa: C901
                     try:
                         field_data: Optional[_Field] = hit_fields[target]
                     except KeyError:
-                        logger.debug(f"`{target}` not in hit fields")
+                        logger.debug("`%s` not in hit fields", target)
                         field_data = next(
                             (v for k, v in hit_fields.items() if get_parent_key(k) == target),
                             None,
@@ -147,7 +147,7 @@ def create_one_or_many_hits(tool_name: str, user: User, **kwargs):  # noqa: C901
                 }
             )
         except HowlerException as e:
-            logger.warning(f"{type(e).__name__} when saving {cur_id}!")
+            logger.warning("%s when saving %s!", type(e).__name__, cur_id)
             logger.warning(e)
 
             out.append({"id": None, "error": str(e)})

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/app.py

@@ -216,7 +216,7 @@ if logger.parent:
 
 # Setup APMs
 if config.core.metrics.apm_server.server_url is not None:
-    logger.info(f"Exporting application metrics to: {config.core.metrics.apm_server.server_url}")
+    logger.info("Exporting application metrics to: %s", config.core.metrics.apm_server.server_url)
     ElasticAPM(
         app,
         server_url=config.core.metrics.apm_server.server_url,

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/common/loader.py

@@ -60,9 +60,9 @@ def get_classification(yml_config: Optional[str] = None):  # noqa: C901
                 )
 
         if not yml_config_path.exists():
-            log.warning(f"{yml_config_path} does not exist!")
+            log.warning("%s does not exist!", yml_config_path)
             yml_config_path = Path("/etc") / APP_NAME.replace("-dev", "") / "classification.yml"
-            log.warning(f"Checking at {yml_config_path} instead.")
+            log.warning("Checking at %s instead.", yml_config_path)
     else:
         yml_config_path = Path(yml_config)
 

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/cronjobs/retention.py

@@ -39,7 +39,7 @@ def setup_job(sched: BaseScheduler):
 
         return
 
-    logger.debug(f"Initializing retention cronjob with cron {config.system.retention.crontab}")
+    logger.debug("Initializing retention cronjob with cron %s", config.system.retention.crontab)
 
     if DEBUG:
         _kwargs: dict[str, Any] = {"next_run_time": datetime.now()}

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/cronjobs/view_cleanup.py

@@ -68,7 +68,7 @@ def setup_job(sched: BaseScheduler):
 
         return
 
-    logger.debug(f"Initializing view cleanup cronjob with cron {config.system.view_cleanup.crontab}")
+    logger.debug("Initializing view cleanup cronjob with cron %s", config.system.view_cleanup.crontab)
 
     if DEBUG:
         _kwargs: dict[str, Any] = {"next_run_time": datetime.now()}

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/datastore/collection.py

@@ -398,7 +398,7 @@ class ESCollection(Generic[ModelType]):
             except elasticsearch.exceptions.TransportError as e:
                 err_code, msg, cause = e.args
                 if err_code == 503 or err_code == "503":
-                    logger.warning(f"Looks like index {self.name} is not ready yet, retrying...")
+                    logger.warning("Looks like index %s is not ready yet, retrying...", self.name)
                     time.sleep(min(retries, self.MAX_RETRY_BACKOFF))
                     self.datastore.connection_reset()
                     retries += 1
@@ -411,7 +411,8 @@ class ESCollection(Generic[ModelType]):
                     retries += 1
                 elif err_code == 403 or err_code == "403":
                     logger.warning(
-                        f"Elasticsearch cluster is preventing writing operations on index {self.name}, retrying..."
+                        "Elasticsearch cluster is preventing writing operations on index %s, retrying...",
+                        self.name,
                     )
                     time.sleep(min(retries, self.MAX_RETRY_BACKOFF))
                     self.datastore.connection_reset()
@@ -470,7 +471,7 @@ class ESCollection(Generic[ModelType]):
             except elasticsearch.exceptions.TransportError as e:
                 err_code, _, _ = e.args
                 if err_code == 408 or err_code == "408":
-                    logger.warning(f"Waiting for index {index} to get to status {min_status}...")
+                    logger.warning("Waiting for index %s to get to status %s...", index, min_status)
                 else:
                     raise
 
@@ -576,8 +577,9 @@ class ESCollection(Generic[ModelType]):
 
         if cur_shards > target_shards:
             logger.info(
-                f"Current shards ({cur_shards}) is bigger then target shards ({target_shards}), "
-                "we will be shrinking the index."
+                "Current shards (%s) is bigger then target shards (%s), we will be shrinking the index.",
+                cur_shards,
+                target_shards,
             )
             if cur_shards % target_shards != 0:
                 logger.info("The target shards is not a factor of the current shards, aborting...")
@@ -591,8 +593,9 @@ class ESCollection(Generic[ModelType]):
                 method = self.datastore.client.indices.shrink
         elif cur_shards < target_shards:
             logger.info(
-                f"Current shards ({cur_shards}) is smaller then target shards ({target_shards}), "
-                "we will be splitting the index."
+                "Current shards (%s) is smaller then target shards (%s), we will be splitting the index.",
+                cur_shards,
+                target_shards,
             )
             if target_shards % cur_shards != 0:
                 logger.warning("The current shards is not a factor of the target shards, aborting...")
@@ -601,13 +604,15 @@ class ESCollection(Generic[ModelType]):
                 method = self.datastore.client.indices.split
         else:
             logger.info(
-                f"Current shards ({cur_shards}) is equal to the target shards ({target_shards}), "
-                "only house keeping operations will be performed."
+                "Current shards (%s) is equal to the target shards (%s), only housekeeping operations will be "
+                "performed.",
+                cur_shards,
+                target_shards,
             )
 
         if method:
             # Before we do anything, we should make sure the source index is in a good state
-            logger.info(f"Waiting for {self.name.upper()} status to be GREEN.")
+            logger.info("Waiting for %s status to be GREEN.", self.name.upper())
             self._wait_for_status(self.name, min_status="green")
 
             # Block all indexes to be written to
@@ -618,7 +623,7 @@ class ESCollection(Generic[ModelType]):
             if not self.with_retries(self.datastore.client.indices.exists, index=temp_name):
                 # if there are specific settings to be applied to the index, apply them
                 if clone_setup_settings:
-                    logger.info(f"Rellocating index to node {target_node.upper()}.")
+                    logger.info("Relocating index to node %s.", target_node.upper())
                     self.with_retries(
                         self.datastore.client.indices.put_settings,
                         index=self.index_name,
@@ -630,7 +635,7 @@ class ESCollection(Generic[ModelType]):
                         time.sleep(1)
 
                 # Make a clone of the current index
-                logger.info(f"Cloning {self.index_name.upper()} into {temp_name.upper()}.")
+                logger.info("Cloning %s into %s.", self.index_name.upper(), temp_name.upper())
                 self._safe_index_copy(
                     self.datastore.client.indices.clone,
                     self.index_name,
@@ -640,14 +645,16 @@ class ESCollection(Generic[ModelType]):
                 )
 
             # Make 100% sure temporary index is ready
-            logger.info(f"Waiting for {temp_name.upper()} status to be GREEN.")
+            logger.info("Waiting for %s status to be GREEN.", temp_name.upper())
             self._wait_for_status(temp_name, "green")
 
             # Make sure temporary index is the alias if not already
             if self._get_current_alias(self.name) != temp_name:
                 logger.info(
-                    f"Make {temp_name.upper()} the current alias for {self.name.upper()} "
-                    f"and delete {self.index_name.upper()}."
+                    "Make %s the current alias for %s and delete %s.",
+                    temp_name.upper(),
+                    self.name.upper(),
+                    self.index_name.upper(),
                 )
                 # Make the hot index the temporary index while deleting the original index
                 alias_actions = [
@@ -658,17 +665,19 @@ class ESCollection(Generic[ModelType]):
 
             # Make sure the original index is deleted
             if self.with_retries(self.datastore.client.indices.exists, index=self.index_name):
-                logger.info(f"Delete extra {self.index_name.upper()} index.")
+                logger.info("Delete extra %s index.", self.index_name.upper())
                 self.with_retries(self.datastore.client.indices.delete, index=self.index_name)
 
             # Shrink/split the temporary index into the original index
-            logger.info(f"Perform shard fix operation from {temp_name.upper()} to {self.index_name.upper()}.")
+            logger.info("Perform shard fix operation from %s to %s.", temp_name.upper(), self.index_name.upper())
             self._safe_index_copy(method, temp_name, self.index_name, settings=settings)
 
             # Make the original index the new alias
             logger.info(
-                f"Make {self.index_name.upper()} the current alias for {self.name.upper()} "
-                f"and delete {temp_name.upper()}."
+                "Make %s the current alias for %s and delete %s.",
+                self.index_name.upper(),
+                self.name.upper(),
+                temp_name.upper(),
             )
             alias_actions = [
                 {"add": {"index": self.index_name, "alias": self.name}},
@@ -681,7 +690,7 @@ class ESCollection(Generic[ModelType]):
         self.with_retries(self.datastore.client.indices.put_settings, settings=write_unblock_settings)
 
         # Restore normal routing and replicas
-        logger.debug(f"Restore original routing table for {self.name.upper()}.")
+        logger.debug("Restore original routing table for %s.", self.name.upper())
         self.with_retries(
             self.datastore.client.indices.put_settings,
             index=self.name,
@@ -849,7 +858,7 @@ class ESCollection(Generic[ModelType]):
                     key_list.remove(row["_id"])
                     add_to_output(row["_source"], row["_id"])
                 except ValueError:
-                    logger.exception(f"MGet returned multiple documents for id: {row['_id']}")
+                    logger.exception("MGet returned multiple documents for id: %s", row["_id"])
 
         if key_list and error_on_missing:
             raise MultiKeyError(key_list, out)
@@ -2358,7 +2367,7 @@ class ESCollection(Generic[ModelType]):
         """
         # Create HOT index
         if not self.with_retries(self.datastore.client.indices.exists, index=self.name):
-            logger.debug(f"Index {self.name.upper()} does not exists. Creating it now...")
+            logger.debug("Index %s does not exist. Creating it now...", self.name.upper())
             try:
                 self.with_retries(
                     self.datastore.client.indices.create,
@@ -2369,7 +2378,7 @@ class ESCollection(Generic[ModelType]):
             except elasticsearch.exceptions.RequestError as e:
                 if "resource_already_exists_exception" not in str(e):
                     raise
-                logger.warning(f"Tried to create an index template that already exists: {self.name.upper()}")
+                logger.warning("Tried to create an index template that already exists: %s", self.name.upper())
 
             self.with_retries(
                 self.datastore.client.indices.put_alias,

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/datastore/migrations/fix_process.py

@@ -15,12 +15,12 @@ def migrate():
         logger.info("Preconditions met, continuing.")
 
         db_size = collection.search("howler.id:*", track_total_hits=True, rows=0)["total"]
-        logger.info(f"Database size pre-migration: {db_size}")
+        logger.info("Database size pre-migration: %s", db_size)
     else:
         logger.info("Preconditions not met, stopping")
         return
 
-    logger.info(f"We will delete {result['total']} hits. Continue?")
+    logger.info("We will delete %s hits. Continue?", result["total"])
     prompt_result = input("y/[n]")
 
     if prompt_result.lower() != "y":
@@ -32,7 +32,7 @@ def migrate():
     collection.commit()
 
     db_size_after = collection.search("howler.id:*", track_total_hits=True, rows=0)["total"]
-    logger.info(f"Database size post-migration: {db_size_after}")
+    logger.info("Database size post-migration: %s", db_size_after)
 
     logger.info("Migration complete")
 

howler_api-4.0.0.dev740/howler/external/README.md

@@ -0,0 +1,30 @@
+# External scripts
+
+## reindex_data.py
+
+Reindex one or more Elasticsearch indexes used by Howler.
+
+### Usage
+
+```bash
+# Reindex specific indexes (confirms each one before proceeding)
+python reindex_data.py hit user
+
+# Reindex all indexes
+python reindex_data.py --all
+
+# Skip confirmation prompts and countdown
+python reindex_data.py hit --force
+
+# Print index schema before reindexing
+python reindex_data.py hit --verbose
+```
+
+### Options
+
+| Argument    | Description                                  |
+|-------------|----------------------------------------------|
+| `indexes`   | One or more index names to reindex.          |
+| `--all`     | Reindex all indexes.                         |
+| `--force`   | Skip confirmation prompts and countdown.     |
+| `--verbose` | Print the index schema before reindexing.    |

howler_api-4.0.0.dev740/howler/external/reindex_data.py

@@ -0,0 +1,64 @@
+import argparse
+import json
+import time
+
+DELAY = 5
+INDEX_NAMES = ["analytic", "hit", "view", "template", "overview", "action", "user", "dossier"]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Reindex elasticsearch indexes.",
+        epilog=f"Valid index names: {', '.join(INDEX_NAMES)}",
+    )
+    parser.add_argument("indexes", nargs="*", help="Indexes to reindex.")
+    parser.add_argument("--all", action="store_true", help="Reindex all indexes.")
+    parser.add_argument("--force", action="store_true", help="Skip confirmation prompts and countdown.")
+    parser.add_argument("--verbose", action="store_true", help="Print index schema before reindexing.")
+    args = parser.parse_args()
+
+    if args.all and args.indexes:
+        parser.error("--all cannot be combined with positional index arguments.")
+
+    if not args.indexes and not args.all:
+        parser.error("Provide index names as arguments, or use --all.")
+
+    invalid = [name for name in args.indexes if name not in INDEX_NAMES]
+    if invalid:
+        parser.error(f"Invalid index(es): {', '.join(invalid)}. Valid options: {', '.join(INDEX_NAMES)}")
+
+    from howler.datastore.collection import ESCollection
+
+    ESCollection.IGNORE_ENSURE_COLLECTION = True
+
+    if args.force:
+        ESCollection.ENSURE_COLLECTION_WARNED = True
+
+    from howler.common import loader
+
+    ds = loader.datastore(archive_access=False)
+
+    selected = list(dict.fromkeys(INDEX_NAMES if args.all else args.indexes))
+
+    for index_name in selected:
+        collection: ESCollection = getattr(ds, index_name)
+
+        if args.verbose:
+            print(f"Index schema for '{index_name}':")
+            print(json.dumps(collection._get_index_mappings(), indent=2))
+
+        print(f"Reindexing: {', '.join(collection.index_list_full)}")
+
+        if not args.force:
+            answer = input(f"Are you sure you want to reindex '{index_name}'? [yes/NO] ")
+            if not answer.startswith("y"):
+                print("Confirmation not provided, skipping.")
+                continue
+
+            for i in range(2 * DELAY):
+                print(f"Reindexing in {2 * DELAY - i}...", end="\r")
+                time.sleep(1)
+            print()
+
+        result = collection.reindex()
+        print(f"Reindex of '{index_name}' complete. Success: {result}.")

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/helper/discover.py

@@ -51,11 +51,11 @@ def get_apps_list(discovery_url: Optional[str]) -> list[dict[str, str]]:
                             )
 
                     except Exception:
-                        logger.exception(f"Failed to parse get app: {str(app)}")
+                        logger.exception("Failed to parse get app: %s", str(app))
             else:
-                logger.warning(f"Invalid response from server for apps discovery: {discovery_url}")
+                logger.warning("Invalid response from server for apps discovery: %s", discovery_url)
         except Exception:
-            logger.exception(f"Failed to get apps from discover URL: {discovery_url}")
+            logger.exception("Failed to get apps from discover URL: %s", discovery_url)
 
         DISCO_CACHE[discovery_url] = sorted(apps, key=lambda k: k["name"])
         return sorted(apps, key=lambda k: k["name"])

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/odm/helper.py

@@ -471,7 +471,7 @@ def create_users_with_username(ds: HowlerDatastore, usernames: list[str]):
         ds.user.save(username, user_data)
 
         if "pytest" not in sys.modules:
-            logger.info(f"{username}:{username}")
+            logger.info("%s:%s", username, username)
 
     ds.user.commit()
     ds.user_avatar.commit()

{howler_api-4.0.0.dev679 → howler_api-4.0.0.dev740}/howler/odm/random_data.py

@@ -139,7 +139,7 @@ def create_users(ds):
     ds.view.save(admin_view.view_id, admin_view)
 
     if "pytest" not in sys.modules:
-        logger.info(f"\t{user_data.uname}:{admin_pass}")
+        logger.info("\t%s:%s", user_data.uname, admin_pass)
 
     user_hash = get_password_hash(user_pass)
 
@@ -186,7 +186,7 @@ def create_users(ds):
     ds.view.save(user_view.view_id, user_view)
 
     if "pytest" not in sys.modules:
-        logger.info(f"\t{user_data.uname}:{user_pass}")
+        logger.info("\t%s:%s", user_data.uname, user_pass)
 
     huey_hash = get_password_hash(huey_pass)
 
@@ -233,7 +233,7 @@ def create_users(ds):
     ds.view.save(huey_view.view_id, huey_view)
 
     if "pytest" not in sys.modules:
-        logger.info(f"\t{huey_data.uname}:{huey_pass}")
+        logger.info("\t%s:%s", huey_data.uname, huey_pass)
 
     shawnh_view = View(
         {
@@ -263,7 +263,7 @@ def create_users(ds):
     ds.view.save(shawnh_view.view_id, shawnh_view)
 
     if "pytest" not in sys.modules:
-        logger.info(f"\t{shawn_data.uname}:{shawnh_pass}")
+        logger.info("\t%s:%s", shawn_data.uname, shawnh_pass)
 
     goose_view = View(
         {
@@ -293,7 +293,7 @@ def create_users(ds):
     ds.view.save(goose_view.view_id, goose_view)
 
     if "pytest" not in sys.modules:
-        logger.info(f"\t{goose_data.uname}:{goose_pass}")
+        logger.info("\t%s:%s", goose_data.uname, goose_pass)
 
     ds.user.commit()
     ds.user_avatar.commit()
@@ -1063,7 +1063,7 @@ def create_actions(ds: HowlerDatastore, num_actions: int = 30):
 
             for step in available_operations[operation_id].specification()["steps"]:
                 for key in step["args"].keys():
-                    potential_values = step["options"].get(key, None)
+                    potential_values = step.get("options", {}).get(key, None)
                     if potential_values:
                         if isinstance(potential_values, dict):
                             try:
@@ -1189,7 +1189,7 @@ if __name__ == "__main__":
 
     for index, operations in INDEXES.items():
         if index in args:
-            logger.info(f"Creating {index}...")
+            logger.info("Creating %s...", index)
 
             # Create functions
             for create_fn in operations[1]: