fh-saas 0.9.5__py3-none-any.whl

fh_saas/utils_bgtsk.py

@@ -0,0 +1,112 @@
+"""Lightweight background task execution for tenant-level operations with retry logic and status tracking."""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/03_utils_bgtsk.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'TenantJob', 'BackgroundTaskManager']
+
+# %% ../nbs/03_utils_bgtsk.ipynb 2
+from datetime import datetime
+from typing import Optional, Callable, Any
+import json
+import traceback
+import asyncio
+import logging
+from starlette.background import BackgroundTask
+from fastcore.utils import *
+from fastsql.core import *
+from nbdev.showdoc import show_doc
+from .db_host import timestamp, gen_id
+
+# Module-level logger - configured by app via configure_logging()
+logger = logging.getLogger(__name__)
+
+
+# %% ../nbs/03_utils_bgtsk.ipynb 5
+class TenantJob:
+    """Tenant-level background job with retry support."""
+    id: str
+    job_type: str
+    status: str  # 'pending', 'running', 'completed', 'failed'
+    payload: str  # JSON string
+    result: str = None  # JSON string
+    error_log: str = None
+    retry_count: int = 0
+    max_retries: int = 3
+    created_at: str = None
+    started_at: str = None
+    completed_at: str = None
+
+# %% ../nbs/03_utils_bgtsk.ipynb 7
+class BackgroundTaskManager:
+    """Lightweight background task manager for tenant-level operations."""
+    
+    def __init__(self, db: Database):
+        """Initialize with tenant database."""
+        self.db = db
+        self.tenant_jobs = db.create(TenantJob, name="tenant_jobs", pk='id')
+    
+    def submit(self, job_type: str, task_func: Callable, max_retries: int = 3, **task_kwargs) -> tuple[str, BackgroundTask]:
+        """Submit a new background task for execution."""
+        job_id = gen_id()
+        job = TenantJob(
+            id=job_id,
+            job_type=job_type,
+            status='pending',
+            payload=json.dumps(task_kwargs),
+            max_retries=max_retries,
+            created_at=timestamp()
+        )
+        self.tenant_jobs.insert(job)
+        
+        bg_task = BackgroundTask(
+            self._execute_with_retry,
+            job_id=job_id,
+            task_func=task_func,
+            **task_kwargs
+        )
+        
+        return job_id, bg_task
+    
+    def _execute_with_retry(self, job_id: str, task_func: Callable, **task_kwargs):
+        """Execute task with automatic retry logic and status tracking."""
+        job = self.tenant_jobs[job_id]
+        
+        try:
+            self.tenant_jobs.update(id=job_id, status='running', started_at=timestamp())
+            result = task_func(**task_kwargs)
+            self.tenant_jobs.update(
+                id=job_id,
+                status='completed',
+                result=json.dumps(result) if result else None,
+                completed_at=timestamp()
+            )
+        except Exception as e:
+            self._handle_failure(job_id, job, e)
+    
+    def _handle_failure(self, job_id: str, job: TenantJob, error: Exception):
+        """Handle task failure with retry logic."""
+        error_msg = f"{type(error).__name__}: {str(error)}\n{traceback.format_exc()}"
+        retry_count = job.retry_count + 1
+        
+        logger.error(f"Job {job_id} ({job.job_type}) failed (attempt {retry_count}/{job.max_retries}): {error}", exc_info=True)
+        
+        if retry_count < job.max_retries:
+            self.tenant_jobs.update(id=job_id, status='pending', retry_count=retry_count, error_log=error_msg)
+        else:
+            self.tenant_jobs.update(id=job_id, status='failed', retry_count=retry_count, error_log=error_msg, completed_at=timestamp())
+    
+    def get_job(self, job_id: str) -> TenantJob:
+        """Get job status and details."""
+        return self.tenant_jobs[job_id]
+    
+    def list_jobs(self, job_type: Optional[str] = None, status: Optional[str] = None, limit: int = 100) -> list[TenantJob]:
+        """List jobs with optional filtering."""
+        where_clauses = []
+        if job_type:
+            where_clauses.append(f"job_type = '{job_type}'")
+        if status:
+            where_clauses.append(f"status = '{status}'")
+        
+        where = " AND ".join(where_clauses) if where_clauses else None
+        return self.tenant_jobs(where=where, order_by="created_at DESC", limit=limit)

