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

machineconfig/scripts/python/ftpx.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env -S uv run --project /home/alex/code/machineconfig --script
 """Sx & Rx
 
 TODO: add support for cases in which source or target has non 22 default port number and is defineda as user@host:port:path which makes 2 colons in the string.
@@ -6,39 +5,56 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 
 """
 
-import argparse
-from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.scripts.python.helpers.helpers2 import ES
-from machineconfig.utils.accessories import pprint
-
-
-def main():
-    print("""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 🚀 FTP File Transfer
-┃ 📋 Starting transfer process...
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-    parser = argparse.ArgumentParser(description="FTP client")
-
-    parser.add_argument("source", help="source path (machine:path)")
-    parser.add_argument("target", help="target path (machine:path)")
-
-    # FLAGS
-    parser.add_argument("--recursive", "-r", help="Send recursively.", action="store_true")  # default is False
-    parser.add_argument("--zipFirst", "-z", help="Zip before sending.", action="store_true")  # default is False
-    parser.add_argument("--cloud", "-c", help="Transfer through the cloud.", action="store_true")  # default is False
-
-    args = parser.parse_args()
-
-    if ":" in args.source and (args.source[1] != ":" if len(args.source) > 1 else True):  # avoid the case of "C:/":
+import typer
+from typing import Annotated
+
+
+def ftpx(
+    source: Annotated[str, typer.Argument(help="Source path (machine:path)")],
+    target: Annotated[str, typer.Argument(help="Target path (machine:path)")],
+    recursive: Annotated[bool, typer.Option("--recursive", "-r", help="Send recursively.")] = False,
+    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(
+                [
+                    "🚀 FTP File Transfer",
+                    "📋 Starting transfer process...",
+                ]
+            ),
+            title="Transfer Initialisation",
+            border_style="blue",
+            padding=(1, 2),
+        )
+    )
+    
+    # Initialize variables
+    resolved_source: str | None = None
+    resolved_target: str | None = None
+    machine: str = ""
+    
+    if ":" in source and (source[1] != ":" if len(source) > 1 else True):  # avoid the case of "C:/":
         source_is_remote = True
 
         # calculating source:
-        source_parts = args.source.split(":")
+        source_parts = source.split(":")
         machine = source_parts[0]
         if len(source_parts) > 1 and source_parts[1] == ES:  # the source path is to be inferred from target.
-            if args.target == ES:
+            if target == ES:
                 raise ValueError(f"""
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ ❌ Configuration Error
@@ -46,21 +62,22 @@ def main():
 ┃    This creates a cyclical inference dependency
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
             else:
-                target = PathExtended(args.target).expanduser().absolute()
-            source = target.collapseuser().as_posix()
+                target_path_obj = PathExtended(target).expanduser().absolute()
+            resolved_source = target_path_obj.collapseuser().as_posix()
+            resolved_target = target
         else:
-            source = ":".join(args.source.split(":")[1:])
-            if args.target == ES:
-                target = None
+            resolved_source = ":".join(source.split(":")[1:])
+            if target == ES:
+                resolved_target = None
             else:
-                target = PathExtended(args.target).expanduser().absolute().as_posix()
+                resolved_target = PathExtended(target).expanduser().absolute().as_posix()
 
-    elif ":" in args.target and (args.target[1] != ":" if len(args.target) > 1 else True):  # avoid the case of "C:/":
+    elif ":" in target and (target[1] != ":" if len(target) > 1 else True):  # avoid the case of "C:/":
         source_is_remote = False
-        target_parts = args.target.split(":")
+        target_parts = target.split(":")
         machine = target_parts[0]
         if len(target_parts) > 1 and target_parts[1] == ES:
-            if args.source == ES:
+            if source == ES:
                 raise ValueError(f"""
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ ❌ Configuration Error
@@ -68,14 +85,14 @@ def main():
 ┃    This creates a cyclical inference dependency
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
             else:
-                source = args.source
-            target = None
+                resolved_source = source
+            resolved_target = None
         else:
-            target = ":".join(args.target.split(":")[1:])
-            if args.source == ES:
-                source = None
+            resolved_target = ":".join(target.split(":")[1:])
+            if source == ES:
+                resolved_source = None
             else:
-                source = PathExtended(args.source).expanduser().absolute()
+                resolved_source = PathExtended(source).expanduser().absolute().as_posix()
 
     else:
         raise ValueError("""
@@ -85,76 +102,123 @@ def main():
 ┃    Format should be: machine:path
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
 
-    pprint({"source": str(source), "target": str(target), "machine": machine}, "CLI Resolution")
+    pprint({"source": str(resolved_source), "target": str(resolved_target), "machine": machine}, "CLI Resolution")
 
     from paramiko.ssh_exception import AuthenticationException  # type: ignore
 
     try:
-        ssh = SSH(rf"{machine}")
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=True)
     except AuthenticationException:
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ 🔑 Authentication Failed
-│    Trying manual authentication...
-│
-│ ⚠️  Caution: Ensure that username is passed appropriately
-│    This exception only handles password authentication
-└────────────────────────────────────────────────────────────────""")
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "🔑 Authentication failed. Trying manual authentication...",
+                        "⚠️  Ensure that the username is provided correctly; only password prompts are handled here.",
+                    ]
+                ),
+                title="Authentication Required",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
         import getpass
 
         pwd = getpass.getpass()
-        ssh = SSH(rf"{machine}", pwd=pwd)
-
-    if args.cloud:
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ ☁️  Cloud Transfer Mode
-│    Uploading from remote to cloud...
-└────────────────────────────────────────────────────────────────""")
-        ssh.run(f"cloud_copy {source} :^", desc="Uploading from remote to the cloud.").print()
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ ⬇️  Cloud Transfer Mode
-│    Downloading from cloud to local...
-└────────────────────────────────────────────────────────────────""")
-        ssh.run_locally(f"cloud_copy :^ {target}").print()
-        received_file = PathExtended(target)  # type: ignore
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=pwd, port=22, enable_compression=True)
+
+    if cloud:
+        console.print(
+            Panel.fit(
+                "☁️  Cloud transfer mode — uploading from remote to cloud...",
+                title="Cloud Upload",
+                border_style="cyan",
+            )
+        )
+        ssh.run_shell(command=f"cloud_copy {resolved_source} :^", verbose_output=True, description="Uploading from remote to the cloud.", strict_stderr=False, strict_return_code=False)
+        console.print(
+            Panel.fit(
+                "⬇️  Cloud transfer mode — downloading from cloud to local...",
+                title="Cloud Download",
+                border_style="cyan",
+            )
+        )
+        ssh.run_locally(command=f"cloud_copy :^ {resolved_target}")
+        received_file = PathExtended(resolved_target)  # type: ignore
     else:
         if source_is_remote:
-            assert source is not None, """
-❌ Path Error: Source must be a remote path (machine:path)"""
-            print(f"""
-┌────────────────────────────────────────────────────────────────
-│ 📥 Transfer Mode: Remote → Local
-│    Source: {source}
-│    Target: {target}
-│    Options: {"ZIP compression" if args.zipFirst else "No compression"}, {"Recursive" if args.recursive else "Non-recursive"}
-└────────────────────────────────────────────────────────────────""")
-            received_file = ssh.copy_to_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+            if resolved_source is None:
+                typer.echo("""❌ Path Error: Source must be a remote path (machine:path)""")
+                typer.Exit(code=1)
+                return                
+            target_display = resolved_target or "<auto>"
+            console.print(
+                Panel(
+                    "\n".join(
+                        [
+                            "📥 Transfer Mode: Remote → Local",
+                            f"Source: [cyan]{resolved_source}[/cyan]",
+                            f"Target: [cyan]{target_display}[/cyan]",
+                            f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                        ]
+                    ),
+                    title="Transfer Details",
+                    border_style="cyan",
+                    padding=(1, 2),
+                )
+            )
+            received_file = ssh.copy_to_here(source=resolved_source, target=resolved_target, compress_with_zip=zipFirst, recursive=recursive)
         else:
-            assert source is not None, """
+            assert resolved_source is not None, """
 ❌ Path Error: Target must be a remote path (machine:path)"""
