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

machineconfig/scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md

@@ -43,3 +43,6 @@ applyTo: "**/*.py"
 * Please avoid writing README files and avoid docstring and comments in code unless absolutely necessary. Use clear naming conventions instead of documenting.
 * Always prefer to functional style of programming over OOP.
 * When passing arguments or constructing dicts or lists or tuples, avoid breaking lines too much, try to use ~ 150 characters per line before breaking to new one.
+
+# Privacy:
+* No matter what, never ever open/read/write/list anything under ~/dotfiles

machineconfig/scripts/python/croshell.py

@@ -16,13 +16,15 @@ def croshell(
     jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
     vscode: Annotated[bool, typer.Option("--vscode", "-c", help="open the script in vscode")] = False,
     # streamlit_viewer: Annotated[bool, typer.Option("--streamlit", "-s", help="view in streamlit app")] = False,
+    uv_with: Annotated[Optional[str], typer.Option("--uv-with", "-w", help="specify uv with packages to use")] = None,
     visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
     marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = False,
 ) -> None:
+    if uv_with is not None: user_uv_with_line = f"--with {uv_with} "
+    else: user_uv_with_line = ""
+
     from machineconfig.scripts.python.helpers_croshell.crosh import get_read_python_file_pycode, get_read_data_pycode
     from machineconfig.utils.meta import lambda_to_python_script
-    from machineconfig.utils.path_helper import get_choice_file
-    from machineconfig.utils.path_extended import PathExtended
     from pathlib import Path
     from machineconfig.utils.accessories import randstr
     import json
@@ -37,13 +39,15 @@ def croshell(
     ipython_profile: Optional[str] = profile
     file_obj = Path.cwd()  # initialization value, could be modified according to args.
     if path is not None:
+        from machineconfig.utils.path_helper import get_choice_file
         choice_file = get_choice_file(path=path, suffixes={".*"})
         if choice_file.suffix == ".py":
             program = choice_file.read_text(encoding="utf-8")
             text = f"📄 Selected file: {choice_file.name}"
             console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
         else:
-            program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(choice_file)), in_global=True, import_module=False)
+            program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(choice_file)),
+                                              in_global=True, import_module=False)
             text = f"📄 Reading data from: {file_obj.name}"
             console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
     else:  # if nothing is specified, then run in interactive mode.