fh_saas/utils_blog.py

@@ -0,0 +1,147 @@
+"""Load markdown posts with frontmatter and render to SEO-friendly HTML."""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/11_utils_blog.ipynb.
+
+# %% ../nbs/11_utils_blog.ipynb 2
+from __future__ import annotations
+import frontmatter
+import markdown
+from pathlib import Path
+from typing import List, Dict, Optional
+from datetime import datetime
+from nbdev.showdoc import show_doc
+
+# %% auto 0
+__all__ = ['PostLoader', 'MarkdownEngine']
+
+# %% ../nbs/11_utils_blog.ipynb 5
+def _generate_slug(filename: str) -> str:
+    """Generate URL-safe slug from filename"""
+    return filename.replace('.md', '').replace(' ', '-').lower()
+
+def _parse_date(date_val: any) -> Optional[datetime]:
+    """Parse date from frontmatter (handles datetime, str, None)"""
+    if isinstance(date_val, datetime):
+        return date_val
+    if isinstance(date_val, str):
+        try:
+            return datetime.fromisoformat(date_val.replace('Z', '+00:00'))
+        except:
+            return None
+    return None
+
+# %% ../nbs/11_utils_blog.ipynb 6
+class PostLoader:
+    """Load and parse markdown blog posts from filesystem"""
+    
+    def __init__(self, posts_dir: str): # Directory containing .md files
+        """Initialize PostLoader with posts directory"""
+        self.posts_dir = Path(posts_dir)
+    
+    def load_posts(self) -> List[Dict]:
+        """
+        Load all markdown posts from directory.
+        
+        Returns list of post dicts sorted by date (newest first).
+        Each post contains: title, date, slug, body, categories, author, series.
+        
+        Example:
+            ```python
+            loader = PostLoader('blog/posts')
+            posts = loader.load_posts()
+            
+            for post in posts:
+                print(f"{post['title']} - {post['slug']}")
+            ```
+        """
+        posts = []
+        
+        if not self.posts_dir.exists():
+            return posts
+        
+        for md_file in self.posts_dir.glob('*.md'):
+            post = frontmatter.load(md_file)
+            
+            posts.append({
+                'title': post.get('title', md_file.stem),
+                'date': _parse_date(post.get('date')),
+                'slug': _generate_slug(md_file.name),
+                'body': post.content,
+                'categories': post.get('categories', []),
+                'author': post.get('author'),
+                'series': post.get('series'),
+                'description': post.get('description', ''),
+                'image': post.get('image')
+            })
+        
+        # Sort by date (newest first)
+        posts.sort(key=lambda p: p['date'] or datetime.min, reverse=True)
+        return posts
+    
+    def get_post(self, slug: str) -> Optional[Dict]: # URL slug (e.g., 'my-post')
+        """
+        Get single post by slug.
+        
+        Example:
+            ```python
+            post = loader.get_post('bg0010')
+            if post:
+                print(post['title'])
+            ```
+        """
+        posts = self.load_posts()
+        return next((p for p in posts if p['slug'] == slug), None)
+
+# %% ../nbs/11_utils_blog.ipynb 10
+class MarkdownEngine:
+    """Render markdown to HTML with SEO extensions"""
+    
+    def __init__(self):
+        """Initialize markdown renderer with standard extensions"""
+        self.md = markdown.Markdown(
+            extensions=[
+                'toc',           # Table of contents
+                'fenced_code',   # ```code blocks```
+                'tables',        # Markdown tables
+                'codehilite',    # Syntax highlighting
+                'extra'          # Abbreviations, definitions, etc.
+            ],
+            extension_configs={
+                'codehilite': {
+                    'css_class': 'highlight',
+                    'linenums': False
+                }
+            }
+        )
+    
+    def render(self, content: str) -> str: # Markdown content
+        """
+        Convert markdown to HTML.
+        
+        Returns HTML string with proper semantic tags for SEO.
+        
+        Example:
+            ```python
+            engine = MarkdownEngine()
+            html = engine.render('# Hello\n\nThis is **bold**.')
+            print(html)  # <h1>Hello</h1><p>This is <strong>bold</strong>.</p>
+            ```
+        """
+        self.md.reset()  # Reset parser state
+        return self.md.convert(content)
+    
+    def get_toc(self) -> str:
+        """
+        Get table of contents HTML from last render.
+        
+        Must call render() first. Returns empty string if no headings.
+        
+        Example:
+            ```python
+            engine = MarkdownEngine()
+            html = engine.render('# Title\n## Section 1\n## Section 2')
+            toc = engine.get_toc()
+            print(toc)  # <ul><li><a href="#section-1">Section 1</a>...</li></ul>
+            ```
+        """
+        return self.md.toc if hasattr(self.md, 'toc') else ''

