plain.models 0.49.2__py3-none-any.whl → 0.50.0__py3-none-any.whl

plain/models/backends/sqlite3/schema.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import copy
 from decimal import Decimal
+from typing import TYPE_CHECKING, Any
 
 from plain.models import register_model
 from plain.models.backends.base.schema import BaseDatabaseSchemaEditor
@@ -10,6 +13,11 @@ from plain.models.db import NotSupportedError
 from plain.models.registry import ModelsRegistry
 from plain.models.transaction import atomic
 
+if TYPE_CHECKING:
+    from plain.models.base import Model
+    from plain.models.constraints import BaseConstraint
+    from plain.models.fields import Field
+
 
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_delete_table = "DROP TABLE %(table)s"
@@ -22,7 +30,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     sql_create_unique = "CREATE UNIQUE INDEX %(name)s ON %(table)s (%(columns)s)"
     sql_delete_unique = "DROP INDEX %(name)s"
 
-    def __enter__(self):
+    def __enter__(self) -> DatabaseSchemaEditor:
         # Some SQLite schema alterations need foreign key constraints to be
         # disabled. Enforce it here for the duration of the schema edition.
         if not self.connection.disable_constraint_checking():
@@ -35,19 +43,19 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             )
         return super().__enter__()
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         self.connection.check_constraints()
         super().__exit__(exc_type, exc_value, traceback)
         self.connection.enable_constraint_checking()
 
-    def quote_value(self, value):
+    def quote_value(self, value: Any) -> str:
         # The backend "mostly works" without this function and there are use
         # cases for compiling Python without the sqlite3 libraries (e.g.
         # security hardening).
         try:
             import sqlite3
 
-            value = sqlite3.adapt(value)
+            value = sqlite3.adapt(value)  # type: ignore[call-overload]
         except ImportError:
             pass
         except sqlite3.ProgrammingError:
@@ -71,12 +79,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                 f"Cannot quote parameter value {value!r} of type {type(value)}"
             )
 
-    def prepare_default(self, value):
+    def prepare_default(self, value: Any) -> str:
         return self.quote_value(value)
 
     def _is_referenced_by_fk_constraint(
-        self, table_name, column_name=None, ignore_self=False
-    ):
+        self, table_name: str, column_name: str | None = None, ignore_self: bool = False
+    ) -> bool:
         """
         Return whether or not the provided table name is referenced by another
         one. If `column_name` is specified, only references pointing to that
@@ -98,8 +106,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         return False
 
     def alter_db_table(
-        self, model, old_db_table, new_db_table, disable_constraints=True
-    ):
+        self,
+        model: type[Model],
+        old_db_table: str,
+        new_db_table: str,
+        disable_constraints: bool = True,
+    ) -> None:
         if (
             not self.connection.features.supports_atomic_references_rename
             and disable_constraints
@@ -117,7 +129,13 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             super().alter_db_table(model, old_db_table, new_db_table)
 
-    def alter_field(self, model, old_field, new_field, strict=False):
+    def alter_field(
+        self,
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        strict: bool = False,
+    ) -> None:
         if not self._field_should_be_altered(old_field, new_field):
             return
         old_field_name = old_field.name
@@ -168,8 +186,12 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             super().alter_field(model, old_field, new_field, strict=strict)
 
     def _remake_table(
-        self, model, create_field=None, delete_field=None, alter_fields=None
-    ):
+        self,
+        model: type[Model],
+        create_field: Field | None = None,
+        delete_field: Field | None = None,
+        alter_fields: list[tuple[Field, Field]] | None = None,
+    ) -> None:
         """
         Shortcut to transform a model from old_model into new_model
 
@@ -189,8 +211,8 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # Self-referential fields must be recreated rather than copied from
         # the old model to ensure their remote_field.field_name doesn't refer
         # to an altered field.
