machineconfig 1.92__py3-none-any.whl → 1.94__py3-none-any.whl

machineconfig/scripts/python/ftpx.py

@@ -1,4 +1,3 @@
-
 """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.
@@ -7,14 +6,21 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 """
 
 import argparse
-from crocodile.meta import SSH, P, Struct
-from machineconfig.scripts.python.cloud_sync import ES
+from crocodile.meta import SSH
+from crocodile.core import Struct
+from crocodile.file_management import P
+from machineconfig.scripts.python.helpers.helpers2 import ES
 
 
 def main():
+    print("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 🚀 FTP File Transfer
+┃ 📋 Starting transfer process...
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     parser = argparse.ArgumentParser(description='FTP client')
 
-    parser.add_argument("source", help=f"source path (machine:path)")
+    parser.add_argument("source", help="source path (machine:path)")
     parser.add_argument("target", help="target path (machine:path)")
 
     # FLAGS
@@ -31,7 +37,12 @@ def main():
         source_parts = args.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: raise ValueError(f"You can't use expand symbol `{ES}` in both source and target. Cyclical inference dependency arised.")
+            if args.target == ES: raise ValueError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Configuration Error
+┃    Cannot use expand symbol `{ES}` in both source and target
+┃    This creates a cyclical inference dependency
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
             else: target = P(args.target).expanduser().absolute()
             source = target.collapseuser().as_posix()
         else:
@@ -44,7 +55,12 @@ def main():
         target_parts = args.target.split(":")
         machine = target_parts[0]
         if len(target_parts) > 1 and target_parts[1] == ES:
-            if args.source == ES: raise ValueError(f"You can't use expand symbol `{ES}` in both source and target. Cyclical inference dependency arised.")
+            if args.source == ES: raise ValueError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Configuration Error
+┃    Cannot use expand symbol `{ES}` in both source and target
+┃    This creates a cyclical inference dependency
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
             else: source = args.source
             target = None
         else:
@@ -53,7 +69,12 @@ def main():
             else: source = P(args.source).expanduser().absolute()
 
     else:
-        raise ValueError("Either source or target must be a remote path (i.e. machine:path)")
+        raise ValueError("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Path Error
+┃    Either source or target must be a remote path
+┃    Format should be: machine:path
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
 
     Struct({"source": str(source), "target": str(target), "machine": machine}).print(as_config=True, title="CLI Resolution")
 
@@ -61,31 +82,68 @@ def main():
     try:
         ssh = SSH(rf'{machine}')
     except AuthenticationException:
-        print("Authentication failed, trying manually:")
-        print(f"Caution: Ensure that username is passed appropriately as this exception only handles password.")
+        print("""
+┌────────────────────────────────────────────────────────────────
+│ 🔑 Authentication Failed
+│    Trying manual authentication...
+│ 
+│ ⚠️  Caution: Ensure that username is passed appropriately
+│    This exception only handles password authentication
+└────────────────────────────────────────────────────────────────""")
         import getpass
         pwd = getpass.getpass()
         ssh = SSH(rf'{machine}', pwd=pwd)
 
     if args.cloud:
-        print("Uploading from remote to 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("Downloading from cloud to local ...")
+        print("""
+┌────────────────────────────────────────────────────────────────
+│ ⬇️  Cloud Transfer Mode
+│    Downloading from cloud to local...
+└────────────────────────────────────────────────────────────────""")
         ssh.run_locally(f"cloud_copy :^ {target}").print()
         received_file = P(target)  # type: ignore
     else:
         if source_is_remote:
-            assert source is not None, "source must be a remote path (i.e. machine:path)"
-            print(f"Running: received_file = ssh.copy_to_here(source=r'{source}', target=r'{target}', z={args.zipFirst}, r={args.recursive})")
+            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)
         else:
-            assert source is not None, "target must be a remote path (i.e. machine:path)"
-            print(f"Running: received_file = ssh.copy_from_here(source=r'{source}', target=r'{target}', z={args.zipFirst}, r={args.recursive})")
+            assert 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)
-    # ssh.print_summary()
-    # if P(args.file).is_dir(): print(f"Use: cd {repr(P(args.file).expanduser())}")
+
     if source_is_remote and isinstance(received_file, P):
-        print(f"Received: {repr(received_file.parent), repr(received_file)}")
+        print(f"""
+┌────────────────────────────────────────────────────────────────
+│ 📁 File Received
+│    Parent: {repr(received_file.parent)}
+│    File: {repr(received_file)}
+└────────────────────────────────────────────────────────────────""")
+    print("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ✅ Transfer Complete
+┃    File transfer process finished successfully
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
 
 
 if __name__ == '__main__':

machineconfig/scripts/python/get_zellij_cmd.py

@@ -0,0 +1,14 @@
+from crocodile.file_management import P
+
+
+def get_zellij_cmd(wd1: P, wd2: P) -> str:
+    _ = wd1, wd2
+    lines = [""" zellij action new-tab --name gitdiff""",
+             """zellij action new-pane --direction down --name local --cwd ./data """,
+             """zellij action write-chars "cd '{wd1}'; git status" """,
+             """zellij action move-focus up; zellij action close-pane """,
+             """zellij action new-pane --direction down --name remote --cwd code """,
+             """zellij action write-chars "cd '{wd2}' """,
+             """git status" """
+    ]
+    return "; ".join(lines)

machineconfig/scripts/python/gh_models.py

@@ -1,7 +1,8 @@
-
 # as per https://github.com/marketplace/models/azure-openai/o1-preview
 from openai import OpenAI
 from crocodile.file_management import Read, P
+from rich import print as rprint
+from rich.panel import Panel
 
 
 gh_token = Read.ini(P.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
@@ -13,8 +14,12 @@ client__ = OpenAI(
 )
 
 
-def get_response(client, model_name: str, messages: list[str]):
-    print(f"Getting response from model {model_name}")
+def get_response(client, model_name: str, messages: list[dict[str, str]]):
+    print(f"""
+┌────────────────────────────────────────────────────────────────
+│ 🤖 Querying Model: {model_name}
+│    Sending request to API...
+└────────────────────────────────────────────────────────────────""")
     try:
         response = client.chat.completions.create(
             messages=messages,
@@ -22,7 +27,11 @@ def get_response(client, model_name: str, messages: list[str]):
         )
         return response.choices
     except Exception as e:
-        print(f"Error with model {model_name}: {e}")
+        print(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ API Error with model {model_name}
+┃    {str(e)}
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
         return None
 
 
@@ -30,26 +39,64 @@ def interactive_chat():
     conversation_history = []
     model_index = 0
     model_name = model_name_preferences[model_index]
+    
+    print("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 🚀 Interactive Chat Started
+┃    Type your message and press Enter to chat
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+    
     while True:
-        print(f"Using model {model_name}".center(80, "="))
+        header = f" 🤖 Using Model: {model_name} "
+        print(f"\n{header.center(80, '═')}\n")
+        
         while True:
-            user_input = input("You: ")
-            conversation_history.append({"role": "user", "content": user_input})
-
-            while True:
-                choices = get_response(client__, model_name, conversation_history)
-                if choices is None:
-                    model_index += 1
-                    model_name = model_name_preferences[model_index % len(model_name_preferences)]
-                    print(f"Switching to model {model_name}".center(80, "="))
-                    continue
-                else:
-                    break
-
-            for a_choice in choices:
-                response_content = a_choice.message.content
-                print("\n" * 5)
-                print(f"AI: {response_content}")
-                conversation_history.append({"role": "assistant", "content": response_content})
-
-interactive_chat()
+            try:
+                user_input = input("💬 You: ")
+                conversation_history.append({"role": "user", "content": user_input})
+
+                while True:
+                    choices = get_response(client__, model_name, conversation_history)
+                    if choices is None:
+                        model_index += 1
+                        model_name = model_name_preferences[model_index % len(model_name_preferences)]
+                        print(f"""
+┌────────────────────────────────────────────────────────────────
+│ 🔄 Model Switch
+│    Now using: {model_name}
+└────────────────────────────────────────────────────────────────""")
+                        continue
+                    else:
+                        break
+
+                for a_choice in choices:
+                    response_content = a_choice.message.content
+                    print("\n" * 2)
+                    try:
+                        rprint(Panel(
+                            f"{response_content}", 
+                            title=f"🤖 AI ({model_name})",
+                            border_style="blue"
+                        ))
+                    except:
+                        # Fallback if rich formatting fails
+                        print(f"""
+┌────────────────────────────────────────────────────────────────
+│ 🤖 AI ({model_name}):
+│ 
+{response_content}
+└────────────────────────────────────────────────────────────────""")
+                    
+                    conversation_history.append({"role": "assistant", "content": response_content})
+                    print("\n")
+            except KeyboardInterrupt:
+                print("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 👋 Chat Session Ended
+┃    Thank you for using the interactive chat!
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+                return
+
+
+if __name__ == "__main__":
+    interactive_chat()

machineconfig/scripts/python/helpers/cloud_helpers.py

@@ -0,0 +1,134 @@
+
+from crocodile.core import Struct
+from crocodile.file_management import P, Read
+from pydantic import ConfigDict
+from pydantic.dataclasses import dataclass
+from typing import Optional
+import os
+from machineconfig.utils.utils import DEFAULTS_PATH
+
+
+class ArgsDefaults:
+    # source: str=None
+    # target: str=None
+    encrypt: bool=False
+    zip_: bool=False
+    overwrite: bool=False
+    share: bool=False
+    rel2home = False
+    root = None
+    os_specific = False
+    key = None
+    pwd = None
+
+
+@dataclass(config=ConfigDict(extra="forbid", frozen=False))
+class Args():
+    cloud: Optional[str] = None
+
+    zip: bool=ArgsDefaults.zip_
+    overwrite: bool=ArgsDefaults.overwrite
+    share: bool=ArgsDefaults.share
+
+    root: Optional[str] = ArgsDefaults.root
+    os_specific: bool = ArgsDefaults.os_specific
+    rel2home: bool = ArgsDefaults.rel2home
+
+    encrypt: bool = ArgsDefaults.encrypt
+    key: Optional[str] = ArgsDefaults.key
+    pwd: Optional[str] = ArgsDefaults.pwd
+
+    config: Optional[str] = None
+
+    @staticmethod
+    def from_config(config_path: P):
+        # from crocodile.core import install_n_import
+        # install_n_import("pydantic")
+        # from pydantic import BaseModel, ConfigDict
+        return Args(**Read.json(config_path))
+
+
+def find_cloud_config(path: P):
+    print(f"""
+╭{'─' * 70}╮
+│ 🔍 Searching for cloud configuration file...                              │
+╰{'─' * 70}╯
+""")
+
+    for _i in range(len(path.parts)):
+        if path.joinpath("cloud.json").exists():
+            res = Args.from_config(path.joinpath("cloud.json"))
+            print(f"""
+╭{'─' * 70}╮
+│ ✅ Found cloud config at: {path.joinpath('cloud.json')}   │
+╰{'─' * 70}╯
+""")
+            Struct(res.__dict__).print(as_config=True, title="Cloud Config")
+            return res
+        path = path.parent
+
+    print("❌ No cloud configuration file found")
+    return None
+
+
+def absolute(path: str) -> P:
+    obj = P(path).expanduser()
+    if not path.startswith(".") and  obj.exists(): return obj
+    try_absing =  P.cwd().joinpath(path)
+    if try_absing.exists(): return try_absing
+    print(f"""
+╭{'─' * 70}╮
+│ ⚠️  WARNING:                                                              │
+│ Path {path} could not be resolved to absolute path.         
+│ Trying to resolve symlinks (this may result in unintended paths).        │
+╰{'─' * 70}╯
+""")
+    return obj.absolute()
+
+
+
+def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Args:
+    print(f"""
+╔{'═' * 70}╗
+║ 🔐 Secure Share Cloud Configuration                                       ║
+╚{'═' * 70}╝
+""")
+    
+    if cloud is None:
+        if os.environ.get("CLOUD_CONFIG_NAME") is not None:
+            default_cloud = os.environ.get("CLOUD_CONFIG_NAME")
+            assert default_cloud is not None
+            cloud = default_cloud
+            print(f"☁️  Using cloud from environment: {cloud}")
+        else:
+            try:
+                default_cloud__ = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+            except Exception:
+                default_cloud__ = 'No default cloud found.'
+            if default_cloud__ == 'No default cloud found.' or interactive:
+                # assert default_cloud is not None
+                cloud = input(f"☁️  Enter cloud name (default {default_cloud__}): ") or default_cloud__
+            else:
+                cloud = default_cloud__
+                print(f"☁️  Using default cloud: {cloud}")
+
+    default_password_path = P.home().joinpath("dotfiles/creds/passwords/quick_password")
+    if default_password_path.exists():
+        pwd = default_password_path.read_text().strip()
+        default_message = "defaults to quick_password"
+    else:
+        pwd = ""
+        default_message = "no default password found"
+    pwd = input(f"🔑 Enter encryption password ({default_message}): ") or pwd
+    res = Args(cloud=cloud,
+               pwd=pwd, encrypt=True,
+               zip=True, overwrite=True, share=True,
+               rel2home=True, root="myshare", os_specific=False,)
+    
+    print(f"""
+╭{'─' * 70}╮
+│ ⚙️  Using SecureShare cloud config                                        │
+╰{'─' * 70}╯
+""")
+    Struct(res.__dict__).print(as_config=True, title="SecureShare Config")
+    return res

machineconfig/scripts/python/helpers/helpers2.py

@@ -0,0 +1,149 @@
+
+
+from crocodile.core import Struct
+from crocodile.file_management import Read
+from machineconfig.scripts.python.helpers.cloud_helpers import Args, ArgsDefaults, absolute, find_cloud_config, get_secure_share_cloud_config
+from machineconfig.utils.utils import DEFAULTS_PATH
+from typing import Optional
+
+
+ES = "^"  # chosen carefully to not mean anything on any shell. `$` was a bad choice.
+
+
+def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str, str, str]:
+    config = args.config
+    if config == "ss":
+        cloud_maybe: Optional[str] = target.split(":")[0]
+        if cloud_maybe == "": cloud_maybe = source.split(":")[0]
+        if cloud_maybe == "": cloud_maybe = None
+        maybe_config = get_secure_share_cloud_config(interactive=True, cloud=cloud_maybe)
+    elif config is not None:
+        print(f"""
+╭{'─' * 70}╮
+│ 📄 Loading configuration from: {config}                   │
+╰{'─' * 70}╯
+""")
+        maybe_config = Args.from_config(absolute(config))
+    else:
+        maybe_config = None
+
+    if maybe_config is not None:
+        if args.zip == ArgsDefaults.zip_: args.zip = maybe_config.zip
+        if args.encrypt == ArgsDefaults.encrypt: args.encrypt = maybe_config.encrypt
+        if args.share == ArgsDefaults.share: args.share = maybe_config.share
+        if args.root == ArgsDefaults.root: args.root = maybe_config.root
+        if args.rel2home == ArgsDefaults.rel2home: args.rel2home = maybe_config.rel2home
+        if args.pwd == ArgsDefaults.pwd: args.pwd = maybe_config.pwd
+        if args.os_specific == ArgsDefaults.os_specific: args.os_specific = maybe_config.os_specific
+
+    root = args.root
+    rel2home = args.rel2home
+    pwd = args.pwd
+    encrypt = args.encrypt
+    zip_arg = args.zip
+    share = args.share
+    os_specific = args.os_specific
+
+    if source.startswith(":"):  # default cloud name is omitted cloud_name:  # or ES in source
+        # At the moment, this cloud.json defaults overrides the args and is activated only when source or target are just ":"
+        # consider activating it by a flag, and also not not overriding explicitly passed args options.
+        assert ES not in target, "Not Implemented here yet."
+        path = absolute(target)
+        if maybe_config is None:  
+            tmp_maybe_config: Optional[Args] = find_cloud_config(path=path)
+            maybe_config = tmp_maybe_config
+
+        if maybe_config is None:
+            default_cloud: str=Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+            print(f"""
+╭{'─' * 70}╮
+│ ⚠️  No cloud config found. Using default cloud: {default_cloud}            │
+╰{'─' * 70}╯
+""")
+            source = default_cloud + ":" + source[1:]
+        else:
+            tmp = maybe_config
+            source = f"{tmp.cloud}:" + source[1:]
+            root = tmp.root
+            rel2home = tmp.rel2home
+            pwd = tmp.pwd
+            encrypt = tmp.encrypt
+            zip_arg = tmp.zip
+            share = tmp.share
+
+    if target.startswith(":"):  # default cloud name is omitted cloud_name:  # or ES in target
+        assert ES not in source, "Not Implemented here yet."
+        path = absolute(source)
+        if maybe_config is None: maybe_config = find_cloud_config(path)
+
+        if maybe_config is None:
+            default_cloud = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+            print(f"""
+╭{'─' * 70}╮
+│ ⚠️  No cloud config found. Using default cloud: {default_cloud}            │
+╰{'─' * 70}╯
+""")
+            target = default_cloud + ":" + target[1:]
+        else:
+            tmp = maybe_config
+            target = f"{tmp.cloud}:" + target[1:]
+            root = tmp.root
+            rel2home = tmp.rel2home
+            pwd = tmp.pwd
+            encrypt = tmp.encrypt
+            zip_arg = tmp.zip
+            share = tmp.share
+
+
+    if ":" in source and (source[1] != ":" if len(source) > 1 else True):  # avoid the deceptive case of "C:/"
+        source_parts: list[str] = source.split(":")
+        cloud = source_parts[0]
+
+        if len(source_parts) > 1 and source_parts[1] == ES:  # the source path is to be inferred from target.
+            assert ES not in target, f"You can't use expand symbol `{ES}` in both source and target. Cyclical inference dependency arised."
+            target_obj = absolute(target)
+            remote_path = target_obj.get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
+            source = f"{cloud}:{remote_path.as_posix()}"
+        else:  # source path is mentioned, target? maybe.
+            if target == ES:  # target path is to be inferred from source.
+                raise NotImplementedError("There is no .get_local_path method yet")
+            else:
+                target_obj = absolute(target)
+        if zip_arg and ".zip" not in source:
+            source += ".zip"
+        if encrypt and ".enc" not in source:
+            source += ".enc"
+
+    elif ":" in target and (target[1] != ":" if len(target) > 1 else True):  # avoid the case of "C:/"
+        target_parts: list[str] = target.split(":")
+        cloud = target.split(":")[0]
+        if len(target_parts) > 1 and target_parts[1] == ES:  # the target path is to be inferred from source.
+            assert ES not in source, "You can't use $ in both source and target. Cyclical inference dependency arised."
+            source_obj = absolute(source)
+            remote_path = source_obj.get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
+            target = f"{cloud}:{remote_path.as_posix()}"
+        else:  # target path is mentioned, source? maybe.
+            target = str(target)
+            if source == ES:
+                raise NotImplementedError("There is no .get_local_path method yet")
+            else:
+                source_obj = absolute(source)
+        if zip_arg and ".zip" not in target: target += ".zip"
+        if encrypt and ".enc" not in target: target += ".enc"
+    else:
+        raise ValueError(f"""
+╔{'═' * 70}╗
+║ ❌ ERROR: Invalid path configuration                                      ║
+╠{'═' * 70}╣
+║ Either source or target must be a remote path (i.e. machine:path)        ║
+╚{'═' * 70}╝
+""")
+
+    print(f"""
+╭{'─' * 70}╮
+│ 🔍 Path resolution complete                                               │
+╰{'─' * 70}╯
+""")
+    Struct({"cloud": cloud, "source": str(source), "target": str(target)}).print(as_config=True, title="CLI Resolution")
+    _ = pwd, encrypt, zip_arg, share
+    return cloud, str(source), str(target)