@@ -64,11 +68,12 @@ def croshell(
         return textwrap.dedent("\n".join(inspect.getsource(f).splitlines()[1:]))
     preprogram += get_body_simple_function_no_args(preprogram_func)
 
-    pyfile = PathExtended.tmp().joinpath(f"tmp_scripts/python/croshell/{randstr()}/script.py")
+    from pathlib import Path
+    pyfile = Path.home().joinpath(f"tmp_results/tmp_scripts/python/croshell/{randstr()}/script.py")
     pyfile.parent.mkdir(parents=True, exist_ok=True)
-
     title = "Reading Data"
-    def_code = lambda_to_python_script(lambda: get_read_python_file_pycode(path=str(pyfile), title=title), in_global=False, import_module=False)
+    def_code = lambda_to_python_script(lambda: get_read_python_file_pycode(path=str(pyfile), title=title),
+                                       in_global=False, import_module=False)
     # print(def_code)
     python_program = preprogram + "\n\n" + def_code + program
     pyfile.write_text(python_program, encoding="utf-8")
@@ -102,37 +107,37 @@ def croshell(
             pass
     if visidata:
         if file_obj.suffix == ".json":
-            fire_line = f"uv run --python 3.14 --with visidata vd {str(file_obj)}"
+            fire_line = f"uv run --python 3.14 {user_uv_with_line} --with visidata vd {str(file_obj)}"
         else:
-            fire_line = f"uv run --python 3.14 --with visidata,pyarrow vd {str(file_obj)}"
+            fire_line = f"uv run --python 3.14 {user_uv_with_line}--with visidata,pyarrow vd {str(file_obj)}"
     elif marimo:
-        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""--with marimo --project "{str(Path.home().joinpath("code/machineconfig"))}" """
-        else: requirements = """--python 3.14 --with "marimo,cowsay,machineconfig[plot]>=7.53" """
+        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""{user_uv_with_line} --with marimo --project "{str(Path.home().joinpath("code/machineconfig"))}" """
+        else: requirements = f"""--python 3.14 {user_uv_with_line} user_uv_with_line--with "marimo,cowsay,machineconfig[plot]>=7.69" """
         fire_line = f"""
 cd {str(pyfile.parent)}
 uv run --python 3.14 --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
 uv run {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
 """
     elif jupyter:
-        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" --with jupyterlab """
-        else: requirements = """--with "cowsay,machineconfig[plot]>=7.53" """
+        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""{user_uv_with_line}  --with jupyterlab --project "{str(Path.home().joinpath("code/machineconfig"))}" """
+        else: requirements = f"""{user_uv_with_line} --with "cowsay,machineconfig[plot]>=7.69" """
         fire_line = f"uv run {requirements} jupyter-lab {str(nb_target)}"
     elif vscode:
+        user_uv_add = f"uv add {uv_with}" if uv_with is not None else ""
         fire_line = f"""
 cd {str(pyfile.parent)}
 uv init --python 3.14
 uv venv
-uv add "cowsay,machineconfig[plot]>=7.53"
+uv add "cowsay,machineconfig[plot]>=7.69"
+uv add {user_uv_add}
 # code serve-web
 code --new-window {str(pyfile)}
 """
     else:
         if interpreter == "ipython": profile = f" --profile {ipython_profile} --no-banner"
         else: profile = ""
-        if Path.home().joinpath("code/machineconfig").exists(): ve_line = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" """
-        else: ve_line = """--python 3.14 --with "cowsay,machineconfig[plot]>=7.53" """
-        # ve_path_maybe, ipython_profile_maybe = get_ve_path_and_ipython_profile(Path.cwd())
-        # --python 3.14
+        if Path.home().joinpath("code/machineconfig").exists(): ve_line = f"""{user_uv_with_line} --project "{str(Path.home().joinpath("code/machineconfig"))}" """
+        else: ve_line = f"""--python 3.14 {user_uv_with_line} --with "cowsay,machineconfig[plot]>=7.69" """
         fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
 
     from machineconfig.utils.code import exit_then_run_shell_script

machineconfig/scripts/python/devops.py

@@ -12,17 +12,16 @@ import machineconfig.scripts.python.helpers_devops.cli_nw as cli_network
 
 def install(which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program names to install, or group name if --group flag is set.")] = None,
         group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
-        interactive: Annotated[bool, typer.Option(..., "--interactive", "-ia", help="Interactive selection of programs to install.")] = False,
+        interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
     ) -> None:
         """📦 Install packages"""
-        import machineconfig.utils.installer_utils.installer as installer_entry_point
-        installer_entry_point.main(which=which, group=group, interactive=interactive)
+        import machineconfig.utils.installer_utils.installer_cli as installer_entry_point
+        installer_entry_point.main_installer_cli(which=which, group=group, interactive=interactive)
 
 
 def get_app():
     app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=False,
                       add_completion=False)
-    _ = install
     app.command("install", no_args_is_help=True, help="🛠️ [i] Install essential packages")(install)
     app.command("i", no_args_is_help=True, help="Install essential packages", hidden=True)(install)
     app_repos = cli_repos.get_app()

machineconfig/scripts/python/devops_navigator.py

@@ -1,7 +1,3 @@
-"""
-TUI for navigating through machineconfig command structure using Textual.
-"""
-
 from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp
 
 

machineconfig/scripts/python/env_manager/path_manager_tui.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "machineconfig>=7.53",
+#     "machineconfig>=7.69",
 #     "textual",
 #     "pyperclip",
 # ]

machineconfig/scripts/python/fire_jobs.py

@@ -7,20 +7,16 @@ fire
 
 """
 
-from machineconfig.utils.ve import get_ve_path_and_ipython_profile
-from machineconfig.utils.accessories import get_repo_root, randstr
-from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs, extract_kwargs, parse_fire_args_from_context
-from machineconfig.utils.path_helper import get_choice_file
-
-import platform
 from typing import Optional, Annotated
-from pathlib import Path
 import typer
 
 
-def route(args: FireJobArgs, fire_args: str = "") -> None:
+def route(args: "FireJobArgs", fire_args: str = "") -> None:
+    from pathlib import Path
+    from machineconfig.utils.path_helper import get_choice_file
+    from machineconfig.utils.accessories import get_repo_root, randstr
     choice_file = get_choice_file(args.path, suffixes=None)
-    repo_root = get_repo_root(Path(choice_file))
+    repo_root = get_repo_root(choice_file)
     print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
     if args.marimo:
         print(f"🧽 Preparing to launch Marimo notebook for `{choice_file}`...")
@@ -32,13 +28,13 @@ uv run --python 3.14 --with marimo marimo convert {choice_file} -o marimo_nb.py
 uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.py
 """
         from machineconfig.utils.code import exit_then_run_shell_script
-
         print(f"🚀 Launching Marimo notebook for `{choice_file}`...")
         exit_then_run_shell_script(script)
         return
 
     # =========================  preparing kwargs_dict
     if choice_file.suffix == ".py":
+        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import extract_kwargs
         kwargs_dict = extract_kwargs(args)  # This now returns empty dict, but kept for compatibility
     else:
         kwargs_dict = {}
@@ -63,6 +59,7 @@ uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.
             exe = f"uv run {with_project} jupyter-lab"
         else:
             if args.interactive:
+                from machineconfig.utils.ve import get_ve_path_and_ipython_profile
                 _ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
                 if ipy_profile is None:
                     ipy_profile = "default"
@@ -76,9 +73,8 @@ uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.
     else:
         raise NotImplementedError(f"File type {choice_file.suffix} not supported, in the sense that I don't know how to fire it.")
 
-    if (
-        args.module or (args.debug and args.choose_function)
-    ):  # because debugging tools do not support choosing functions and don't interplay with fire module. So the only way to have debugging and choose function options is to import the file as a module into a new script and run the function of interest there and debug the new script.
+    if args.module or (args.debug and args.choose_function):
+        # because debugging tools do not support choosing functions and don't interplay with fire module. So the only way to have debugging and choose function options is to import the file as a module into a new script and run the function of interest there and debug the new script.
         assert choice_file.suffix == ".py", f"File must be a python file to be imported as a module. Got {choice_file}"
         from machineconfig.scripts.python.helpers_fire_command.file_wrangler import get_import_module_code, wrap_import_in_try_except
         from machineconfig.utils.meta import lambda_to_python_script
@@ -92,9 +88,12 @@ uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.
             in_global=True,
             import_module=False,
         )
