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

plain/models/backups/clients.py

@@ -1,13 +1,20 @@
+from __future__ import annotations
+
 import gzip
 import os
 import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
 
 
 class PostgresBackupClient:
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper) -> None:
         self.connection = connection
 
-    def get_env(self):
+    def get_env(self) -> dict[str, str]:
         settings_dict = self.connection.settings_dict
         options = settings_dict.get("OPTIONS", {})
         env = {}
@@ -27,7 +34,7 @@ class PostgresBackupClient:
             env["PGSSLKEY"] = str(options.get("sslkey"))
         return env
 
-    def create_backup(self, backup_path, *, pg_dump="pg_dump"):
+    def create_backup(self, backup_path: Path, *, pg_dump: str = "pg_dump") -> None:
         settings_dict = self.connection.settings_dict
 
         args = pg_dump.split()
@@ -64,7 +71,9 @@ class PostgresBackupClient:
             cmd, env={**os.environ, **self.get_env()}, check=True, shell=True
         )
 
-    def restore_backup(self, backup_path, *, pg_restore="pg_restore", psql="psql"):
+    def restore_backup(
+        self, backup_path: Path, *, pg_restore: str = "pg_restore", psql: str = "psql"
+    ) -> None:
         settings_dict = self.connection.settings_dict
 
         host = settings_dict.get("HOST")
@@ -118,17 +127,17 @@ class PostgresBackupClient:
 
 
 class SQLiteBackupClient:
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper) -> None:
         self.connection = connection
 
-    def create_backup(self, backup_path):
+    def create_backup(self, backup_path: Path) -> None:
         self.connection.ensure_connection()
         src_conn = self.connection.connection
         dump = "\n".join(src_conn.iterdump())
         with gzip.open(backup_path, "wt") as f:
             f.write(dump)
 
-    def restore_backup(self, backup_path):
+    def restore_backup(self, backup_path: Path) -> None:
         with gzip.open(backup_path, "rt") as f:
             sql = f.read()
 

plain/models/backups/core.py

@@ -1,18 +1,29 @@
+from __future__ import annotations
+
 import datetime
 import os
+from collections.abc import Generator
 from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
 
 from plain.runtime import PLAIN_TEMP_PATH
 
-from .. import db_connection
+from .. import db_connection as _db_connection
 from .clients import PostgresBackupClient, SQLiteBackupClient
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+
+    db_connection = cast("BaseDatabaseWrapper", _db_connection)
+else:
+    db_connection = _db_connection
+
 
 class DatabaseBackups:
-    def __init__(self):
+    def __init__(self) -> None:
         self.path = PLAIN_TEMP_PATH / "backups"
 
-    def find_backups(self):
+    def find_backups(self) -> list[DatabaseBackup]:
         if not self.path.exists():
             return []
 
@@ -27,20 +38,20 @@ class DatabaseBackups:
 
         return backups
 
-    def create(self, name, **create_kwargs):
+    def create(self, name: str, **create_kwargs: Any) -> Path:
         backup = DatabaseBackup(name, backups_path=self.path)
         if backup.exists():
             raise Exception(f"Backup {name} already exists")
         backup_dir = backup.create(**create_kwargs)
         return backup_dir
 
-    def restore(self, name, **restore_kwargs):
+    def restore(self, name: str, **restore_kwargs: Any) -> None:
         backup = DatabaseBackup(name, backups_path=self.path)
         if not backup.exists():
             raise Exception(f"Backup {name} not found")
         backup.restore(**restore_kwargs)
 
-    def delete(self, name):
+    def delete(self, name: str) -> None:
         backup = DatabaseBackup(name, backups_path=self.path)
         if not backup.exists():
             raise Exception(f"Backup {name} not found")
@@ -48,17 +59,17 @@ class DatabaseBackups:
 
 
 class DatabaseBackup:
-    def __init__(self, name: str, *, backups_path: Path):
+    def __init__(self, name: str, *, backups_path: Path) -> None:
         self.name = name
         self.path = backups_path / name
 
         if not self.name:
             raise ValueError("Backup name is required")
 
-    def exists(self):
+    def exists(self) -> bool:
         return self.path.exists()
 
-    def create(self, **create_kwargs):
+    def create(self, **create_kwargs: Any) -> Path:
         self.path.mkdir(parents=True, exist_ok=True)
 
         backup_path = self.path / "default.backup"
@@ -75,7 +86,7 @@ class DatabaseBackup:
 
         return self.path
 
-    def iter_files(self):
+    def iter_files(self) -> Generator[Path, None, None]:
         for backup_file in self.path.iterdir():
             if not backup_file.is_file():
                 continue
@@ -83,7 +94,7 @@ class DatabaseBackup:
                 continue
             yield backup_file
 
-    def restore(self, **restore_kwargs):
+    def restore(self, **restore_kwargs: Any) -> None:
         for backup_file in self.iter_files():
             if db_connection.vendor == "postgresql":
                 PostgresBackupClient(db_connection).restore_backup(
@@ -95,12 +106,12 @@ class DatabaseBackup:
             else:
                 raise Exception("Unsupported database vendor")
 
-    def delete(self):
+    def delete(self) -> None:
         for backup_file in self.iter_files():
             backup_file.unlink()
 
         self.path.rmdir()
 
-    def updated_at(self):
+    def updated_at(self) -> datetime.datetime:
         mtime = os.path.getmtime(self.path)
         return datetime.datetime.fromtimestamp(mtime)