usecli 0.1.35__tar.gz → 0.1.37__tar.gz

{usecli-0.1.35 → usecli-0.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usecli
-Version: 0.1.35
+Version: 0.1.37
 Summary: A powerful Python CLI framework for building beautiful, developer-friendly command-line tools.
 Author: Edward Boswell
 Author-email: Edward Boswell <thememium@gmail.com>

{usecli-0.1.35 → usecli-0.1.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.35"
+version = "0.1.37"
 description = "A powerful Python CLI framework for building beautiful, developer-friendly command-line tools."
 readme = "README.md"
 authors = [{ name = "Edward Boswell", email = "thememium@gmail.com" }]

{usecli-0.1.35 → usecli-0.1.37}/src/usecli/cli/config/colors.py

@@ -11,6 +11,9 @@ Usage:
 
 from __future__ import annotations
 
+import importlib.metadata
+import importlib.util
+import os
 import sys
 from pathlib import Path
 from typing import Any, Callable, Final, final
@@ -25,6 +28,15 @@ PYPROJECT_TOML = "pyproject.toml"
 USECLI_CONFIG_TOML = "usecli.config.toml"
 DEFAULT_THEME_NAME = "default"
 THEMES_DIR = Path(__file__).resolve().parent.parent / "themes"
+_SKIP_DIRS = {
+    ".venv",
+    "venv",
+    "site-packages",
+    "dist-packages",
+    "__pypackages__",
+    "pipx",
+    "venvs",
+}
 DEFAULT_THEME_COLORS: dict[str, str] = {
     "primary": "#60D7FF",
     "secondary": "#5EFF87",
@@ -48,15 +60,19 @@ DEFAULT_THEME_COLORS: dict[str, str] = {
 }
 
 
-def _find_usecli_config_path(root_dir: Path, start_dir: Path) -> Path | None:
+def _find_usecli_config_path(
+    root_dir: Path, start_dir: Path, *, skip_venv: bool
+) -> Path | None:
     if not root_dir.exists() or not root_dir.is_dir():
         return None
 
-    candidates = [
-        path
-        for path in root_dir.rglob(USECLI_CONFIG_TOML)
-        if not any(part in {".venv", "venv"} for part in path.parts)
-    ]
+    candidates = [path for path in root_dir.rglob(USECLI_CONFIG_TOML)]
+    if skip_venv:
+        candidates = [
+            path
+            for path in candidates
+            if not any(part in _SKIP_DIRS for part in path.parts)
+        ]
     if not candidates:
         return None
 
@@ -83,6 +99,98 @@ def _find_usecli_config_path(root_dir: Path, start_dir: Path) -> Path | None:
     return selection[0]
 
 
+def _find_usecli_config_in_package() -> Path | None:
+    spec = importlib.util.find_spec(_get_package_name())
+    if spec is None or not spec.submodule_search_locations:
+        return None
+    for location in spec.submodule_search_locations:
+        package_root = Path(location)
+        if not package_root.exists() or not package_root.is_dir():
+            continue
+        candidates = [
+            path for path in package_root.rglob(USECLI_CONFIG_TOML) if path.exists()
+        ]
+        if candidates:
+            candidates.sort(key=lambda path: (len(path.parts), str(path)))
+            return candidates[0]
+    return None
+
+
+def _find_usecli_config_in_named_package(package_name: str) -> Path | None:
+    if not package_name:
+        return None
+    spec = importlib.util.find_spec(package_name)
+    if spec is None or not spec.submodule_search_locations:
+        return None
+    for location in spec.submodule_search_locations:
+        package_root = Path(location)
+        if not package_root.exists() or not package_root.is_dir():
+            continue
+        candidates = [
+            path for path in package_root.rglob(USECLI_CONFIG_TOML) if path.exists()
+        ]
+        if candidates:
+            candidates.sort(key=lambda path: (len(path.parts), str(path)))
+            return candidates[0]
+    return None
+
+
+def _find_usecli_config_for_console_script() -> Path | None:
+    command_name = os.path.basename(sys.argv[0]) if sys.argv else ""
+    if not command_name:
+        return None
+    try:
+        distributions = importlib.metadata.distributions()
+    except Exception:
+        return None
+    for dist in distributions:
+        try:
+            entry_points = dist.entry_points
+        except Exception:
+            continue
+        for entry_point in entry_points:
+            if entry_point.group != "console_scripts":
+                continue
+            if entry_point.name != command_name:
+                continue
+            metadata = dist.metadata
+            dist_name = ""
+            if "Name" in metadata:
+                dist_name = metadata["Name"]
+            elif "name" in metadata:
+                dist_name = metadata["name"]
+            candidates: list[str] = []
+            if dist_name:
+                candidates.append(dist_name)
+                normalized = dist_name.replace("-", "_")
+                if normalized not in candidates:
+                    candidates.append(normalized)
+            for package_name in candidates:
+                match = _find_usecli_config_in_named_package(package_name)
+                if match:
+                    return match
+    return None
+
+
+def _is_preferred_package_path(path: Path) -> bool:
+    return any(part in _SKIP_DIRS for part in path.parts)
+
+
+def _is_within_usecli_package(start_dir: Path) -> bool:
+    spec = importlib.util.find_spec(_get_package_name())
+    if spec is None or not spec.submodule_search_locations:
+        return False
+    start_dir = start_dir.resolve()
+    for location in spec.submodule_search_locations:
+        package_root = Path(location)
+        try:
+            start_dir.relative_to(package_root)
+            return True
+        except ValueError:
+            continue
+    return False
+
+
 def _find_project_root(start_dir: Path | None = None) -> Path | None:
     if start_dir is None:
         start_dir = Path.cwd()
@@ -110,10 +218,18 @@ def _find_project_root(start_dir: Path | None = None) -> Path | None:
         current = parent
 
     search_root = git_root or start_dir.resolve()
-    config_match = _find_usecli_config_path(search_root, start_dir)
+    config_match = _find_usecli_config_path(search_root, start_dir, skip_venv=True)
     if config_match:
         return config_match.parent
 
+    console_match = _find_usecli_config_for_console_script()
+    if console_match:
+        return console_match.parent
+
+    package_match = _find_usecli_config_in_package()
+    if package_match:
+        return package_match.parent
+
     return git_root
 
 
@@ -123,10 +239,25 @@ def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
 
     config_path = project_root / USECLI_CONFIG_TOML
     if not config_path.exists():
-        config_path = _find_usecli_config_path(project_root, project_root)
+        config_path = _find_usecli_config_path(
+            project_root,
+            project_root,
+            skip_venv=True,
+        )
+    if not config_path or not config_path.exists():
+        console_match = _find_usecli_config_for_console_script()
+        if console_match:
+            return _load_usecli_config_file(console_match)
+        package_match = _find_usecli_config_in_package()
+        if package_match:
+            config_path = package_match
     if not config_path or not config_path.exists():
         return {}
 
+    return _load_usecli_config_file(config_path)
+
+
+def _load_usecli_config_file(config_path: Path) -> dict[str, Any]:
     try:
         data = tomllib.loads(config_path.read_text())
     except (tomllib.TOMLDecodeError, OSError):
@@ -145,6 +276,13 @@ def _load_usecli_config(project_root: Path | None) -> dict[str, Any]:
     return {}
 
 
+def _get_package_name() -> str:
+    package = __package__ or __name__
+    if not package:
+        return "usecli"
+    return package.split(".")[0]
+
+
 def _normalize_color(value: Any) -> str | None:
     if not isinstance(value, str):
         return None

{usecli-0.1.35 → usecli-0.1.37}/src/usecli/shared/config/manager.py

@@ -5,6 +5,9 @@ Handles loading and accessing configuration from project-level files.
 
 from __future__ import annotations
 
+import importlib.metadata
+import importlib.util
+import os
 import sys
 from pathlib import Path
 from typing import Any
@@ -58,7 +61,15 @@ def _dedupe_items(items: list[str]) -> list[str]:
 class ConfigManager:
     """Manages useCli configuration from project-level files."""
 
-    _SKIP_DIRS = {".venv", "venv"}
+    _SKIP_DIRS = {
+        ".venv",
+        "venv",
+        "site-packages",
+        "dist-packages",
+        "__pypackages__",
+        "pipx",
+        "venvs",
+    }
 
     DEFAULT_CONFIG: dict[str, Any] = {
         "title": "usecli",
@@ -107,8 +118,25 @@ class ConfigManager:
         self.usecli_config_path: Path = usecli_config_path
         self.start_dir: Path = start_dir
         detected_root = find_project_root(start_dir)
-        if detected_root is None and self.usecli_config_path.exists():
-            detected_root = self.usecli_config_path.parent
+        if self.usecli_config_path.exists():
+            config_parent = self.usecli_config_path.parent
+            if detected_root is None:
+                detected_root = config_parent
+            else:
+                root_config = detected_root / USECLI_CONFIG_TOML
+                if self.usecli_config_path.resolve() != root_config.resolve():
+                    detected_root = config_parent
+                else:
+                    try:
+                        self.usecli_config_path.relative_to(detected_root)
+                    except ValueError:
+                        detected_root = config_parent
+                    else:
+                        if any(
+                            part in self._SKIP_DIRS
+                            for part in self.usecli_config_path.parts
+                        ):
+                            detected_root = config_parent
         self.project_root: Path = (detected_root or start_dir).resolve()
         self._config: dict[str, Any] = {}
         self._overrides: dict[str, Any] = {}
@@ -179,22 +207,39 @@ class ConfigManager:
             current = parent
 
         search_root = find_project_root(start_dir) or start_dir.resolve()
-        recursive_match = cls._find_usecli_config_in_tree(search_root, start_dir)
+        recursive_match = cls._find_usecli_config_in_tree(
+            search_root, start_dir, skip_venv=True
+        )
         if recursive_match:
             return recursive_match
 
+        console_match = cls._find_usecli_config_for_console_script()
+        if console_match:
+            return console_match
+
+        if not cls._is_within_usecli_package(start_dir):
+            return None
+
+        package_match = cls._find_usecli_config_in_package()
+        if package_match:
+            return package_match
+
         return cls._find_usecli_config_on_sys_path()
 
     @staticmethod
-    def _find_usecli_config_in_tree(root_dir: Path, start_dir: Path) -> Path | None:
+    def _find_usecli_config_in_tree(
+        root_dir: Path, start_dir: Path, *, skip_venv: bool
+    ) -> Path | None:
         if not root_dir.exists() or not root_dir.is_dir():
             return None
 
-        candidates = [
-            path
-            for path in root_dir.rglob(USECLI_CONFIG_TOML)
-            if not any(part in ConfigManager._SKIP_DIRS for part in path.parts)
-        ]
+        candidates = [path for path in root_dir.rglob(USECLI_CONFIG_TOML)]
+        if skip_venv:
+            candidates = [
+                path
+                for path in candidates
+                if not any(part in ConfigManager._SKIP_DIRS for part in path.parts)
+            ]
         if not candidates:
             return None
 
@@ -220,6 +265,98 @@ class ConfigManager:
         selection.sort(key=_depth_key)
         return selection[0]
 
+    @staticmethod
+    def _find_usecli_config_in_package() -> Path | None:
+        spec = importlib.util.find_spec(_get_package_name())
+        if spec is None or not spec.submodule_search_locations:
+            return None
+        for location in spec.submodule_search_locations:
+            package_root = Path(location)
+            if not package_root.exists() or not package_root.is_dir():
+                continue
+            candidates = [
+                path for path in package_root.rglob(USECLI_CONFIG_TOML) if path.exists()
+            ]
+            if candidates:
+                candidates.sort(key=lambda path: (len(path.parts), str(path)))
+                return candidates[0]
+        return None
+
+    @classmethod
+    def _find_usecli_config_in_named_package(cls, package_name: str) -> Path | None:
+        if not package_name:
+            return None
+        spec = importlib.util.find_spec(package_name)
+        if spec is None or not spec.submodule_search_locations:
+            return None
+        for location in spec.submodule_search_locations:
+            package_root = Path(location)
+            if not package_root.exists() or not package_root.is_dir():
+                continue
+            candidates = [
+                path for path in package_root.rglob(USECLI_CONFIG_TOML) if path.exists()
+            ]
+            if candidates:
+                candidates.sort(key=lambda path: (len(path.parts), str(path)))
+                return candidates[0]
+        return None
+
+    @classmethod
+    def _find_usecli_config_for_console_script(cls) -> Path | None:
+        command_name = os.path.basename(sys.argv[0]) if sys.argv else ""
+        if not command_name:
+            return None
+        try:
+            distributions = importlib.metadata.distributions()
+        except Exception:
+            return None
+        for dist in distributions:
+            try:
+                entry_points = dist.entry_points
+            except Exception:
+                continue
+            for entry_point in entry_points:
+                if entry_point.group != "console_scripts":
+                    continue
+                if entry_point.name != command_name:
+                    continue
+                metadata = dist.metadata
+                dist_name = ""
+                if "Name" in metadata:
+                    dist_name = metadata["Name"]
+                elif "name" in metadata:
+                    dist_name = metadata["name"]
+                candidates = []
+                if dist_name:
+                    candidates.append(dist_name)
+                    normalized = dist_name.replace("-", "_")
+                    if normalized not in candidates:
+                        candidates.append(normalized)
+                for package_name in candidates:
+                    match = cls._find_usecli_config_in_named_package(package_name)
+                    if match:
+                        return match
+        return None
+
+    @staticmethod
+    def _is_preferred_package_path(path: Path) -> bool:
+        return any(part in ConfigManager._SKIP_DIRS for part in path.parts)
+
+    @staticmethod
+    def _is_within_usecli_package(start_dir: Path) -> bool:
+        spec = importlib.util.find_spec(_get_package_name())
+        if spec is None or not spec.submodule_search_locations:
+            return False
+        start_dir = start_dir.resolve()
+        for location in spec.submodule_search_locations:
+            package_root = Path(location)
+            try:
+                start_dir.relative_to(package_root)
+                return True
+            except ValueError:
+                continue
+        return False
+
     @staticmethod
     def _find_usecli_config_on_sys_path() -> Path | None:
         for entry in sys.path:
@@ -328,6 +465,9 @@ class ConfigManager:
 
     def reload(self) -> None:
         """Reload configuration from disk."""
+        self.usecli_config_path = self._find_usecli_config(self.start_dir) or (
+            self.start_dir / USECLI_CONFIG_TOML
+        )
         self._load_config()
 
     @property
@@ -399,8 +539,24 @@ def find_project_root(start_dir: Path | None = None) -> Path | None:
         current = parent
 
     search_root = git_root or start_dir.resolve()
-    config_match = ConfigManager._find_usecli_config_in_tree(search_root, start_dir)
+    config_match = ConfigManager._find_usecli_config_in_tree(
+        search_root,
+        start_dir,
+        skip_venv=True,
+    )
     if config_match:
         return config_match.parent
 
+    if ConfigManager._is_within_usecli_package(start_dir):
+        package_match = ConfigManager._find_usecli_config_in_package()
+        if package_match:
+            return package_match.parent
+
     return git_root
+
+
+def _get_package_name() -> str:
+    package = __package__ or __name__
+    if not package:
+        return "usecli"
+    return package.split(".")[0]