vyasa 0.3.6__py3-none-any.whl

vyasa/helpers.py

@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+import re
+import tomllib
+from functools import lru_cache
+from pathlib import Path
+import frontmatter
+from loguru import logger
+
+def slug_to_title(s: str, abbreviations=None) -> str:
+    abbreviations = abbreviations or []
+    abbrev_set = {str(word).strip().lower() for word in abbreviations if str(word).strip()}
+    words = s.replace('-', ' ').replace('_', ' ').split()
+    titled = []
+    for word in words:
+        lowered = word.lower()
+        if lowered in abbrev_set:
+            titled.append(word.upper())
+        elif word.isupper():
+            titled.append(word)
+        else:
+            titled.append(word[0].upper() + word[1:])
+    return ' '.join(titled)
+
+def _strip_inline_markdown(text: str) -> str:
+    cleaned = text or ""
+    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)
+    cleaned = re.sub(r'\[([^\]]+)\]\[[^\]]*\]', r'\1', cleaned)
+    cleaned = re.sub(r'`([^`]+)`', r'\1', cleaned)
+    cleaned = re.sub(r'\*\*([^*]+)\*\*', r'\1', cleaned)
+    cleaned = re.sub(r'__([^_]+)__', r'\1', cleaned)
+    cleaned = re.sub(r'\*([^*]+)\*', r'\1', cleaned)
+    cleaned = re.sub(r'_([^_]+)_', r'\1', cleaned)
+    cleaned = re.sub(r'~~([^~]+)~~', r'\1', cleaned)
+    return cleaned
+
+def _plain_text_from_html(text: str) -> str:
+    import html
+    cleaned = re.sub(r'<[^>]+>', '', text or "")
+    return html.unescape(cleaned)
+
+def text_to_anchor(text: str) -> str:
+    """Convert text to anchor slug"""
+    cleaned = _strip_inline_markdown(text)
+    cleaned = _plain_text_from_html(cleaned)
+    return re.sub(r'[^\w\s-]', '', cleaned.lower()).replace(' ', '-')
+
+def _unique_anchor(base: str, counts: dict[str, int]) -> str:
+    if not base:
+        base = "section"
+    current = counts.get(base, 0) + 1
+    counts[base] = current
+    return base if current == 1 else f"{base}-{current}"
+
+_frontmatter_cache: dict[str, tuple[float, tuple[dict, str]]] = {}
+
+def parse_frontmatter(file_path: str | Path):
+    """Parse frontmatter from a markdown file with caching"""
+    import time
+    start_time = time.time()
+
+    file_path = Path(file_path)
+    cache_key = str(file_path)
+    mtime = file_path.stat().st_mtime
+
+    if cache_key in _frontmatter_cache:
+        cached_mtime, cached_data = _frontmatter_cache[cache_key]
+        if cached_mtime == mtime:
+            elapsed = (time.time() - start_time) * 1000
+            logger.debug(f"[DEBUG] parse_frontmatter CACHE HIT for {file_path.name} ({elapsed:.2f}ms)")
+            return cached_data
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            post = frontmatter.load(f)
+            result = (post.metadata, post.content)
+            _frontmatter_cache[cache_key] = (mtime, result)
+            elapsed = (time.time() - start_time) * 1000
+            logger.debug(f"[DEBUG] parse_frontmatter READ FILE {file_path.name} ({elapsed:.2f}ms)")
+            return result
+    except Exception as e:
+        print(f"Error parsing frontmatter from {file_path}: {e}")
+        return {}, open(file_path).read()
+
+def get_post_title(file_path: str | Path, abbreviations=None) -> str:
+    """Get post title from frontmatter or filename"""
+    metadata, _ = parse_frontmatter(file_path)
+    file_path = Path(file_path)
+    return metadata.get('title', slug_to_title(file_path.stem, abbreviations=abbreviations))
+
+@lru_cache(maxsize=128)
+def _cached_vyasa_config(path_str: str, mtime: float):
+    path = Path(path_str)
+    try:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except Exception:
+        return {}
+
+def _normalize_vyasa_config(parsed):
+    config = {
+        "order": [],
+        "sort": "name_asc",
+        "folders_first": True,
+        "folders_always_first": False,
+        "layout_max_width": None,
+        "abbreviations": None,
+    }
+    if not isinstance(parsed, dict):
+        return config
+
+    order = parsed.get("order")
+    if order is not None:
+        if isinstance(order, (list, tuple)):
+            config["order"] = [str(item).strip() for item in order if str(item).strip()]
+        else:
+            config["order"] = []
+
+    sort = parsed.get("sort")
+    if isinstance(sort, str) and sort in ("name_asc", "name_desc", "mtime_asc", "mtime_desc"):
+        config["sort"] = sort
+
+    folders_first = parsed.get("folders_first")
+    if isinstance(folders_first, bool):
+        config["folders_first"] = folders_first
+    elif isinstance(folders_first, str):
+        lowered = folders_first.lower()
+        if lowered in ("true", "false"):
+            config["folders_first"] = lowered == "true"
+
+    folders_always_first = parsed.get("folders_always_first")
+    if isinstance(folders_always_first, bool):
+        config["folders_always_first"] = folders_always_first
+    elif isinstance(folders_always_first, str):
+        lowered = folders_always_first.lower()
+        if lowered in ("true", "false"):
+            config["folders_always_first"] = lowered == "true"
+
+    for key in ("layout_max_width",):
+        value = parsed.get(key)
+        if isinstance(value, (int, float)):
+            value = str(value)
+        if isinstance(value, str):
+            value = value.strip()
+            config[key] = value if value else None
+
+    abbreviations = parsed.get("abbreviations")
+    if isinstance(abbreviations, (list, tuple, set)):
+        config["abbreviations"] = [str(item).strip() for item in abbreviations if str(item).strip()]
+    elif isinstance(abbreviations, str):
+        parts = [part.strip() for part in abbreviations.split(",")]
+        config["abbreviations"] = [part for part in parts if part]
+
+    return config
+
+def _effective_abbreviations(root: Path, folder: Path | None = None):
+    root_config = get_vyasa_config(root)
+    root_abbrevs = root_config.get("abbreviations") or []
+    if folder is None or folder == root:
+        return root_abbrevs
+    folder_config = get_vyasa_config(folder)
+    folder_abbrevs = folder_config.get("abbreviations")
+    return folder_abbrevs if folder_abbrevs is not None else root_abbrevs
+
+def get_vyasa_config(folder: Path):
+    vyasa_path = folder / ".vyasa"
+    if not vyasa_path.exists():
+        return _normalize_vyasa_config({})
+    try:
+        mtime = vyasa_path.stat().st_mtime
+    except OSError:
+        return _normalize_vyasa_config({})
+    parsed = _cached_vyasa_config(str(vyasa_path), mtime)
+    config = _normalize_vyasa_config(parsed)
+    logger.debug(
+        "[DEBUG] .vyasa config for %s: order=%s sort=%s folders_first=%s",
+        folder,
+        config.get("order"),
+        config.get("sort"),
+        config.get("folders_first"),
+    )
+    return config
+
+def order_vyasa_entries(entries, config):
+    if not entries:
+        return []
+
+    order_list = [name.strip().rstrip("/") for name in config.get("order", []) if str(name).strip()]
+    if not order_list:
+        sorted_entries = _sort_vyasa_entries(entries, config.get("sort"), config.get("folders_first", True))
+        if config.get("folders_always_first"):
+            sorted_entries = _group_folders_first(sorted_entries)
+        logger.debug(
+            "[DEBUG] .vyasa order empty; sorted entries: %s",
+            [item.name for item in sorted_entries],
+        )
+        return sorted_entries
+
+    exact_map = {}
+    stem_map = {}
+    for item in entries:
+        exact_map.setdefault(item.name, item)
+        if item.suffix == ".md":
+            stem_map.setdefault(item.stem, item)
+
+    ordered = []
+    used = set()
+    for name in order_list:
+        if name in exact_map:
+            item = exact_map[name]
+        elif name in stem_map:
+            item = stem_map[name]
+        else:
+            item = None
+        if item and item not in used:
+            ordered.append(item)
+            used.add(item)
+
+    remaining = [item for item in entries if item not in used]
+    remaining_sorted = _sort_vyasa_entries(
+        remaining,
+        config.get("sort"),
+        config.get("folders_first", True)
+    )
+    combined = ordered + remaining_sorted
+    if config.get("folders_always_first"):
+        combined = _group_folders_first(combined)
+    logger.debug(
+        "[DEBUG] .vyasa ordered=%s remaining=%s",
+        [item.name for item in ordered],
+        [item.name for item in remaining_sorted],
+    )
+    return combined
+
+def _group_folders_first(entries):
+    folders = [item for item in entries if item.is_dir()]
+    files = [item for item in entries if not item.is_dir()]
+    return folders + files
+
+def _sort_vyasa_entries(entries, sort_method, folders_first):
+    method = sort_method or "name_asc"
+    reverse = method.endswith("desc")
+    by_mtime = method.startswith("mtime")
+
+    def sort_key(item):
+        if by_mtime:
+            try:
+                return item.stat().st_mtime
+            except OSError:
+                return 0
+        return item.name.lower()
+
+    if folders_first:
+        folders = [item for item in entries if item.is_dir()]
+        files = [item for item in entries if not item.is_dir()]
+        folders_sorted = sorted(folders, key=sort_key, reverse=reverse)
+        files_sorted = sorted(files, key=sort_key, reverse=reverse)
+        return folders_sorted + files_sorted
+
+    return sorted(entries, key=sort_key, reverse=reverse)
+
+def list_vyasa_posts(root: Path, include_hidden: bool = False) -> list[dict]:
+    """List all posts in the blog root (md + pdf)."""
+    root = root.resolve()
+    root_parts = len(root.parts)
+    posts: list[dict] = []
+    abbreviations = _effective_abbreviations(root)
+
+    for path in sorted(root.rglob("*")):
+        if not path.is_file():
+            continue
+        rel_parts = path.parts[root_parts:]
+        if not rel_parts:
+            continue
+        if not include_hidden and any(part.startswith(".") for part in rel_parts):
+            continue
+        if path.suffix.lower() not in {".md", ".pdf"}:
+            continue
+
+        rel = Path(*rel_parts)
+        slug = rel.with_suffix("").as_posix()
+        if path.suffix.lower() == ".md":
+            title = get_post_title(path, abbreviations=abbreviations)
+            kind = "md"
+        else:
+            title = slug_to_title(rel.stem, abbreviations=abbreviations)
+            kind = "pdf"
+
+        posts.append(
+            {
+                "path": slug,
+                "title": title,
+                "type": kind,
+            }
+        )
+
+    return posts
+
+def list_vyasa_entries(root: Path, relative: str = ".", include_hidden: bool = False) -> dict:
+    """List immediate entries (folders + md/pdf files) under a relative path."""
+    root = root.resolve()
+    target = (root / relative).resolve()
+    if target != root and root not in target.parents:
+        return {"error": "Path escapes blog root"}
+    if not target.exists() or not target.is_dir():
+        return {"error": "Folder not found"}
+
+    abbreviations = _effective_abbreviations(root, target)
+    entries: list[dict] = []
+    for item in sorted(target.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower())):
+        if not include_hidden and item.name.startswith("."):
+            continue
+        if item.is_dir():
+            entries.append({"type": "folder", "path": item.relative_to(root).as_posix()})
+            continue
+        if item.suffix.lower() not in {".md", ".pdf"}:
+            continue
+        rel = item.relative_to(root)
+        slug = rel.with_suffix("").as_posix()
+        if item.suffix.lower() == ".md":
+            title = get_post_title(item, abbreviations=abbreviations)
+            kind = "md"
+        else:
+            title = slug_to_title(rel.stem, abbreviations=abbreviations)
+            kind = "pdf"
+        entries.append({"type": kind, "path": slug, "title": title})
+
+    return {"path": target.relative_to(root).as_posix(), "entries": entries}
+
+def find_folder_note_file(folder: Path) -> Path | None:
+    """Return the preferred folder note file (index.md, readme.md, or foldername.md)."""
+    try:
+        folder_name = folder.name.lower()
+        index_file = None
+        readme_file = None
+        named_file = None
+        for item in folder.iterdir():
+            if not item.is_file() or item.suffix.lower() != ".md":
+                continue
+            stem = item.stem.lower()
+            if stem == "index":
+                index_file = item
+            elif stem == "readme":
+                readme_file = item
+            elif stem == folder_name:
+                named_file = item
+        return index_file or readme_file or named_file
+    except OSError:
+        return None