+        # print(f"🧩 Preparing import code for module import:\n{import_code}")
         code_printing = lambda_to_python_script(
-            lambda: print_code(code=import_code_robust, lexer="python", desc="import code"), in_global=True, import_module=False
+            lambda: print_code(code=import_code_robust, lexer="python", desc="import as module code"),
+            in_global=True, import_module=False
         )
+        print(f"🧩 Preparing import code for module import:\n{import_code}")
         if choice_function is not None:
             calling = f"""res = {choice_function}({("**" + str(kwargs_dict)) if kwargs_dict else ""})"""
         else:
@@ -105,6 +104,7 @@ uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.
 
     # =========================  determining basic command structure: putting together exe & choice_file & choice_function & pdb
     if args.debug:
+        import platform
         if platform.system() == "Windows":
             command = f"{exe} -m ipdb {choice_file} "  # pudb is not available on windows machines, use poor man's debugger instead.
         elif platform.system() in ["Linux", "Darwin"]:
@@ -172,6 +172,7 @@ uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.
         export_line = add_to_path(path_variable="PYTHONPATH", directory=str(repo_root))
         command = export_line + "\n" + command
     if args.loop:
+        import platform
         if platform.system() in ["Linux", "Darwin"]:
             command = command + "\nsleep 0.5"
         elif platform.system() == "Windows":
