python-color-math 0.2.18__tar.gz → 0.2.19__tar.gz

{python_color_math-0.2.18/python_color_math.egg-info → python_color_math-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-color-math
-Version: 0.2.18
+Version: 0.2.19
 Summary: A fast, local semantic LaTeX colorizer for Markdown, Jupyter, and LaTeX math equations.
 Author: Aditya
 License: MIT License

{python_color_math-0.2.18 → python_color_math-0.2.19}/color_math/__init__.py

@@ -1,13 +1,19 @@
 """Public helpers for converting Obsidian LaTeX color markup."""
 
 from .adapters import detect_format, transform_document
-from .config import ColorMathOptions, ensure_global_config_exists, open_config_folder
+from .config import (
+    ColorMathOptions,
+    find_config_path,
+    get_venv_config_path,
+    init_config,
+    open_config_folder,
+)
 from .converters.block import convert_text
 from .undo import uncolor_text
 
 from .ipython import ColorMath, colormath, load_ipython_extension, unload_ipython_extension
 
-__version__ = "0.2.18"
+__version__ = "0.2.19"
 
 __all__ = [
     "__version__",
@@ -16,7 +22,9 @@ __all__ = [
     "colormath",
     "convert_text",
     "detect_format",
-    "ensure_global_config_exists",
+    "find_config_path",
+    "get_venv_config_path",
+    "init_config",
     "load_ipython_extension",
     "open_config_folder",
     "transform_document",

{python_color_math-0.2.18 → python_color_math-0.2.19}/color_math/config.py

@@ -714,31 +714,89 @@ def default_config_dict() -> dict[str, object]:
     }
 
 
-def get_global_config_path() -> Path | None:
-    """Return platform-appropriate XDG / AppData user configuration path."""
-    if sys.platform == "win32":
-        app_data = os.environ.get("APPDATA")
-        if app_data:
-            return Path(app_data) / "color-math" / "config.json"
-    else:
-        xdg_config = os.environ.get("XDG_CONFIG_HOME")
-        if xdg_config:
-            return Path(xdg_config) / "color-math" / "config.json"
-        home = os.environ.get("HOME")
-        if home:
-            return Path(home) / ".config" / "color-math" / "config.json"
+def get_user_home_config_path() -> Path:
+    """Return platform-standard user-level config path (~/.config/color-math/config.json)."""
+    xdg_config = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config:
+        return Path(xdg_config) / "color-math" / "config.json"
+    return Path.home() / ".config" / "color-math" / "config.json"
+
+
+def get_global_config_path() -> Path:
+    """Backward-compatible alias for user home configuration path."""
+    return get_user_home_config_path()
+
+
+def find_project_config_path(start_dir: Path | None = None) -> Path | None:
+    """Search for .colormath.json in start_dir and walk up parent directories."""
+    curr = (start_dir or Path.cwd()).resolve()
+    for parent in [curr, *curr.parents]:
+        candidate = parent / ".colormath.json"
+        if candidate.exists() and candidate.is_file():
+            return candidate
+        if (parent / ".git").exists():
+            break
     return None
 
 
-def ensure_global_config_exists() -> Path | None:
-    """Ensure that the global configuration file and folder exist on disk.
+def get_venv_config_path() -> Path | None:
+    """Return path to .colormath.json inside active virtual environment, if any."""
+    if sys.prefix != sys.base_prefix or "VIRTUAL_ENV" in os.environ:
+        venv_root = Path(os.environ.get("VIRTUAL_ENV", sys.prefix))
+        return venv_root / ".colormath.json"
+    return None
+
+
+def find_config_path(start_dir: Path | None = None) -> tuple[Path | None, str]:
+    """Resolve active configuration path in order of precedence:
+    1. Project hierarchy (.colormath.json in current or parent dirs)
+    2. Active virtual environment (.colormath.json in sys.prefix or $VIRTUAL_ENV)
+    3. User home config (~/.config/color-math/config.json)
+
+    Returns (path_or_none, scope_name).
+    """
+    proj = find_project_config_path(start_dir)
+    if proj is not None:
+        return proj, "project"
+
+    venv_cfg = get_venv_config_path()
+    if venv_cfg is not None and venv_cfg.exists():
+        return venv_cfg, "venv"
 
-    Creates the directory and saves the documented default configuration if it
-    does not already exist. Returns the Path to the global config.
+    home_cfg = get_user_home_config_path()
+    if home_cfg.exists():
+        return home_cfg, "home"
+
+    return None, "default"
+
+
+def init_config(scope: str = "project", target_dir: Path | None = None) -> Path:
+    """Initialize a new .colormath.json configuration file.
+
+    Scopes:
+      - 'project': in target_dir or current working directory (isolated per project)
+      - 'venv': inside the active virtual environment (.venv)
+      - 'home': in user home (~/.config/color-math/config.json)
     """
-    path = get_global_config_path()
-    if path is None:
-        return None
+    if scope == "venv":
+        venv_cfg = get_venv_config_path()
+        if venv_cfg is None:
+            raise RuntimeError("No active virtual environment detected to initialize config in.")
+        path = venv_cfg
+    elif scope == "home":
+        path = get_user_home_config_path()
+    else:  # project
+        directory = (target_dir or Path.cwd()).resolve()
+        path = directory / ".colormath.json"
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    save_default_config(path)
+    return path
+
+
+def ensure_global_config_exists() -> Path | None:
+    """Legacy helper maintained for backward compatibility."""
+    path = get_user_home_config_path()
     if not path.exists():
         try:
             path.parent.mkdir(parents=True, exist_ok=True)
@@ -748,41 +806,43 @@ def ensure_global_config_exists() -> Path | None:
     return path
 
 
-def open_config_folder(path: Path | None = None) -> bool:
-    """Open the configuration folder in the operating system's file manager."""
+def open_config_folder(path: Path | None = None, scope: str = "project") -> tuple[bool, Path]:
+    """Open the configuration file or folder in the operating system's default application."""
     target = path
     if target is None:
-        local_candidate = Path(".colormath.json")
-        if local_candidate.exists():
-            target = local_candidate
+        found, _ = find_config_path()
+        if found is not None:
+            target = found
         else:
-            target = ensure_global_config_exists() or get_global_config_path()
-
-    if target is None:
-        return False
+            target = init_config(scope=scope)
 
-    folder = target.parent if target.suffix else target
-    try:
-        folder.mkdir(parents=True, exist_ok=True)
-        if not target.exists() and target.suffix == ".json":
+    if not target.exists():
+        try:
+            target.parent.mkdir(parents=True, exist_ok=True)
             save_default_config(target)
-    except OSError:
-        pass
+        except OSError:
+            pass
 
     try:
         if sys.platform == "win32":
-            os.startfile(folder)
-            return True
+            os.startfile(target)
+            return True, target
         elif sys.platform == "darwin":
             import subprocess
-            subprocess.run(["open", str(folder)], check=False)
-            return True
+            subprocess.run(["open", str(target)], check=False)
+            return True, target
         else:
             import subprocess
-            subprocess.run(["xdg-open", str(folder)], check=False)
-            return True
+            subprocess.run(["xdg-open", str(target)], check=False)
+            return True, target
     except Exception:
-        return False
+        try:
+            if sys.platform == "win32":
+                os.startfile(target.parent)
+                return True, target.parent
+        except Exception:
+            pass
+        return False, target
 
 
 DEFAULT_UNICODE_CONFIG: dict[str, object] = {
@@ -821,8 +881,8 @@ def load_config(
     path: Path | None = None,
 ) -> tuple[dict[str, str], ColorMathOptions, dict[str, object]]:
     """
-    Load configuration from path, local '.colormath.json', or global user config.
-    Fault-tolerant: If the user file contains JSON syntax errors or invalid types,
+    Load configuration from path, project hierarchy, active venv, or user home.
+    Fault-tolerant: If the file contains JSON syntax errors or invalid types,
     a warning is emitted and it safely falls back to factory defaults without crashing.
     Returns (palette_dict, ColorMathOptions, unicode_config_dict).
     """
@@ -832,13 +892,7 @@ def load_config(
 
     target = path
     if target is None:
-        local_candidate = Path(".colormath.json")
-        if local_candidate.exists():
-            target = local_candidate
-        else:
-            global_candidate = ensure_global_config_exists()
-            if global_candidate and global_candidate.exists():
-                target = global_candidate
+        target, _ = find_config_path()
 
     if target is None or not target.exists():
         return palette, options, unicode_config

{python_color_math-0.2.18 → python_color_math-0.2.19}/color_math/ipython.py

@@ -14,9 +14,10 @@ from .adapters import transform_document
 from .config import (
     ColorMathOptions,
     THEMES,
+    find_config_path,
+    get_venv_config_path,
+    init_config,
     load_config,
-    get_global_config_path,
-    ensure_global_config_exists,
     open_config_folder,
     save_default_config,
 )
@@ -180,44 +181,63 @@ if HAS_IPYTHON:
 
         @line_magic("color_math_config")
         def color_math_config(self, line: str) -> None:
-            """Inspect or initialize Color Math configuration.
+            """Inspect, create, or open Color Math configuration.
 
             Usage:
-                %color_math_config
-                %color_math_config --init
-                %color_math_config --reload
+                %color_math_config                  - Show current active config and scope
+                %color_math_config init             - Create .colormath.json in current project
+                %color_math_config init --venv      - Create .colormath.json inside active .venv
+                %color_math_config open             - Open the active config file in editor
+                %color_math_config reload           - Reload config from disk
             """
-            raw = line.strip().lower()
-            if "--init" in raw:
-                target = Path(".colormath.json")
-                save_default_config(target)
-                print(f"Color Math: Created config template at '{target.resolve()}'.")
-                self._palette, self._options, _ = load_config(target)
-            raw = line.strip().lower()
-            if raw in ("open", "--open", "explore", "folder"):
-                opened = open_config_folder()
-                if opened:
-                    print("Color Math: Opened configuration folder in file manager.")
+            parts = line.strip().split()
+            subcmd = parts[0].lower() if parts else ""
+
+            if subcmd in ("init", "--init"):
+                scope = "venv" if "--venv" in parts else "project"
+                try:
+                    target = init_config(scope=scope)
+                    print(f"Color Math: Created {scope} configuration at '{target}'.")
+                    self._palette, self._options, _ = load_config(target)
+                except Exception as err:
+                    print(f"Color Math error: {err}")
+                return
+
+            if subcmd in ("open", "--open", "explore", "folder", "edit"):
+                scope = "venv" if "--venv" in parts else "project"
+                success, target = open_config_folder(scope=scope)
+                if success:
+                    print(f"Color Math: Opened '{target}'.")
                 else:
-                    print("Color Math: Could not open configuration folder automatically.")
+                    print(f"Color Math: Configuration file is at '{target}'.")
                 return
 
-            if "--reload" in raw or raw == "reload":
+            if subcmd in ("reload", "--reload"):
                 self._palette, self._options, _ = load_config()
-                print("Color Math: Configuration reloaded.")
+                print("Color Math: Configuration reloaded from disk.")
                 return
 
-            local_path = Path(".colormath.json")
-            global_path = ensure_global_config_exists() or get_global_config_path()
+            active_path, scope = find_config_path()
             print("Color Math Configuration:")
-            print(f"  Local config:  {local_path.resolve()} ({'exists' if local_path.exists() else 'not found'})")
-            if global_path:
-                print(f"  Global config: {global_path} ({'exists' if global_path.exists() else 'not found'})")
+            if active_path:
+                print(f"  Active Config: {active_path} (scope: {scope})")
+            else:
+                print("  Active Config: Built-in defaults (zero disk pollution)")
+
+            venv_cfg = get_venv_config_path()
+            if venv_cfg:
+                status = "configured" if venv_cfg.exists() else "no config in venv"
+                print(f"  Virtual Env:   {venv_cfg.parent.name} ({status})")
+
             print(f"  Variables:     {'ENABLED' if self._options.variable_data_flow else 'DISABLED'}")
             print(f"  Taxonomy:      {'ENABLED' if self._options.enable_taxonomy else 'DISABLED'}")
             print(f"  Delimiters:    {'ENABLED' if self._options.rainbow_delimiters else 'DISABLED'}")
             print(f"  Auto-display:  {'ENABLED' if self._auto_hook_active else 'DISABLED'}")
-            print("\nTip: Run '%color_math_config open' to open the configuration folder in your file manager.")
+            print("\nCommands:")
+            print("  %color_math_config init        - Create project-level .colormath.json")
+            print("  %color_math_config init --venv - Create .colormath.json inside current .venv")
+            print("  %color_math_config open        - Open active config in your editor")
+            print("  %color_math_config reload      - Reload settings from disk")
 
         @line_magic("color_math_auto")
         def color_math_auto(self, line: str) -> None:

{python_color_math-0.2.18 → python_color_math-0.2.19}/color_math/main.py

@@ -227,10 +227,15 @@ def build_parser() -> argparse.ArgumentParser:
         const=".colormath.json",
         help="Generate a .colormath.json config template (optional target path).",
     )
+    style_group.add_argument(
+        "--init-venv",
+        action="store_true",
+        help="Generate a .colormath.json inside the active virtual environment (.venv).",
+    )
     style_group.add_argument(
         "--open-config",
         action="store_true",
-        help="Open configuration folder in system file manager.",
+        help="Open configuration file in default editor/file manager.",
     )
     style_group.add_argument(
         "--config",
@@ -589,7 +594,18 @@ def _main_impl(argv: list[str] | None = None) -> int:
             sys.stdout.write("Reset runtime color palette to factory defaults (Tokyo Night).\n")
         return 0
 
+    if args.init_venv:
+        from .config import init_config
+        try:
+            cfg_path = init_config(scope="venv")
+            sys.stdout.write(f"Created virtual environment configuration: {cfg_path}\n")
+        except Exception as err:
+            sys.stderr.write(f"color-math error: {err}\n")
+            return 1
+        return 0
+
     if args.init_config:
+        from .config import init_config
         cfg_path = Path(args.init_config)
         save_default_config(cfg_path)
         sys.stdout.write(f"Created configuration file: {cfg_path}\n")
@@ -597,7 +613,11 @@ def _main_impl(argv: list[str] | None = None) -> int:
 
     if args.open_config:
         from .config import open_config_folder
-        open_config_folder(args.config)
+        success, path = open_config_folder(args.config)
+        if success:
+            sys.stdout.write(f"Opened configuration: {path}\n")
+        else:
+            sys.stdout.write(f"Configuration file located at: {path}\n")
         return 0
 
     # 3. Load base configuration & theme

{python_color_math-0.2.18 → python_color_math-0.2.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-color-math"
-version = "0.2.18"
+version = "0.2.19"
 description = "A fast, local semantic LaTeX colorizer for Markdown, Jupyter, and LaTeX math equations."
 readme = "README.md"
 requires-python = ">=3.10"

{python_color_math-0.2.18 → python_color_math-0.2.19/python_color_math.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-color-math
-Version: 0.2.18
+Version: 0.2.19
 Summary: A fast, local semantic LaTeX colorizer for Markdown, Jupyter, and LaTeX math equations.
 Author: Aditya
 License: MIT License