vyasa/layout_helpers.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import re
+from .config import get_config
+
+def _coerce_config_str(value):
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, str):
+        cleaned = value.strip()
+        return cleaned if cleaned else None
+    return str(value)
+
+def _width_class_and_style(value, kind):
+    if not value:
+        return "", ""
+    val = value.strip()
+    lowered = val.lower()
+    if lowered in ("default", "auto", "none"):
+        return "", ""
+    if kind == "max":
+        if val.startswith("max-w-"):
+            return val, ""
+        if re.match(r'^\d+(\.\d+)?$', val):
+            val = f"{val}px"
+        return "", f"--layout-max-width: {val};"
+    return "", ""
+
+def _style_attr(style_value):
+    if not style_value:
+        return {}
+    return {"style": style_value}
+
+def _resolve_layout_config(current_path):
+    config = get_config()
+    return {
+        "layout_max_width": _coerce_config_str(config.get("layout_max_width", "VYASA_LAYOUT_MAX_WIDTH", "75vw")),
+    }

vyasa/main.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+import sys
+import os
+from .config import get_config, reload_config
+
+# Import app at module level, but config will be initialized before it's used
+from .core import app
+
+def build_command():
+    """CLI entry point for vyasa build command"""
+    import argparse
+    from .build import build_static_site
+    
+    parser = argparse.ArgumentParser(description='Build static site from markdown files')
+    parser.add_argument('directory', nargs='?', help='Path to markdown files directory')
+    parser.add_argument('-o', '--output', help='Output directory (default: ./dist)', default='dist')
+    
+    args = parser.parse_args(sys.argv[2:])  # Skip 'vyasa' and 'build'
+    
+    try:
+        output_dir = build_static_site(input_dir=args.directory, output_dir=args.output)
+        return 0
+    except Exception as e:
+        print(f"Error building static site: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        return 1
+
+def cli():
+    """CLI entry point for vyasa command
+    
+    Usage:
+        vyasa [directory]                    # Run locally on 127.0.0.1:5001
+        vyasa [directory] --host 0.0.0.0     # Run on all interfaces
+        vyasa build [directory]              # Build static site
+        vyasa build [directory] -o output    # Build to custom output directory
+        
+    Environment variables:
+        VYASA_ROOT: Path to markdown files
+        VYASA_HOST: Server host (default: 127.0.0.1)
+        VYASA_PORT: Server port (default: 5001)
+        
+    Configuration file:
+        Create a .vyasa file (TOML format) in your blog directory
+    """
+    import uvicorn
+    import argparse
+    
+    # Check if first argument is 'build'
+    if len(sys.argv) > 1 and sys.argv[1] == 'build':
+        sys.exit(build_command())
+    
+    parser = argparse.ArgumentParser(description='Run Vyasa server')
+    parser.add_argument('directory', nargs='?', help='Path to markdown files directory')
+    parser.add_argument('--host', help='Server host (default: 127.0.0.1, use 0.0.0.0 for all interfaces)')
+    parser.add_argument('--port', type=int, help='Server port (default: 5001)')
+    parser.add_argument('--no-reload', action='store_true', help='Disable auto-reload')
+    parser.add_argument('--user', help='Login username (overrides config/env)')
+    parser.add_argument('--password', help='Login password (overrides config/env)')
+    
+    args = parser.parse_args()
+    
+    # Set root folder from arguments or environment
+    if args.directory:
+        root = Path(args.directory).resolve()
+        if not root.exists():
+            print(f"Error: Directory {root} does not exist")
+            sys.exit(1)
+        os.environ['VYASA_ROOT'] = str(root)
+    
+    # Initialize or reload config to pick up .vyasa file
+    # This ensures .vyasa file is loaded and config is refreshed
+    config = reload_config() if args.directory else get_config()
+    
+    # Get host and port from arguments, config, or use defaults
+    host = args.host or config.get_host()
+    port = args.port or config.get_port()
+    reload = not args.no_reload
+
+    # Set login credentials from CLI if provided
+    if args.user:
+        os.environ['VYASA_USER'] = args.user
+    if args.password:
+        os.environ['VYASA_PASSWORD'] = args.password
+
+    print(f"Starting Vyasa server...")
+    print(f"Blog root: {config.get_root_folder()}")
+    print(f"Blog title: {config.get_blog_title()}")
+    print(f"Serving at: http://{host}:{port}")
+    if host == '0.0.0.0':
+        print(f"Server accessible from network at: http://<your-ip>:{port}")
+    
+    # Configure reload to watch markdown and PDF files in the blog directory
+    reload_kwargs = {}
+    if reload:
+        blog_root = config.get_root_folder()
+        reload_kwargs = {
+            "reload": True,
+            "reload_dirs": [str(blog_root)],
+            "reload_includes": ["*.md", "*.pdf", "*.vyasa"]
+        }
+    else:
+        reload_kwargs = {"reload": False}
+
+    uvicorn.run("vyasa.main:app", host=host, port=port, **reload_kwargs)
+
+if __name__ == "__main__":
+    cli()