-            print(f"""
-┌────────────────────────────────────────────────────────────────
-│ 📤 Transfer Mode: Local → Remote
-│    Source: {source}
-│    Target: {target}
-│    Options: {"ZIP compression" if args.zipFirst else "No compression"}, {"Recursive" if args.recursive else "Non-recursive"}
-└────────────────────────────────────────────────────────────────""")
-            received_file = ssh.copy_from_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+            target_display = resolved_target or "<auto>"
+            console.print(
+                Panel(
+                    "\n".join(
+                        [
+                            "📤 Transfer Mode: Local → Remote",
+                            f"Source: [cyan]{resolved_source}[/cyan]",
+                            f"Target: [cyan]{target_display}[/cyan]",
+                            f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                        ]
+                    ),
+                    title="Transfer Details",
+                    border_style="cyan",
+                    padding=(1, 2),
+                )
+            )
+            received_file = ssh.copy_from_here(source_path=resolved_source, target_rel2home=resolved_target, compress_with_zip=zipFirst, recursive=recursive, overwrite_existing=False)
 
     if source_is_remote and isinstance(received_file, PathExtended):
-        print(f"""
-┌────────────────────────────────────────────────────────────────
-│ 📁 File Received
-│    Parent: {repr(received_file.parent)}
-│    File: {repr(received_file)}
-└────────────────────────────────────────────────────────────────""")
-    print("""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ✅ Transfer Complete
-┃    File transfer process finished successfully
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "📁 File Received",
+                        f"Parent: [cyan]{repr(received_file.parent)}[/cyan]",
+                        f"File: [cyan]{repr(received_file)}[/cyan]",
+                    ]
+                ),
+                title="Transfer Result",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+    console.print(
+        Panel(
+            "File transfer process finished successfully",
+            title="✅ Transfer Complete",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+
+
+def main() -> None:
+    """Entry point function that uses typer to parse arguments and call main."""
+    app = typer.Typer()
+    app.command(no_args_is_help=True, help="File transfer utility though SSH.")(ftpx)
+    app()
 
 
 if __name__ == "__main__":

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