machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/utils/terminal.py

@@ -1,9 +1,6 @@
-from machineconfig.utils.path_extended import PathExtended, OPLike
+from machineconfig.utils.path_extended import PathExtended
 import subprocess
 from typing import Any, BinaryIO, Optional, Union
-import platform
-import sys
-import os
 from typing import Literal, TypeAlias
 from dataclasses import dataclass
 
@@ -38,7 +35,8 @@ class Response:
     def __call__(self, *args: Any, **kwargs: Any) -> Optional[str]:
         _ = args, kwargs
         return self.op.rstrip() if type(self.op) is str else None
-
+    def __repr__(self) -> str:
+        return f"Response({self.input=}, {self.output=}, {self.desc=}, {self.op=}, {self.ip=}, {self.err=}, {self.returncode=})"
     @property
     def op(self) -> str:
         return self.output.stdout
@@ -100,138 +98,3 @@ class Response:
         txt = tmp1 + Text(str(self.input), style="white") + tmp2 + Text("\n".join(list_str), style="white")
         con.print(Panel(txt, title=f"🖥️  {self.desc}", subtitle=f"📋 {desc}", width=150, style="bold cyan on black"))
         return self
-
-
-# DEPRECATED: Use subprocess.run directly instead of Terminal class.
-# The Terminal class has been replaced with inline subprocess calls to underlying primitives.
-# This file is kept for reference but should not be used.
-
-
-class Terminal:
-    def __init__(self, stdout: Optional[int] = subprocess.PIPE, stderr: Optional[int] = subprocess.PIPE, stdin: Optional[int] = subprocess.PIPE, elevated: bool = False):
-        self.machine: str = platform.system()
-        self.elevated: bool = elevated
-        self.stdout = stdout
-        self.stderr = stderr
-        self.stdin = stdin
-
-    # def set_std_system(self): self.stdout = sys.stdout; self.stderr = sys.stderr; self.stdin = sys.stdin
-    def set_std_pipe(self):
-        self.stdout = subprocess.PIPE
-        self.stderr = subprocess.PIPE
-        self.stdin = subprocess.PIPE
-
-    def set_std_null(self):
-        self.stdout, self.stderr, self.stdin = subprocess.DEVNULL, subprocess.DEVNULL, subprocess.DEVNULL  # Equivalent to `echo 'foo' &> /dev/null`
-
-    def run(self, *cmds: str, shell: Optional[SHELLS] = "default", check: bool = False, ip: Optional[str] = None) -> Response:  # Runs SYSTEM commands like subprocess.run
-        """Blocking operation. Thus, if you start a shell via this method, it will run in the main and won't stop until you exit manually IF stdin is set to sys.stdin, otherwise it will run and close quickly. Other combinations of stdin, stdout can lead to funny behaviour like no output but accept input or opposite.
-        * This method is short for: res = subprocess.run("powershell command", capture_output=True, shell=True, text=True) and unlike os.system(cmd), subprocess.run(cmd) gives much more control over the output and input.
-        * `shell=True` loads up the profile of the shell called so more specific commands can be run. Importantly, on Windows, the `start` command becomes availalbe and new windows can be launched.
-        * `capture_output` prevents the stdout to redirect to the stdout of the script automatically, instead it will be stored in the Response object returned. # `capture_output=True` same as `stdout=subprocess.PIPE, stderr=subprocess.PIPE`"""
-        my_list = list(
-            cmds
-        )  # `subprocess.Popen` (process open) is the most general command. Used here to create asynchronous job. `subprocess.run` is a thin wrapper around Popen that makes it wait until it finishes the task. `suprocess.call` is an archaic command for pre-Python-3.5.
-        if self.machine == "Windows" and shell in {"powershell", "pwsh"}:
-            my_list = [shell, "-Command"] + my_list  # alternatively, one can run "cmd"
-        if self.elevated is False or self.is_user_admin():
-            resp: subprocess.CompletedProcess[str] = subprocess.run(my_list, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=check, input=ip)
-        else:
-            resp = __import__("ctypes").windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
-        return Response.from_completed_process(resp)
-
-    def run_script(self, script: str, shell: SHELLS = "default", verbose: bool = False):
-        if self.machine == "Linux":
-            script = "#!/bin/bash" + "\n" + script  # `source` is only available in bash.
-        script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if self.machine == "Windows" else ".sh", folder="tmp_scripts")
-        script_file.write_text(script, newline={"Windows": None, "Linux": "\n"}[self.machine])
-        if shell == "default":
-            if self.machine == "Windows":
-                start_cmd = "powershell"  # default shell on Windows is cmd which is not very useful. (./source is not available)
-                full_command: Union[list[str], str] = [start_cmd, str(script_file)]  # shell=True will cause this to be a string anyway (with space separation)
-            else:
-                start_cmd = "bash"
-                full_command = f"{start_cmd} {script_file}"  # full_command = [start_cmd, str(script_file)]
-        else:
-            full_command = f"{shell} {script_file}"  # full_command = [shell, str(tmp_file)]
-        if verbose:
-            desc = "Script to be executed:"
-            if platform.system() == "Windows":
-                lexer = "powershell"
-            elif platform.system() == "Linux":
-                lexer = "sh"
-            elif platform.system() == "Darwin":
-                lexer = "sh"  # macOS uses similar shell to Linux
-            else:
-                raise NotImplementedError(f"Platform {platform.system()} not supported.")
-            from rich.console import Console
-            from rich.panel import Panel
-            from rich.syntax import Syntax
-            import rich.progress as pb
-
-            console = Console()
-            console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 {desc}"), style="bold red")
-            with pb.Progress(transient=True) as progress:
-                _task = progress.add_task(f"Running Script @ {script_file}", total=None)
-                resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
-        else:
-            resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
-        return Response.from_completed_process(resp)
-
-    def run_py(self, script: str, wdir: OPLike = None, interactive: bool = True, ipython: bool = True, shell: Optional[str] = None, terminal: str = "", new_window: bool = True, header: bool = True):  # async run, since sync run is meaningless.
-        script = (Terminal.get_header(wdir=wdir, toolbox=True) if header else "") + script + ("\nDisplayData.set_pandas_auto_width()\n" if terminal in {"wt", "powershell", "pwsh"} else "")
-        py_script = PathExtended.tmpfile(name="tmp_python_script", suffix=".py", folder="tmp_scripts/terminal")
-        py_script.write_text(f"""print(r'''{script}''')""" + "\n" + script)
-        print(f"""🚀 [ASYNC PYTHON SCRIPT] Script URI:
-   {py_script.absolute().as_uri()}""")
-        print("Script to be executed asyncronously: ", py_script.absolute().as_uri())
-        shell_script = f"""
-{f"cd {wdir}" if wdir is not None else ""}
-{"ipython" if ipython else "python"} {"-i" if interactive else ""} {py_script}
-"""
-        shell_path = PathExtended.tmpfile(name="tmp_shell_script", suffix=".sh" if self.machine == "Linux" else ".ps1", folder="tmp_scripts/shell")
-        shell_path.write_text(shell_script)
-        if shell is None and self.machine == "Windows":
-            shell = "pwsh"
-        window = "start" if new_window and self.machine == "Windows" else ""
-        os.system(f"{window} {terminal} {shell} {shell_script}")
-
-    @staticmethod
-    def is_user_admin() -> bool:  # adopted from: https://stackoverflow.com/questions/19672352/how-to-run-script-with-elevated-privilege-on-windows"""
-        if os.name == "nt":
-            try:
-                return __import__("ctypes").windll.shell32.IsUserAnAdmin()
-            except Exception:
-                import traceback
-
-                traceback.print_exc()
-                print("Admin check failed, assuming not an admin.")
-                return False
-        else:
-            return os.getuid() == 0  # Check for root on Posix
-
-    #     @staticmethod
-    #     def run_as_admin(file: PLike, params: Any, wait: bool = False):
-    #         proce_info = install_n_import(library="win32com", package="pywin32", fromlist=["shell.shell.ShellExecuteEx"]).shell.shell.ShellExecuteEx(lpVerb='runas', lpFile=file, lpParameters=params)
-    #         # TODO update PATH for this to take effect immediately.
-    #         if wait: time.sleep(1)
-    #         return proce_info
-
-    @staticmethod
-    def get_header(wdir: OPLike, toolbox: bool):
-        if toolbox:
-            toobox_code = """
-try:
-    from crocodile.toolbox import *
-except ImportError:
-    print("Crocodile not found, skipping import.")
-    pass
-"""
-        else:
-            toobox_code = "# No toolbox import."
-        return f"""
-# >> Code prepended
-{toobox_code}
-{'''sys.path.insert(0, r'{wdir}') ''' if wdir is not None else "# No path insertion."}
-# >> End of header, start of script passed
-"""

