machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/profile/create_helper.py

@@ -1,35 +1,73 @@
 
 from typing import Literal
+from pathlib import Path
+import shutil
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT, CONFIG_ROOT
 
 
-def copy_assets_to_machine(which: Literal["scripts", "settings"]):
-    # callers, symlink public, shell profile adder (requires init.ps1 and scripts dir to be present on machine)
+def _copy_path(source: Path, target: Path, overwrite: bool) -> None:
+    source = source.expanduser().resolve()
+    target = target.expanduser().resolve()
+    if not source.exists():
+        raise FileNotFoundError(f"Source path does not exist: {source}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.exists() and not overwrite:
+        raise FileExistsError(f"Target already exists and overwrite=False: {target}")
+    if target.exists() and overwrite:
+        if target.is_dir():
+            shutil.rmtree(target)
+        else:
+            target.unlink()
+    if source.is_file():
+        shutil.copy2(source, target)
+    elif source.is_dir():
+        shutil.copytree(source, target, dirs_exist_ok=overwrite)
+    else:
+        raise ValueError(f"Source is neither file nor directory: {source}")
+
+
+def copy_assets_to_machine(which: Literal["scripts", "settings"]) -> None:
     import platform
-    if platform.system().lower() == "windows":
+    import subprocess
+    system_name = platform.system().lower()
+    if system_name == "windows":
         system = "windows"
-    elif platform.system().lower() == "linux" or platform.system().lower() == "darwin":
+    elif system_name in {"linux", "darwin"}:
         system = "linux"
     else:
-        raise NotImplementedError(f"System {platform.system().lower()} not supported")
+        raise NotImplementedError(f"System {system_name} not supported")
+
     match which:
         case "scripts":
             source = LIBRARY_ROOT.joinpath("scripts", system)
-            target = CONFIG_ROOT.joinpath("scripts", system)
+            target = CONFIG_ROOT.joinpath("scripts")
+
+            # _copy_path(source=source, target=target, overwrite=True)
 
+            for a_path in source.rglob("*"):
+                if not a_path.is_file():
+                    continue
+                relative_path = a_path.relative_to(source)
+                target_path = target.joinpath(relative_path)
+                _copy_path(source=a_path, target=target_path, overwrite=True)
+
+            wrap_mcfg_source = LIBRARY_ROOT.joinpath("scripts", "nu", "wrap_mcfg.nu")
+            wrap_mcfg_target = CONFIG_ROOT.joinpath("scripts", "wrap_mcfg.nu")
+
+            wrap_mcfg_target.parent.mkdir(parents=True, exist_ok=True)
+            _copy_path(source=wrap_mcfg_source, target=wrap_mcfg_target, overwrite=True)
+
+            if system_name == "linux":
+                from rich.console import Console
+                console = Console()
+                console.print("\n[bold]📜 Setting executable permissions for scripts...[/bold]")
+                scripts_path = CONFIG_ROOT.joinpath("scripts")
+                subprocess.run(f"chmod +x {scripts_path} -R", shell=True, capture_output=True, text=True, check=False)
+                console.print("[green]✅ Script permissions updated[/green]")
+            return
         case "settings":
             source = LIBRARY_ROOT.joinpath("settings")
             target = CONFIG_ROOT.joinpath("settings")
-    from machineconfig.utils.path_extended import PathExtended
-    PathExtended(source).copy(folder=target.parent, overwrite=True)
-    import platform
-    system = platform.system().lower()
-    if system == "linux" and which == "scripts":
-        import subprocess
-        from rich.console import Console
-        console = Console()
-        console.print("\n[bold]📜 Setting executable permissions for scripts...[/bold]")
-        subprocess.run(f"chmod +x {CONFIG_ROOT.joinpath(f'scripts/{system.lower()}')} -R", shell=True, capture_output=True, text=True)
-        console.print("[green]✅ Script permissions updated[/green]")
-
 
+    _copy_path(source=source, target=target, overwrite=True)
+    

machineconfig/profile/create_links.py

@@ -13,59 +13,117 @@ from rich.table import Table
 
 from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.links import symlink_map, copy_map
+from machineconfig.profile.create_links_export import ON_CONFLICT_STRICT
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT, CONFIG_ROOT
 
 import platform
 import subprocess
 import tomllib
-from typing import Optional, Any, TypedDict, Literal
+from typing import Optional, Any, TypedDict, Literal, TypeAlias
+from pathlib import Path
 
 
+LIBRARY_MAPPER_PATH = LIBRARY_ROOT.joinpath("profile/mapper_dotfiles.toml")
+USER_MAPPER_PATH  = Path.home().joinpath("dotfiles/machineconfig/mapper_dotfiles.toml")
+
 system = platform.system()  # Linux or Windows
 ERROR_LIST: list[Any] = []  # append to this after every exception captured.
 SYSTEM = system.lower()
 
 console = Console()
 
+OS_ALIASES = {
+    "mac": "darwin",
+    "macos": "darwin",
+    "osx": "darwin",
+}
+REPO_ALIASES = {
+    "l": "library",
+    "i": "user",
+}
+
+
+def _normalize_os_name(value: str) -> str:
+    return OS_ALIASES.get(value.strip().lower(), value.strip().lower())
+
+
+def _normalize_repo_name(value: str) -> str:
+    return REPO_ALIASES.get(value.strip().lower(), value.strip().lower())
+
+
+def _parse_os_field(os_field: Any) -> set[str]:
+    if not os_field:
+        return {"any"}
+    if isinstance(os_field, list):
+        raw_values = [str(item) for item in os_field]
+    else:
+        raw_values = str(os_field).split(",")
+    values: set[str] = set()
+    for raw in raw_values:
+        token = _normalize_os_name(raw)
+        if not token:
+            continue
+        if token in {"any", "all", "*"}:
+            return {"any"}
+        values.add(token)
+    return values or {"any"}
+
 
 class Base(TypedDict):
-    this: str
-    to_this: str
+    original: str
+    self_managed: str
     contents: Optional[bool]
     copy: Optional[bool]
+    os: Optional[str]
 class ConfigMapper(TypedDict):
     file_name: str
     config_file_default_path: str
     self_managed_config_file_path: str
     contents: Optional[bool]
     copy: Optional[bool]
+    os: Optional[str]
 class MapperFileData(TypedDict):
     public: dict[str, list[ConfigMapper]]
     private: dict[str, list[ConfigMapper]]
-def read_mapper() -> MapperFileData:
-    mapper_data: dict[str, dict[str, Base]] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/mapper.toml").read_text(encoding="utf-8"))
+
+RepoLoose: TypeAlias = Literal["user", "library", "all"]
+
+
+def read_mapper(repo: RepoLoose) -> MapperFileData:
+    repo_key = _normalize_repo_name(repo)
+    match repo_key:
+        case "user":
+            mapper_path = USER_MAPPER_PATH
+        case "library":
+            mapper_path = LIBRARY_MAPPER_PATH
+        case "all":
+            # Merge both mappers
+            if not USER_MAPPER_PATH.exists():
+                user_mapper = {"public": {}, "private": {}}
+            else:
+                user_mapper = read_mapper(repo="user")
+            library_mapper = read_mapper(repo="library")
+            merged_public: dict[str, list[ConfigMapper]] = {**library_mapper["public"], **user_mapper["public"]}
+            merged_private: dict[str, list[ConfigMapper]] = {**library_mapper["private"], **user_mapper["private"]}
+            return {"public": merged_public, "private": merged_private}
+        case _:
+            raise ValueError(f"Unsupported repo value: {repo}")
+    mapper_data: dict[str, dict[str, Base]] = tomllib.loads(mapper_path.read_text(encoding="utf-8"))
     public: dict[str, list[ConfigMapper]] = {}
     private: dict[str, list[ConfigMapper]] = {}
-    # def get_other_systems(current_system: str) -> list[str]:
-    #     all_systems = ["linux", "windows", "darwin"]
-    #     return [s for s in all_systems if s != current_system.lower()]
-    # OTHER_SYSTEMS = get_other_systems(SYSTEM)
+    normalized_system = _normalize_os_name(SYSTEM)
     for program_key, program_map in mapper_data.items():
-        parts = program_key.split("_")
-        if len(parts) > 1:
-            if parts[-1].lower() == "windows" and SYSTEM != "windows":
-                # console.print(f"Skipping Windows-only program mapping: {program_key}")
-                continue
-            elif parts[-1].lower() == "linux" and SYSTEM == "windows":
-                # console.print(f"Skipping Linux-only program mapping: {program_key}")
-                continue
         for file_name, file_base in program_map.items():
+            os_values = _parse_os_field(file_base.get("os"))
+            if "any" not in os_values and normalized_system not in os_values:
+                continue
             file_map: ConfigMapper = {
                 "file_name": file_name,
-                "config_file_default_path": file_base["this"],
-                "self_managed_config_file_path": file_base["to_this"],
+                "config_file_default_path": file_base["original"],
+                "self_managed_config_file_path": file_base["self_managed"],
                 "contents": file_base.get("contents"),
                 "copy": file_base.get("copy"),
+                "os": file_base.get("os"),
             }
             if "CONFIG_ROOT" in file_map["self_managed_config_file_path"]:
                 if program_key not in public:
@@ -79,7 +137,7 @@ def read_mapper() -> MapperFileData:
 
 
 def apply_mapper(mapper_data: dict[str, list[ConfigMapper]],
-                 on_conflict: Literal["throwError", "overwriteSelfManaged", "backupSelfManaged", "overwriteDefaultPath", "backupDefaultPath"],
+                 on_conflict: ON_CONFLICT_STRICT,
                  method: Literal["symlink", "copy"]
                  ):
     operation_records: list[OperationRecord] = []
@@ -116,7 +174,7 @@ def apply_mapper(mapper_data: dict[str, list[ConfigMapper]],
             # Determine whether to use copy or symlink
             use_copy = method == "copy" or a_mapper.get("copy", False)
             if "contents" in a_mapper and a_mapper["contents"]:
-                targets = list(self_managed_config_file_path.expanduser().search("*"))
+                targets = list(self_managed_config_file_path.expanduser().glob("*"))
                 for a_target in targets:
                     operation_type = "contents_copy" if use_copy else "contents_symlink"
                     try:

machineconfig/profile/create_links_export.py

@@ -1,54 +1,105 @@
 
 import typer
-from typing import Optional, Literal, Annotated
+from typing import Literal, Annotated, Optional, TypeAlias
 
 
-def main_public_from_parser(method: Annotated[Literal["symlink", "copy"], typer.Option(..., help="Method to use for setting up the config file.")],
-                            on_conflict: Annotated[Literal["throwError", "overwriteDefaultPath", "backupDefaultPath"], typer.Option(..., help="Action to take on conflict")],
-                            which: Annotated[Optional[str], typer.Option(..., help="Specific items to process")] = None,
-                            interactive: Annotated[bool, typer.Option(..., help="Run in interactive mode")] = False):
+ON_CONFLICT_LOOSE: TypeAlias = Literal[
+    "throw-error", "t",
+    "overwrite-self-managed", "os",
+    "backup-self-managed", "bs",
+    "overwrite-default-path", "od",
+    "backup-default-path", "bd"
+    ]
+ON_CONFLICT_STRICT: TypeAlias = Literal["throw-error", "overwrite-self-managed", "backup-self-managed", "overwrite-default-path", "backup-default-path"]
+ON_CONFLICT_MAPPER: dict[ON_CONFLICT_LOOSE, ON_CONFLICT_STRICT] = {
+    "t": "throw-error",
+    "os": "overwrite-self-managed",
+    "bs": "backup-self-managed",
+    "od": "overwrite-default-path",
+    "bd": "backup-default-path",
+    "throw-error": "throw-error",
+    "overwrite-self-managed": "overwrite-self-managed",
+    "backup-self-managed": "backup-self-managed",
+    "overwrite-default-path": "overwrite-default-path",
+    "backup-default-path": "backup-default-path",
+    }
+
+SENSITIVITY_LOOSE: TypeAlias = Literal["private", "p", "public", "b", "all", "a"]
+SENSITIVITY_STRICT: TypeAlias = Literal["private", "public", "all"]
+SENSITIVITY_MAP: dict[SENSITIVITY_LOOSE, SENSITIVITY_STRICT] = {
+    "private": "private",
+    "p": "private",
+    "public": "public",
+    "b": "public",
+    "all": "all",
+    "a": "all",
+}
+
+REPO_STRICT: TypeAlias = Literal["library", "user", "all"]
+REPO_LOOSE: TypeAlias = Literal["library", "l", "user", "u", "all", "a"]
+REPO_MAP: dict[REPO_LOOSE, REPO_STRICT] = {
+    "library": "library",
+    "l": "library",
+    "user": "user",
+    "u": "user",
+    "a": "all",
+    "all": "all",
+}
+
+METHOD_STRICT: TypeAlias = Literal["symlink", "copy"]
+METHOD_LOOSE: TypeAlias = Literal["symlink", "s", "copy", "c"]
+METHOD_MAP: dict[METHOD_LOOSE, METHOD_STRICT] = {
+    "symlink": "symlink",
+    "s": "symlink",
+    "copy": "copy",
+    "c": "copy",
+}
+
+
+
+def main_from_parser(
+    sensitivity: Annotated[SENSITIVITY_LOOSE, typer.Option(..., "--sensitivity", "-s", help="Sensitivity of the configuration files to manage.")],
+    method: Annotated[METHOD_LOOSE, typer.Option(..., "--method", "-m", help="Method to use for linking files")],
+    repo: Annotated[REPO_LOOSE, typer.Option(..., "--repo", "-r", help="Mapper source to use for config files.")] = "library",
+    on_conflict: Annotated[ON_CONFLICT_LOOSE, typer.Option(..., "--on-conflict", "-o", help="Action to take on conflict")] = "throw-error",
+    which: Annotated[Optional[str], typer.Option(..., "--which", "-w", help="Specific items to process ('all' for all items) (default is None, selection is interactive)")] = None,
+):
     """Terminology:
     SOURCE = Self-Managed-Config-File-Path
     TARGET = Config-File-Default-Path
-    For public config files, the source always exists, because we know it comes from machineconfig repo."""
+    For public config files in the library repo, the source always exists."""
     from machineconfig.profile.create_links import ConfigMapper, read_mapper
-    mapper_full = read_mapper()["public"]
+    repo_key = REPO_MAP[repo]
+    mapper_full_obj = read_mapper(repo=repo_key)
+    match sensitivity:
+        case "private" | "p":
+            mapper_full = mapper_full_obj["private"]
+        case "public" | "b":
+            mapper_full = mapper_full_obj["public"]
+        case "all" | "a":
+            mapper_full = {**mapper_full_obj["private"], **mapper_full_obj["public"]}
+            
     if which is None:
-        assert interactive is True
-        from machineconfig.utils.options import choose_from_options
-        items_chosen = choose_from_options(msg="Which symlink to create?", options=list(mapper_full.keys()), fzf=True, multi=True)
+        from machineconfig.utils.options_utils.tv_options import choose_from_dict_with_preview
+        import pprint
+        options_with_preview: dict[str, str] = {key: pprint.pformat(value, width=88, sort_dicts=True) for key, value in mapper_full.items()}
+        items_chosen = choose_from_dict_with_preview(options_with_preview, extension="toml", multi=True, preview_size_percent=75.0)
     else:
-        assert interactive is False
         if which == "all":
             items_chosen = list(mapper_full.keys())
         else:
             items_chosen = which.split(",")
     items_objections: dict[str, list[ConfigMapper]] = {item: mapper_full[item] for item in items_chosen if item in mapper_full}
+    if len(items_objections) == 0:
+        msg = typer.style("Error: ", fg=typer.colors.RED) + "No valid items selected."
+        typer.echo(msg)
+        typer.Exit(code=1)
+        return
 
-    from machineconfig.profile.create_links import apply_mapper
-    from machineconfig.profile.create_helper import copy_assets_to_machine
-    copy_assets_to_machine(which="settings")  # config files live here and will be linked to.
-    apply_mapper(mapper_data=items_objections, on_conflict=on_conflict, method=method)
-
-
-def main_private_from_parser(method: Annotated[Literal["symlink", "copy"], typer.Option(..., help="Method to use for linking files")],
-                             on_conflict: Annotated[Literal["throwError", "overwriteSelfManaged", "backupSelfManaged", "overwriteDefaultPath", "backupDefaultPath"], typer.Option(..., help="Action to take on conflict")] = "throwError",
-                             which: Annotated[Optional[str], typer.Option(..., help="Specific items to process")] = None,
-                             interactive: Annotated[bool, typer.Option(..., help="Run in interactive mode")] = False):
-    from machineconfig.profile.create_links import ConfigMapper, read_mapper
-
-    mapper_full = read_mapper()["private"]
-    if which is None:
-        assert interactive is True
-        from machineconfig.utils.options import choose_from_options
-        items_chosen = choose_from_options(msg="Which symlink to create?", options=list(mapper_full.keys()), fzf=True, multi=True)
-    else:
-        assert interactive is False
-        if which == "all":
-            items_chosen = list(mapper_full.keys())
-        else:
-            items_chosen = which.split(",")
-    items_objections: dict[str, list[ConfigMapper]] = {item: mapper_full[item] for item in items_chosen if item in mapper_full}
+    if (sensitivity == "public" or sensitivity == "b") and repo_key == "library":
+        from machineconfig.profile.create_helper import copy_assets_to_machine
+        copy_assets_to_machine(which="settings")  # config files live here and will be linked to.
 
+    method = METHOD_MAP[method]
     from machineconfig.profile.create_links import apply_mapper
-    apply_mapper(mapper_data=items_objections, on_conflict=on_conflict, method=method)
+    apply_mapper(mapper_data=items_objections, on_conflict=ON_CONFLICT_MAPPER[on_conflict], method=method)