fh_saas/utils_db.py

@@ -0,0 +1,151 @@
+"""Atomic table and index management utilities for tenant databases."""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/15_utils_db.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'register_table', 'register_tables', 'drop_table', 'create_index', 'create_indexes', 'drop_index',
+           'table_exists']
+
+# %% ../nbs/15_utils_db.ipynb 2
+from fastsql import *
+from sqlalchemy import text
+import logging
+from typing import List, Dict, Any, Optional, Tuple, Type
+from .utils_sql import get_db_type
+from nbdev.showdoc import show_doc
+
+# Module-level logger - configured by app via configure_logging()
+logger = logging.getLogger(__name__)
+
+# %% ../nbs/15_utils_db.ipynb 5
+def register_table(tenant_db: Database, model_class: Type, table_name: str, pk: str = 'id'):
+    """Create a table from a dataclass model if it doesn't exist (atomic)."""
+    try:
+        table = tenant_db.create(model_class, name=table_name, pk=pk)
+        tenant_db.conn.commit()
+        return table
+    except Exception as e:
+        logger.error(f"Failed to create table '{table_name}': {e}", exc_info=True)
+        tenant_db.conn.rollback()
+        raise Exception(f"Failed to create table '{table_name}': {str(e)}") from e
+
+# %% ../nbs/15_utils_db.ipynb 7
+def register_tables(tenant_db: Database, models: List[Tuple[Type, str, str]]) -> Dict[str, Any]:
+    """Create multiple tables atomically (all succeed or all rollback)."""
+    current_table = None
+    try:
+        tables = {}
+        for model_class, table_name, pk in models:
+            current_table = table_name
+            tables[table_name] = tenant_db.create(model_class, name=table_name, pk=pk)
+        tenant_db.conn.commit()
+        return tables
+    except Exception as e:
+        logger.error(f"Failed to create table '{current_table}': {e}", exc_info=True)
+        tenant_db.conn.rollback()
+        raise Exception(f"Failed to create table '{current_table}': {str(e)}") from e
+
+# %% ../nbs/15_utils_db.ipynb 10
+def drop_table(tenant_db: Database, table_name: str) -> None:
+    """Drop a table if it exists (atomic operation)."""
+    sql = f"DROP TABLE IF EXISTS {table_name}"
+    try:
+        tenant_db.conn.execute(text(sql))
+        tenant_db.conn.commit()
+    except Exception as e:
+        logger.error(f"Failed to drop table '{table_name}': {e}", exc_info=True)
+        tenant_db.conn.rollback()
+        raise Exception(f"Failed to drop table '{table_name}': {str(e)}") from e
+
+# %% ../nbs/15_utils_db.ipynb 13
+def create_index(tenant_db: Database, table_name: str, columns: List[str], 
+                 unique: bool = False, index_name: str = None) -> None:
+    """Create an index on a table if it doesn't exist (atomic operation)."""
+    # Auto-generate index name if not provided
+    if index_name is None:
+        index_name = f"idx_{table_name}_{'_'.join(columns)}"
+    
+    unique_clause = "UNIQUE " if unique else ""
+    columns_clause = ", ".join(columns)
+    
+    # CREATE INDEX IF NOT EXISTS works for both PostgreSQL and SQLite
+    sql = f"CREATE {unique_clause}INDEX IF NOT EXISTS {index_name} ON {table_name} ({columns_clause})"
+    
+    try:
+        tenant_db.conn.execute(text(sql))
+        tenant_db.conn.commit()
+    except Exception as e:
+        logger.error(f"Failed to create index '{index_name}' on '{table_name}': {e}", exc_info=True)
+        tenant_db.conn.rollback()
+        raise Exception(f"Failed to create index '{index_name}' on '{table_name}': {str(e)}") from e
+
+# %% ../nbs/15_utils_db.ipynb 15
+def create_indexes(tenant_db: Database, indexes: List[Tuple[str, List[str], bool, Optional[str]]]) -> None:
+    """Create multiple indexes atomically (all succeed or all rollback)."""
+    current_index = None
+    current_table = None
+    try:
+        for table_name, columns, unique, index_name in indexes:
+            current_table = table_name
+            # Auto-generate index name if not provided
+            if index_name is None:
+                index_name = f"idx_{table_name}_{'_'.join(columns)}"
+            current_index = index_name
+            
+            unique_clause = "UNIQUE " if unique else ""
+            columns_clause = ", ".join(columns)
+            sql = f"CREATE {unique_clause}INDEX IF NOT EXISTS {index_name} ON {table_name} ({columns_clause})"
+            tenant_db.conn.execute(text(sql))
+        
+        tenant_db.conn.commit()
+    except Exception as e:
+        logger.error(f"Failed to create index '{current_index}' on '{current_table}': {e}", exc_info=True)
+        tenant_db.conn.rollback()
+        raise Exception(f"Failed to create index '{current_index}' on '{current_table}': {str(e)}") from e
+
+# %% ../nbs/15_utils_db.ipynb 18
+def drop_index(tenant_db: Database, index_name: str, table_name: str = None) -> None:
+    """Drop an index if it exists (atomic operation)."""
+    db_type = get_db_type()
+    
+    if db_type == "POSTGRESQL":
+        # PostgreSQL: DROP INDEX IF EXISTS index_name
+        sql = f"DROP INDEX IF EXISTS {index_name}"
+    else:
+        # SQLite: DROP INDEX IF EXISTS index_name
+        sql = f"DROP INDEX IF EXISTS {index_name}"
+    
+    try:
+        tenant_db.conn.execute(text(sql))
+        tenant_db.conn.commit()
+    except Exception as e:
+        logger.error(f"Failed to drop index '{index_name}': {e}", exc_info=True)
+        tenant_db.conn.rollback()
+        raise Exception(f"Failed to drop index '{index_name}': {str(e)}") from e
+
+# %% ../nbs/15_utils_db.ipynb 21
+def table_exists(tenant_db: Database, table_name: str) -> bool:
+    """Check if a table exists in the database."""
+    db_type = get_db_type()
+    
+    if db_type == "POSTGRESQL":
+        sql = """
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables 
+                WHERE table_name = :table_name
+            )
+        """
+    else:  # SQLite
+        sql = """
+            SELECT EXISTS (
+                SELECT 1 FROM sqlite_master 
+                WHERE type = 'table' AND name = :table_name
+            )
+        """
+    
+    try:
+        result = tenant_db.conn.execute(text(sql), {"table_name": table_name})
+        return result.scalar()
+    except Exception as e:
+        logger.error(f"Failed to check if table '{table_name}' exists: {e}", exc_info=True)
+        raise Exception(f"Failed to check if table '{table_name}' exists: {str(e)}") from e