@@ -213,6 +214,7 @@ def fire(
     """Main function to process fire jobs arguments."""
 
     # Get Fire arguments from context
+    from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs, parse_fire_args_from_context
     fire_args = parse_fire_args_from_context(ctx)
 
     args = FireJobArgs(
@@ -265,4 +267,4 @@ def main():
 
 
 if __name__ == "__main__":
-    pass
+    from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs

machineconfig/scripts/python/ftpx.py

@@ -6,17 +6,7 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 """
 
 import typer
-from typing_extensions import Annotated
-from rich.console import Console
-from rich.panel import Panel
-
-from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
-from machineconfig.utils.accessories import pprint
-
-
-console = Console()
+from typing import Annotated
 
 
 def ftpx(
@@ -26,6 +16,18 @@ def ftpx(
     zipFirst: Annotated[bool, typer.Option("--zipFirst", "-z", help="Zip before sending.")] = False,
     cloud: Annotated[bool, typer.Option("--cloud", "-c", help="Transfer through the cloud.")] = False,
 ) -> None:
+
+    from rich.console import Console
+    from rich.panel import Panel
+
+    from machineconfig.utils.ssh import SSH
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
+    from machineconfig.utils.accessories import pprint
+
+
+    console = Console()
+
     console.print(
         Panel(
             "\n".join(

machineconfig/scripts/python/helpers/ast_search.py

@@ -0,0 +1,74 @@
+
+import ast
+import os
+from typing import TypedDict
+
+
+class SymbolInfo(TypedDict):
+    """Represents a symbol (module, class, or function) in the repository."""
+    type: str
+    name: str
+    path: str
+    # line: int | None
+    # column: int | None
+    docstring: str
+
+
+def _get_docstring(node: ast.AsyncFunctionDef | ast.FunctionDef | ast.ClassDef | ast.Module) -> str:
+    """Extract docstring from an AST node."""
+    return ast.get_docstring(node) or ""
+
+
+def _extract_symbols(tree: ast.AST, module_path: str, source: str) -> list[SymbolInfo]:
+    """Extract symbols from an AST tree."""
+    symbols: list[SymbolInfo] = []
+    
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            symbol: SymbolInfo = {
+                "type": "function",
+                "name": node.name,
+                "path": f"{module_path}.{node.name}",
+                "docstring": _get_docstring(node),
+            }
+            symbols.append(symbol)
+        elif isinstance(node, ast.ClassDef):
+            symbol: SymbolInfo = {
+                "type": "class",
+                "name": node.name,
+                "path": f"{module_path}.{node.name}",
+                "docstring": _get_docstring(node),
+            }
+            symbols.append(symbol)
+    
+    return symbols
+
+
+def get_repo_symbols(repo_path: str) -> list[SymbolInfo]:
+    skip_dirs = {'.venv', 'venv', '__pycache__', '.mypy_cache', '.pytest_cache', '.git'}
+    results: list[SymbolInfo] = []
+    counter: int = 0
+    for root, dirs, files in os.walk(repo_path):
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith('.')]
+        for file in files:
+            if not file.endswith(".py"):
+                continue
+            file_path = os.path.join(root, file)
+            module_path = (
+                os.path.relpath(file_path, repo_path)
+                .replace(os.sep, ".")
+                .removesuffix(".py")
+            )
+            try:
+                if counter % 100 == 0: print(f"🔍 Parsing {counter}: {file_path}...")
+                with open(file_path, encoding="utf-8") as f:
+                    source = f.read()
+                tree = ast.parse(source, filename=file_path)
+                symbols = _extract_symbols(tree, module_path, source)
+                results.extend(symbols)
+            except Exception as e:
+                print(f"⚠️ Error parsing {file_path}: {e}")
+                continue
+            counter += 1
+
+    return results