machineconfig/utils/tst.py

@@ -0,0 +1,20 @@
+from typing import Callable, ParamSpec, TypeVar, Any, Dict
+
+P = ParamSpec('P')
+R = TypeVar('R')
+
+def typed_function(func: Callable[P, R], signature_dict: Dict[str, Any]) -> Callable[P, R]:
+    """
+    Returns the function with its signature preserved using ParamSpec.
+
+    The signature_dict is passed for potential future use or documentation,
+    but is not currently used in the implementation.
+
+    Args:
+        func: The function whose signature is to be preserved.
+        signature_dict: A dictionary describing the function's signature (not used).
+
+    Returns:
+        The original function, typed with ParamSpec to preserve its signature.
+    """
+    return func

machineconfig/utils/upgrade_packages.py

@@ -1,5 +1,15 @@
+
 """
+
 Generate uv add commands from pyproject.toml dependency groups.
+
+#!/bin/bash
+# rm ./pyproject.toml
+rm ./uv.lock
+rm -rfd .venv
+uv venv --python 3.13
+uv init
+
 """
 
 from pathlib import Path
@@ -15,44 +25,48 @@ def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
         pyproject_path: Path to the pyproject.toml file
         output_path: Path where to write the uv add commands
     """
-    # Read pyproject.toml
     with open(pyproject_path, "rb") as f:
         pyproject_data: dict[str, Any] = tomllib.load(f)
 
     commands: list[str] = []
 
-    # Handle main dependencies (no group)
     if "project" in pyproject_data and "dependencies" in pyproject_data["project"]:
-        main_deps = pyproject_data["project"]["dependencies"]
+        main_deps: list[str] = pyproject_data["project"]["dependencies"]
         if main_deps:
-            # Extract package names without version constraints
-            package_names = [extract_package_name(dep) for dep in main_deps]
-            commands.append(f"uv add {' '.join(package_names)}")
+            package_names: list[str] = [extract_package_name(dep) for dep in main_deps]
+            commands.append(f"uv add --no-cache {' '.join(package_names)}")
 
-    # Handle optional dependencies as groups
     if "project" in pyproject_data and "optional-dependencies" in pyproject_data["project"]:
-        optional_deps = pyproject_data["project"]["optional-dependencies"]
+        optional_deps: dict[str, list[str]] = pyproject_data["project"]["optional-dependencies"]
         for group_name, deps in optional_deps.items():
             if deps:
                 package_names = [extract_package_name(dep) for dep in deps]
-                commands.append(f"uv add {' '.join(package_names)} --group {group_name}")
+                commands.append(f"uv add --no-cache --group {group_name} {' '.join(package_names)}")
 
-    # Handle dependency-groups (like dev)
     if "dependency-groups" in pyproject_data:
-        dep_groups = pyproject_data["dependency-groups"]
+        dep_groups: dict[str, list[str]] = pyproject_data["dependency-groups"]
         for group_name, deps in dep_groups.items():
             if deps:
                 package_names = [extract_package_name(dep) for dep in deps]
                 if group_name == "dev":
-                    commands.append(f"uv add {' '.join(package_names)} --dev")
+                    commands.append(f"uv add --no-cache --dev {' '.join(package_names)}")
                 else:
-                    commands.append(f"uv add {' '.join(package_names)} --group {group_name}")
-
-    # Write commands to output file
-    with open(output_path, "w") as f:
-        for command in commands:
-            f.write(command + "\n")
-
+                    commands.append(f"uv add --no-cache --group {group_name} {' '.join(package_names)}")
+
+    # with open(output_path, "w") as f:
+    #     f.write("#!/bin/bash\n")
+    #     f.write("set -e\n\n")
+    #     f.write("uv cache clean --force\n\n")
+    #     for command in commands:
+    #         f.write(command + "\n")
+    script = f"""
+#!/bin/bash
+set -e
+uv cache clean --force
+rm -rfd .venv
+{"".join(f"{command}\n" for command in commands)}
+"""
+    output_path.write_text(script.strip() + "\n", encoding="utf-8")
     print(f"Generated {len(commands)} uv add commands in {output_path}")
 
 
@@ -79,13 +93,80 @@ def extract_package_name(dependency_spec: str) -> str:
     return dependency_spec.strip()
 
 
+def upgrade_machine_config_version() -> None:
+    """
+    Upgrade machineconfig version in pyproject.toml and all source files.
+    
+    Reads current version from pyproject.toml, bumps it by 0.01, and replaces
+    all occurrences of machineconfig>={old_version} and machineconfig[group]>={old_version}
+    with the new version in Python (.py), shell (.sh), and PowerShell (.ps1) files.
+    """
+    current_dir: Path = Path.cwd()
+    pyproject_file: Path = current_dir / "pyproject.toml"
+    
+    # Read current version from pyproject.toml
+    with open(pyproject_file, "rb") as f:
+        pyproject_data: dict[str, Any] = tomllib.load(f)
+    
+    current_version_str: str = pyproject_data["project"]["version"]
+    version_parts: list[str] = current_version_str.split(".")
+    major: int = int(version_parts[0])
+    minor: int = int(version_parts[1])
+    
+    # Bump minor version by 1, preserving zero-padding
+    new_minor: int = minor + 1
+    # Preserve the same number of digits as the original minor version
+    minor_width: int = len(version_parts[1])
+    new_version: str = f"{major}.{new_minor:0{minor_width}d}"
+    
+    # Collect all optional dependency groups
+    optional_groups: set[str] = set()
+    if "project" in pyproject_data and "optional-dependencies" in pyproject_data["project"]:
+        optional_groups.update(pyproject_data["project"]["optional-dependencies"].keys())
+    if "dependency-groups" in pyproject_data:
+        optional_groups.update(pyproject_data["dependency-groups"].keys())
+    
+    print(f"Upgrading from {current_version_str} to {new_version}")
+    print(f"Found optional groups: {', '.join(sorted(optional_groups))}")
+    
+    # Update pyproject.toml
+    content: str = pyproject_file.read_text(encoding="utf-8")
+    updated_content: str = content.replace(f'version = "{current_version_str}"', f'version = "{new_version}"')
+    pyproject_file.write_text(updated_content, encoding="utf-8")
+    print(f"Updated pyproject.toml: {current_version_str} -> {new_version}")
+    
+    # Find all Python files and replace version constraints
+    py_files: list[Path] = list(current_dir.glob("**/*.py")) + list(current_dir.glob("**/*.sh")) + list(current_dir.glob("**/*.ps1"))
+    
+    files_updated: int = 0
+    for file_path in py_files:
+        try:
+            file_content: str = file_path.read_text(encoding="utf-8")
+            updated_file_content: str = file_content
+            
+            # Replace base constraint (without group)
+            old_constraint: str = f"machineconfig>={current_version_str}"
+            new_constraint: str = f"machineconfig>={new_version}"
+            if old_constraint in updated_file_content:
+                updated_file_content = updated_file_content.replace(old_constraint, new_constraint)
+            
+            # Replace constraints with optional groups
+            for group in optional_groups:
+                old_group_constraint: str = f"machineconfig[{group}]>={current_version_str}"
+                new_group_constraint: str = f"machineconfig[{group}]>={new_version}"
+                if old_group_constraint in updated_file_content:
+                    updated_file_content = updated_file_content.replace(old_group_constraint, new_group_constraint)
+            
+            if updated_file_content != file_content:
+                file_path.write_text(updated_file_content, encoding="utf-8")
+                files_updated += 1
+                print(f"Updated {file_path.relative_to(current_dir)}")
+        except (UnicodeDecodeError, PermissionError):
+            # Skip files that can't be read as text
+            pass
+    
+    print(f"Updated {files_updated} files with version constraint")
+
+
 if __name__ == "__main__":
-    # Example usage
-    current_dir = Path.cwd()
-    pyproject_file = current_dir / "pyproject.toml"
-    output_file = current_dir / "uv_add_commands.txt"
-
-    if pyproject_file.exists():
-        generate_uv_add_commands(pyproject_file, output_file)
-    else:
-        print(f"pyproject.toml not found at {pyproject_file}")
+    upgrade_machine_config_version()

machineconfig/utils/ve.py

@@ -1,14 +1,15 @@
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.io import read_ini
-import platform
+
 from typing import Optional
 
 
-def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[str], Optional[str]]:
+def get_ve_path_and_ipython_profile(init_path: "Path") -> tuple[Optional[str], Optional[str]]:
     """Works with .ve.ini .venv and .ve_path"""
     ve_path: Optional[str] = None
     ipy_profile: Optional[str] = None
     tmp = init_path
+
+    from machineconfig.utils.io import read_ini
+
     for _ in init_path.parents:
         if tmp.joinpath(".ve.ini").exists():
             ini = read_ini(tmp.joinpath(".ve.ini"))
@@ -39,10 +40,17 @@ def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[s
 
 
 def get_ve_activate_line(ve_root: str):
+    import platform
+    from pathlib import Path
     if platform.system() == "Windows":
-        activate_ve_line = f". {ve_root}/Scripts/activate.ps1"
+        q = Path(ve_root).expanduser().relative_to(Path.home()).as_posix()
+        activate_ve_line = f". $HOME/{q}/Scripts/activate.ps1"
     elif platform.system() in ["Linux", "Darwin"]:
         activate_ve_line = f". {ve_root}/bin/activate"
     else:
         raise NotImplementedError(f"Platform {platform.system()} not supported.")
     return activate_ve_line
+
+
+if __name__ == "__main__":
+    from pathlib import Path

machineconfig-7.69.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: machineconfig
+Version: 7.69
+Summary: Dotfiles management package
+Author-email: Alex Al-Saffar <programmer@usa.com>
+License: Apache 2.0
+Project-URL: Homepage, https://github.com/thisismygitrepo/machineconfig
+Project-URL: Bug Tracker, https://github.com/thisismygitrepo/machineconfig/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=44.0.2
+Requires-Dist: fire>=0.7.0
+Requires-Dist: joblib>=1.5.2
+Requires-Dist: paramiko>=3.5.1
+Requires-Dist: randomname>=0.2.1
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich>=14.0.0
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: gitpython>=3.1.44
+Requires-Dist: pyfzf>=0.3.1
+Requires-Dist: rclone-python>=0.1.23
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: typer-slim>=0.19.2
+Requires-Dist: typer>=0.19.2
+Provides-Extra: windows
+Requires-Dist: pywin32; extra == "windows"
+Provides-Extra: plot
+Requires-Dist: sqlalchemy>=2.0.43; extra == "plot"
+Requires-Dist: ipykernel>=6.30.1; extra == "plot"
+Requires-Dist: ipython>=9.5.0; extra == "plot"
+Requires-Dist: jupyterlab>=4.4.9; extra == "plot"
+Requires-Dist: kaleido>=1.1.0; extra == "plot"
+Requires-Dist: matplotlib>=3.10.6; extra == "plot"
+Requires-Dist: nbformat>=5.10.4; extra == "plot"
+Requires-Dist: numpy>=2.3.3; extra == "plot"
+Requires-Dist: plotly>=6.3.0; extra == "plot"
+Requires-Dist: polars>=1.33.1; extra == "plot"
+Requires-Dist: python-magic>=0.4.27; extra == "plot"
+
+
+<p align="center">
+
+<a href="https://github.com/thisismygitrepo/machineconfig/commits">
+<img src="https://img.shields.io/github/commit-activity/m/thisismygitrepo/machineconfig" />
+</a>
+
+</p>
+
+
+# 🧠 Welcome to **Machineconfig**
+
+**Machineconfig** is a cli-based **Digital Life Manager** — It's called so because no existing category of software fully captures its scope. At the same time, it is a *Package Manager*, *Configuration Manager*, *Automation Tool*, *Dotfiles Manager*, *Data Solution*, and *Code Manager*, among other functionalities covered, all rolled into one seamless experience.
+
+
+## 💡 Motivation
+
+But why do we need such a tool to combine all those functionalities?? Because you need one tool to manager your stack and dev-environment, put it together and maintain it.
+Consider this concrete scenario: When setting up a new machine, VM, or Docker container, you often face dependency chains like this:
+
+```mermaid
+flowchart TD
+    A["Need to setup my [dev] environment"] --> B["need my tool x, e.g.: yadm"]
+    B --> C["Requires git"]
+    C --> D["Requires package manager, e.g. brew"]
+    D --> E["Requires curl"]
+    E --> F["Requires network setup / system update"]
+    F --> G["Requires system configuration access"]
+    G --> H["Finally ready to start setup the tool x."]
+```
+
+Machineconfig builds on shoulder of giants. A suite of best-in-class stack of projects on github are used, the most starred, active and written in Rust tools are used when possible. The goal is to provide a seamless experience that abstracts away the complexity of setting up and maintaining your digital environment. The goal of machineconfig is to replicate your setup, config, code, data and secrets on any machine, any os, in 5 minutes, using minimal user input. Then, from that point, machineconfig will help you maintain, update, backup and sync your digital life across all your devices, automatically.
+
+
+## ⚙️ Functional Overview
+
+| Category               | Comparable Tools                              | Description                                               |
+|------------------------|----------------------------------------------|-----------------------------------------------------------|
+| **Package Manager**     | `winget`, `apt`, `brew`, `nix`               | Installs and manages software packages across systems.    |
+| **Configuration Manager** | `Ansible`, `Chef`, `Puppet`                | Configures and maintains system‐level preferences.        |
+| **Automation Tool**     | `Airflow`, `Prefect`, `Dagster`, `Celery`    | Automates repetitive tasks, pipelines, orchestration.     |
+| **Dotfiles Manager**    | `chezmoi`, `yadm`, `rcm`, `GNU Stow`        | Synchronises dotfiles & personal configs across systems.  |
+| **Data Solution**       | `rclone`, `rsync`                            | Handles backups, mirroring and secure file sync.          |
+| **Code Manager**        | `strong‐box`, `Vault`                        | Manages and protects code snippets, secrets and creds.    |
+
+---
+
+
+# Install On Windows:
+
+```powershell
+# install tool the tool only:
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"  # Skip if UV is already installed
+uv tool install --upgrade --python 3.14 machineconfig
+# interactive install of machineconfig and following on to run it and make basic machine configuration (RECOMMENDED):
+iex (iwr bit.ly/cfgwindows).Content  # Or, if UV is installed: iex (uvx machineconfig define)
+# Quick install and configure (optionals are accepted by default):
+iex (iwr bit.ly/cfgwq).Content
+```
+
+
+# Install On Linux and MacOS
+
+```bash
+# install the tool only:
+curl -LsSf https://astral.sh/uv/install.sh | sh  # Skip if UV is already installed
+uv tool install --upgrade --python 3.14 machineconfig
+# interactive install of machineconfig and following on to run it and make basic machine configuration (RECOMMENDED):
+. <(curl -L bit.ly/cfglinux) # Or, if UV is installed: . <(uvx machineconfig define)
+```
+
+
+# Author
+Alex Al-Saffar. [email](mailto:programmer@usa.com)
+
+# Contributor
+Ruby Chan. [email](mailto:ruby.chan@sa.gov.au)
+
+
+[![Alex's github activity graph](https://github-readme-activity-graph.vercel.app/graph?username=thisismygitrepo)](https://github.com/ashutosh00710/github-readme-activity-graph)
+