-        def is_self_referential(f):
-            return f.is_relation and f.remote_field.model is model
+        def is_self_referential(f: Field) -> bool:
+            return f.is_relation and f.remote_field.model is model  # type: ignore[attr-defined]
 
         # Work out the new fields dict / mapping
         body = {
@@ -276,7 +298,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         meta = type("Meta", (), meta_contents)
         body_copy["Meta"] = meta
         body_copy["__module__"] = model.__module__
-        register_model(type(model._meta.object_name, model.__bases__, body_copy))
+        register_model(type(model._meta.object_name, model.__bases__, body_copy))  # type: ignore[arg-type]
 
         # Construct a model with a renamed table name.
         body_copy = copy.deepcopy(body)
@@ -291,7 +313,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         body_copy["Meta"] = meta
         body_copy["__module__"] = model.__module__
         new_model = type(f"New{model._meta.object_name}", model.__bases__, body_copy)
-        register_model(new_model)
+        register_model(new_model)  # type: ignore[arg-type]
 
         # Create a new table with the updated schema.
         self.create_model(new_model)
@@ -299,7 +321,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         # Copy data from the old table into the new table
         self.execute(
             "INSERT INTO {} ({}) SELECT {} FROM {}".format(
-                self.quote_name(new_model._meta.db_table),
+                self.quote_name(new_model._meta.db_table),  # type: ignore[attr-defined]
                 ", ".join(self.quote_name(x) for x in mapping),
                 ", ".join(mapping.values()),
                 self.quote_name(model._meta.db_table),
@@ -311,8 +333,8 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
         # Rename the new table to take way for the old
         self.alter_db_table(
-            new_model,
-            new_model._meta.db_table,
+            new_model,  # type: ignore[arg-type]
+            new_model._meta.db_table,  # type: ignore[attr-defined]
             model._meta.db_table,
             disable_constraints=False,
         )
@@ -325,7 +347,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if restore_pk_field:
             restore_pk_field.primary_key = True
 
-    def delete_model(self, model, handle_autom2m=True):
+    def delete_model(self, model: type[Model], handle_autom2m: bool = True) -> None:
         if handle_autom2m:
             super().delete_model(model)
         else:
@@ -343,7 +365,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                 ):
                     self.deferred_sql.remove(sql)
 
-    def add_field(self, model, field):
+    def add_field(self, model: type[Model], field: Field) -> None:
         """Create a field on a model."""
         if (
             # Primary keys are not supported in ALTER TABLE
@@ -360,7 +382,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             super().add_field(model, field)
 
-    def remove_field(self, model, field):
+    def remove_field(self, model: type[Model], field: Field) -> None:
         """
         Remove a field from a model. Usually involves deleting a column,
         but for M2Ms may involve deleting a table.
@@ -374,8 +396,8 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             # Primary keys, unique fields, indexed fields, and foreign keys are
             # not supported in ALTER TABLE DROP COLUMN.
             and not field.primary_key
-            and not (field.remote_field and field.db_index)
-            and not (field.remote_field and field.db_constraint)
+            and not (field.remote_field and field.db_index)  # type: ignore[attr-defined]
+            and not (field.remote_field and field.db_constraint)  # type: ignore[attr-defined]
         ):
             super().remove_field(model, field)
         # For everything else, remake.
@@ -387,15 +409,15 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
     def _alter_field(
         self,
-        model,
-        old_field,
-        new_field,
-        old_type,
-        new_type,
-        old_db_params,
-        new_db_params,
-        strict=False,
-    ):
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        old_type: str,
+        new_type: str,
+        old_db_params: dict[str, Any],
+        new_db_params: dict[str, Any],
+        strict: bool = False,
+    ) -> None:
         """Perform a "physical" (non-ManyToMany) field update."""
         # Use "ALTER TABLE ... RENAME COLUMN" if only the column name
         # changed and there aren't any constraints.
@@ -405,9 +427,9 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             and self.column_sql(model, old_field) == self.column_sql(model, new_field)
             and not (
                 old_field.remote_field
-                and old_field.db_constraint
+                and old_field.db_constraint  # type: ignore[attr-defined]
                 or new_field.remote_field
-                and new_field.db_constraint
+                and new_field.db_constraint  # type: ignore[attr-defined]
             )
         ):
             return self.execute(
@@ -440,37 +462,39 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             for related_model in related_models:
                 self._remake_table(related_model)
 
-    def _alter_many_to_many(self, model, old_field, new_field, strict):
+    def _alter_many_to_many(
+        self, model: type[Model], old_field: Field, new_field: Field, strict: bool
+    ) -> None:
         """Alter M2Ms to repoint their to= endpoints."""
         if (
-            old_field.remote_field.through._meta.db_table
-            == new_field.remote_field.through._meta.db_table
+            old_field.remote_field.through._meta.db_table  # type: ignore[attr-defined]
+            == new_field.remote_field.through._meta.db_table  # type: ignore[attr-defined]
         ):
             # The field name didn't change, but some options did, so we have to
             # propagate this altering.
             self._remake_table(
-                old_field.remote_field.through,
+                old_field.remote_field.through,  # type: ignore[attr-defined]
                 alter_fields=[
                     (
                         # The field that points to the target model is needed,
                         # so that table can be remade with the new m2m field -
                         # this is m2m_reverse_field_name().
-                        old_field.remote_field.through._meta.get_field(
-                            old_field.m2m_reverse_field_name()
+                        old_field.remote_field.through._meta.get_field(  # type: ignore[attr-defined]
+                            old_field.m2m_reverse_field_name()  # type: ignore[attr-defined]
                         ),
-                        new_field.remote_field.through._meta.get_field(
-                            new_field.m2m_reverse_field_name()
+                        new_field.remote_field.through._meta.get_field(  # type: ignore[attr-defined]
+                            new_field.m2m_reverse_field_name()  # type: ignore[attr-defined]
                         ),
                     ),
                     (
                         # The field that points to the model itself is needed,
                         # so that table can be remade with the new self field -
                         # this is m2m_field_name().
-                        old_field.remote_field.through._meta.get_field(
-                            old_field.m2m_field_name()
+                        old_field.remote_field.through._meta.get_field(  # type: ignore[attr-defined]
+                            old_field.m2m_field_name()  # type: ignore[attr-defined]
                         ),
-                        new_field.remote_field.through._meta.get_field(
-                            new_field.m2m_field_name()
+                        new_field.remote_field.through._meta.get_field(  # type: ignore[attr-defined]
+                            new_field.m2m_field_name()  # type: ignore[attr-defined]
                         ),
                     ),
                 ],
@@ -478,32 +502,32 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             return
 
         # Make a new through table
-        self.create_model(new_field.remote_field.through)
+        self.create_model(new_field.remote_field.through)  # type: ignore[attr-defined]
         # Copy the data across
         self.execute(
             "INSERT INTO {} ({}) SELECT {} FROM {}".format(
-                self.quote_name(new_field.remote_field.through._meta.db_table),
+                self.quote_name(new_field.remote_field.through._meta.db_table),  # type: ignore[attr-defined]
                 ", ".join(
                     [
                         "id",
-                        new_field.m2m_column_name(),
-                        new_field.m2m_reverse_name(),
+                        new_field.m2m_column_name(),  # type: ignore[attr-defined]
+                        new_field.m2m_reverse_name(),  # type: ignore[attr-defined]
                     ]
                 ),
                 ", ".join(
                     [
                         "id",
-                        old_field.m2m_column_name(),
-                        old_field.m2m_reverse_name(),
+                        old_field.m2m_column_name(),  # type: ignore[attr-defined]
+                        old_field.m2m_reverse_name(),  # type: ignore[attr-defined]
                     ]
                 ),
-                self.quote_name(old_field.remote_field.through._meta.db_table),
+                self.quote_name(old_field.remote_field.through._meta.db_table),  # type: ignore[attr-defined]
             )
         )
         # Delete the old through table
-        self.delete_model(old_field.remote_field.through)
+        self.delete_model(old_field.remote_field.through)  # type: ignore[attr-defined]
 
-    def add_constraint(self, model, constraint):
+    def add_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         if isinstance(constraint, UniqueConstraint) and (
             constraint.condition
             or constraint.contains_expressions
@@ -514,7 +538,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             self._remake_table(model)
 
-    def remove_constraint(self, model, constraint):
+    def remove_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         if isinstance(constraint, UniqueConstraint) and (
             constraint.condition
             or constraint.contains_expressions
@@ -525,5 +549,5 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         else:
             self._remake_table(model)
 
-    def _collate_sql(self, collation):
+    def _collate_sql(self, collation: str) -> str:
         return "COLLATE " + collation

plain/models/backends/utils.py

@@ -1,52 +1,59 @@
+from __future__ import annotations
+
 import datetime
 import decimal
 import functools
 import logging
 import time
+from collections.abc import Generator, Iterator
 from contextlib import contextmanager
 from hashlib import md5
+from typing import TYPE_CHECKING, Any
 
 from plain.models.db import NotSupportedError
 from plain.models.otel import db_span
 from plain.utils.dateparse import parse_time
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+
 logger = logging.getLogger("plain.models.backends")
 
 
 class CursorWrapper:
-    def __init__(self, cursor, db):
+    def __init__(self, cursor: Any, db: Any) -> None:
         self.cursor = cursor
         self.db = db
 
     WRAP_ERROR_ATTRS = frozenset(["fetchone", "fetchmany", "fetchall", "nextset"])
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str) -> Any:
         cursor_attr = getattr(self.cursor, attr)
         if attr in CursorWrapper.WRAP_ERROR_ATTRS:
             return self.db.wrap_database_errors(cursor_attr)
         else:
             return cursor_attr
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         with self.db.wrap_database_errors:
             yield from self.cursor
 
-    def __enter__(self):
+    def __enter__(self) -> CursorWrapper:
         return self
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(self, type: Any, value: Any, traceback: Any) -> None:
         # Close instead of passing through to avoid backend-specific behavior
         # (#17671). Catch errors liberally because errors in cleanup code
         # aren't useful.
         try:
-            self.close()
+            self.close()  # type: ignore[attr-defined]
         except self.db.Database.Error:
             pass
 
     # The following methods cannot be implemented in __getattr__, because the
     # code must run when the method is invoked, not just when it is accessed.
 
-    def callproc(self, procname, params=None, kparams=None):
+    def callproc(self, procname: str, params: Any = None, kparams: Any = None) -> Any:
         # Keyword parameters for callproc aren't supported in PEP 249, but the
         # database driver may support them (e.g. cx_Oracle).
         if kparams is not None and not self.db.features.supports_callproc_kwargs:
@@ -64,23 +71,25 @@ class CursorWrapper:
                 params = params or ()
                 return self.cursor.callproc(procname, params, kparams)
 
-    def execute(self, sql, params=None):
+    def execute(self, sql: str, params: Any = None) -> Any:
         return self._execute_with_wrappers(
             sql, params, many=False, executor=self._execute
         )
 
-    def executemany(self, sql, param_list):
+    def executemany(self, sql: str, param_list: Any) -> Any:
         return self._execute_with_wrappers(
             sql, param_list, many=True, executor=self._executemany
         )
 
-    def _execute_with_wrappers(self, sql, params, many, executor):
-        context = {"connection": self.db, "cursor": self}
+    def _execute_with_wrappers(
+        self, sql: str, params: Any, many: bool, executor: Any
+    ) -> Any:
+        context: dict[str, Any] = {"connection": self.db, "cursor": self}
         for wrapper in reversed(self.db.execute_wrappers):
             executor = functools.partial(wrapper, executor)
         return executor(sql, params, many, context)
 
-    def _execute(self, sql, params, *ignored_wrapper_args):
+    def _execute(self, sql: str, params: Any, *ignored_wrapper_args: Any) -> Any:
         # Wrap in an OpenTelemetry span with standard attributes.
         with db_span(self.db, sql, params=params):
             self.db.validate_no_broken_transaction()
@@ -90,7 +99,9 @@ class CursorWrapper:
                 else:
                     return self.cursor.execute(sql, params)
 
-    def _executemany(self, sql, param_list, *ignored_wrapper_args):
+    def _executemany(
+        self, sql: str, param_list: Any, *ignored_wrapper_args: Any
+    ) -> Any:
         with db_span(self.db, sql, many=True, params=param_list):
             self.db.validate_no_broken_transaction()
             with self.db.wrap_database_errors:
@@ -100,18 +111,22 @@ class CursorWrapper:
 class CursorDebugWrapper(CursorWrapper):
     # XXX callproc isn't instrumented at this time.
 
-    def execute(self, sql, params=None):
+    def execute(self, sql: str, params: Any = None) -> Any:
         with self.debug_sql(sql, params, use_last_executed_query=True):
             return super().execute(sql, params)
 
-    def executemany(self, sql, param_list):
+    def executemany(self, sql: str, param_list: Any) -> Any:
         with self.debug_sql(sql, param_list, many=True):
             return super().executemany(sql, param_list)
 
     @contextmanager
     def debug_sql(
-        self, sql=None, params=None, use_last_executed_query=False, many=False
-    ):
+        self,
+        sql: str | None = None,
+        params: Any = None,
+        use_last_executed_query: bool = False,
+        many: bool = False,
+    ) -> Generator[None, None, None]:
         start = time.monotonic()
         try:
             yield
@@ -121,7 +136,7 @@ class CursorDebugWrapper(CursorWrapper):
             if use_last_executed_query:
                 sql = self.db.ops.last_executed_query(self.cursor, sql, params)
             try:
-                times = len(params) if many else ""
+                times = len(params) if many else ""  # type: ignore[arg-type]
             except TypeError:
                 # params could be an iterator.
                 times = "?"
@@ -145,7 +160,9 @@ class CursorDebugWrapper(CursorWrapper):
 
 
 @contextmanager
-def debug_transaction(connection, sql):
+def debug_transaction(
+    connection: BaseDatabaseWrapper, sql: str
+) -> Generator[None, None, None]:
     start = time.monotonic()
     try:
         yield
@@ -171,7 +188,7 @@ def debug_transaction(connection, sql):
             )
 
 
-def split_tzname_delta(tzname):
+def split_tzname_delta(tzname: str) -> tuple[str, str | None, str | None]:
     """
     Split a time zone name into a 3-tuple of (name, sign, offset).
     """
@@ -188,13 +205,15 @@ def split_tzname_delta(tzname):
 ###############################################
 
 
-def typecast_date(s):
+def typecast_date(s: str | None) -> datetime.date | None:
     return (
         datetime.date(*map(int, s.split("-"))) if s else None
     )  # return None if s is null
 
 
-def typecast_time(s):  # does NOT store time zone information
+def typecast_time(
+    s: str | None,
+) -> datetime.time | None:  # does NOT store time zone information
     if not s:
         return None
     hour, minutes, seconds = s.split(":")
@@ -207,7 +226,9 @@ def typecast_time(s):  # does NOT store time zone information
     )
 
 
-def typecast_timestamp(s):  # does NOT store time zone information
+def typecast_timestamp(
+    s: str | None,
+) -> datetime.date | datetime.datetime | None:  # does NOT store time zone information
     # "2005-07-29 15:48:00.590358-05"
     # "2005-07-29 09:56:00-05"
     if not s:
@@ -243,7 +264,7 @@ def typecast_timestamp(s):  # does NOT store time zone information
 ###############################################
 
 
-def split_identifier(identifier):
+def split_identifier(identifier: str) -> tuple[str, str]:
     """
     Split an SQL identifier into a two element tuple of (namespace, name).
 
@@ -257,7 +278,7 @@ def split_identifier(identifier):
     return namespace.strip('"'), name.strip('"')
 
 
-def truncate_name(identifier, length=None, hash_len=4):
+def truncate_name(identifier: str, length: int | None = None, hash_len: int = 4) -> str:
     """
     Shorten an SQL identifier to a repeatable mangled version with the given
     length.
@@ -278,7 +299,7 @@ def truncate_name(identifier, length=None, hash_len=4):
     )
 
 
-def names_digest(*args, length):
+def names_digest(*args: str, length: int) -> str:
     """
     Generate a 32-bit digest of a set of arguments that can be used to shorten
     identifying names.
@@ -289,7 +310,9 @@ def names_digest(*args, length):
     return h.hexdigest()[:length]
 
 
-def format_number(value, max_digits, decimal_places):
+def format_number(
+    value: decimal.Decimal | None, max_digits: int | None, decimal_places: int | None
+) -> str | None:
     """
     Format a number into a string with the requisite number of digits and
     decimal places.
@@ -304,12 +327,12 @@ def format_number(value, max_digits, decimal_places):
             decimal.Decimal(1).scaleb(-decimal_places), context=context
         )
     else:
-        context.traps[decimal.Rounded] = 1
+        context.traps[decimal.Rounded] = 1  # type: ignore[assignment]
         value = context.create_decimal(value)
     return f"{value:f}"
 
 
-def strip_quotes(table_name):
+def strip_quotes(table_name: str) -> str:
     """
     Strip quotes off of quoted table names to make them safe for use in index
     names, sequence names, etc. For example '"USER"."TABLE"' (an Oracle naming

plain/models/backups/cli.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import time
 from pathlib import Path
@@ -11,13 +13,13 @@ from .core import DatabaseBackups
 
 @register_cli("backups")
 @click.group("backups")
-def cli():
+def cli() -> None:
     """Local database backups"""
     pass
 
 
 @cli.command("list")
-def list_backups():
+def list_backups() -> None:
     backups_handler = DatabaseBackups()
     backups = backups_handler.find_backups()
     if not backups:
@@ -40,7 +42,7 @@ def list_backups():
 @cli.command("create")
 @click.option("--pg-dump", default="pg_dump", envvar="PG_DUMP")
 @click.argument("backup_name", default="")
-def create_backup(backup_name, pg_dump):
+def create_backup(backup_name: str, pg_dump: str) -> None:
     backups_handler = DatabaseBackups()
 
     if not backup_name:
@@ -62,7 +64,7 @@ def create_backup(backup_name, pg_dump):
 @click.option("--latest", is_flag=True)
 @click.option("--pg-restore", default="pg_restore", envvar="PG_RESTORE")
 @click.argument("backup_name", default="")
-def restore_backup(backup_name, latest, pg_restore):
+def restore_backup(backup_name: str, latest: bool, pg_restore: str) -> None:
     backups_handler = DatabaseBackups()
 
     if backup_name and latest:
@@ -89,7 +91,7 @@ def restore_backup(backup_name, latest, pg_restore):
 
 @cli.command("delete")
 @click.argument("backup_name")
-def delete_backup(backup_name):
+def delete_backup(backup_name: str) -> None:
     backups_handler = DatabaseBackups()
     try:
         backups_handler.delete(backup_name)
@@ -101,7 +103,7 @@ def delete_backup(backup_name):
 
 @cli.command("clear")
 @click.confirmation_option(prompt="Are you sure you want to delete all backups?")
-def clear_backups():
+def clear_backups() -> None:
     backups_handler = DatabaseBackups()
     backups = backups_handler.find_backups()
     for backup in backups: