future-framework 3.0.0__tar.gz → 3.0.2__tar.gz

{future_framework-3.0.0 → future_framework-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: future-framework
-Version: 3.0.0
+Version: 3.0.2
 Summary: ASGI-based framework for web APIs
 License: LICENSE
 License-File: LICENSE

{future_framework-3.0.0 → future_framework-3.0.2}/future/databases/MySQLDatabase.py

@@ -172,7 +172,6 @@ class MySQLDatabase(IDatabase):
         async with self.client.connect() as connection:
             rows = (await connection.execute(sql, {"table": blueprint.name})).mappings().all()
         existing = {row["COLUMN_NAME"] for row in rows}
-        common = [column.name for column in blueprint.columns if column.name in existing]
         temporary = f"_future_migrate_{blueprint.name}"
         backup = f"_future_backup_{blueprint.name}"
         parts = self._schema_parts(blueprint)
@@ -180,9 +179,27 @@ class MySQLDatabase(IDatabase):
             await connection.execute(text(f"DROP TABLE IF EXISTS `{temporary}`"))
             await connection.execute(text(f"DROP TABLE IF EXISTS `{backup}`"))
             await connection.execute(text(f"CREATE TABLE `{temporary}` ({', '.join(parts)})"))
-            if common:
-                columns = ", ".join(f"`{name}`" for name in common)
-                await connection.execute(text(f"INSERT INTO `{temporary}` ({columns}) SELECT {columns} FROM `{blueprint.name}`"))
+            targets = []
+            sources = []
+            backfills = {}
+            for index, column in enumerate(blueprint.columns):
+                quoted = f"`{column.name}`"
+                if column.name in existing:
+                    source = quoted
+                    if not column.is_nullable:
+                        key = f"future_backfill_{index}"
+                        source = f"COALESCE({quoted}, :{key})"
+                        backfills[key] = column.backfill_value()
+                elif not column.is_nullable:
+                    key = f"future_backfill_{index}"
+                    source = f":{key}"
+                    backfills[key] = column.backfill_value()
+                else:
+                    continue
+                targets.append(quoted)
+                sources.append(source)
+            if targets:
+                await connection.execute(text(f"INSERT INTO `{temporary}` ({', '.join(targets)}) SELECT {', '.join(sources)} FROM `{blueprint.name}`"), backfills)
             await connection.execute(text(f"RENAME TABLE `{blueprint.name}` TO `{backup}`, `{temporary}` TO `{blueprint.name}`"))
             await connection.execute(text(f"DROP TABLE `{backup}`"))
         return {"status": "updated", "table": blueprint.name, "columns": sorted(column.name for column in blueprint.columns)}

{future_framework-3.0.0 → future_framework-3.0.2}/future/databases/PostgresDatabase.py

@@ -180,15 +180,32 @@ class PostgresDatabase(IDatabase):
         async with self.client.connect() as connection:
             rows = (await connection.execute(sql, {"table": blueprint.name})).mappings().all()
         existing = {row["column_name"] for row in rows}
-        common = [column.name for column in blueprint.columns if column.name in existing]
         temporary = f"_future_{uuid4().hex[:8]}_{blueprint.name}"[:63]
         parts, indexes = self._schema_parts(blueprint)
         async with self.client.begin() as connection:
             await connection.execute(text(f'DROP TABLE IF EXISTS "{temporary}"'))
             await connection.execute(text(f'CREATE TABLE "{temporary}" ({", ".join(parts)})'))
-            if common:
-                columns = ", ".join(f'"{name}"' for name in common)
-                await connection.execute(text(f'INSERT INTO "{temporary}" ({columns}) SELECT {columns} FROM "{blueprint.name}"'))
+            targets = []
+            sources = []
+            backfills = {}
+            for index, column in enumerate(blueprint.columns):
+                quoted = f'"{column.name}"'
+                if column.name in existing:
+                    source = quoted
+                    if not column.is_nullable:
+                        key = f"future_backfill_{index}"
+                        source = f"COALESCE({quoted}, :{key})"
+                        backfills[key] = column.backfill_value()
+                elif not column.is_nullable:
+                    key = f"future_backfill_{index}"
+                    source = f":{key}"
+                    backfills[key] = column.backfill_value()
+                else:
+                    continue
+                targets.append(quoted)
+                sources.append(source)
+            if targets:
+                await connection.execute(text(f'INSERT INTO "{temporary}" ({", ".join(targets)}) SELECT {", ".join(sources)} FROM "{blueprint.name}"'), backfills)
             await connection.execute(text(f'DROP TABLE "{blueprint.name}"'))
             await connection.execute(text(f'ALTER TABLE "{temporary}" RENAME TO "{blueprint.name}"'))
             for index_name in indexes:

{future_framework-3.0.0 → future_framework-3.0.2}/future/databases/SQLiteDatabase.py

@@ -178,16 +178,33 @@ class SQLiteDatabase(IDatabase):
             rows = (await connection.execute(text(f'PRAGMA table_info("{blueprint.name}")'))).mappings().all()
         existing = {row["name"] for row in rows}
         desired = {column.name for column in blueprint.columns}
-        common = [column.name for column in blueprint.columns if column.name in existing]
         temporary = f"_future_migrate_{blueprint.name}"
         definitions, _ = self._schema_parts(blueprint)
         _, indexes = self._schema_parts(blueprint, index_table=blueprint.name)
         async with self.client.begin() as connection:
             await connection.execute(text(f'DROP TABLE IF EXISTS "{temporary}"'))
             await connection.execute(text(f'CREATE TABLE "{temporary}" ({", ".join(definitions)})'))
-            if common:
-                columns = ", ".join(f'"{name}"' for name in common)
-                await connection.execute(text(f'INSERT INTO "{temporary}" ({columns}) SELECT {columns} FROM "{blueprint.name}"'))
+            targets = []
+            sources = []
+            backfills = {}
+            for index, column in enumerate(blueprint.columns):
+                quoted = f'"{column.name}"'
+                if column.name in existing:
+                    source = quoted
+                    if not column.is_nullable:
+                        key = f"future_backfill_{index}"
+                        source = f"COALESCE({quoted}, :{key})"
+                        backfills[key] = column.backfill_value()
+                elif not column.is_nullable:
+                    key = f"future_backfill_{index}"
+                    source = f":{key}"
+                    backfills[key] = column.backfill_value()
+                else:
+                    continue
+                targets.append(quoted)
+                sources.append(source)
+            if targets:
+                await connection.execute(text(f'INSERT INTO "{temporary}" ({", ".join(targets)}) SELECT {", ".join(sources)} FROM "{blueprint.name}"'), backfills)
             await connection.execute(text(f'DROP TABLE "{blueprint.name}"'))
             await connection.execute(text(f'ALTER TABLE "{temporary}" RENAME TO "{blueprint.name}"'))
             for index_sql in indexes:

{future_framework-3.0.0 → future_framework-3.0.2}/future/migrations.py

@@ -55,6 +55,21 @@ class Column:
         self.default_value = value
         return self
 
+    def backfill_value(self):
+        if self.default_value is not None:
+            return self.default_value
+        if self.type in ("string", "text"):
+            return ""
+        if self.type == "integer":
+            return 0
+        if self.type == "float":
+            return 0.0
+        if self.type == "boolean":
+            return False
+        if self.type == "datetime":
+            return datetime(1970, 1, 1)
+        raise ValueError(f"Unsupported column type: {self.type}")
+
 
 class Blueprint:
     def __init__(self, name, connection_name, action="create"):
@@ -268,6 +283,11 @@ class MigrationGenerator:
         for field, annotation in annotations.items():
             line = self.column_line(field, annotation)
             if line is not None:
+                default_value = vars(model).get(field)
+                if default_value is not None:
+                    if isinstance(default_value, datetime):
+                        default_value = default_value.isoformat(sep=" ")
+                    line += f".default({default_value!r})"
                 lines.append(f"            {line}")
         if use_timestamps:
             lines.append("            table.timestamps()")

{future_framework-3.0.0 → future_framework-3.0.2}/future/taskscheduler.py

@@ -27,6 +27,7 @@ class ScheduledTask:
         self.jitter = task.jitter
         self.last_run: Optional[datetime] = None
         self.next_run: Optional[datetime] = None
+        self.running = False
 
         if self.start_time is None:
             self.start_time = datetime.now()
@@ -85,6 +86,7 @@ class CronScheduler:
 
     async def _run_task(self, scheduled: ScheduledTask) -> None:
         """Run a single task."""
+        scheduled.running = True
         try:
             log.debug(f"Running scheduled task '{scheduled.name}'")
             await scheduled.task.run()
@@ -99,6 +101,8 @@ class CronScheduler:
         except Exception as e:
             log.error(f"Error running scheduled task '{scheduled.name}': {e}")
             # Don't update last_run on error, so it will retry next cycle
+        finally:
+            scheduled.running = False
 
     async def _scheduler_loop(self) -> None:
         """Main scheduler loop that checks for tasks to run."""
@@ -110,7 +114,8 @@ class CronScheduler:
 
             # Check which tasks need to run
             for scheduled in self.tasks.values():
-                if scheduled.next_run and now >= scheduled.next_run:
+                if scheduled.next_run and now >= scheduled.next_run and not scheduled.running:
+                    scheduled.running = True
                     tasks_to_run.append(scheduled)
 
             # Run tasks that are due

{future_framework-3.0.0 → future_framework-3.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "future-framework"
-version = "3.0.0"
+version = "3.0.2"
 description = "ASGI-based framework for web APIs"
 authors = ["nicolaipre"]
 license = "LICENSE"