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

machineconfig/scripts/python/helpers/helpers4.py

@@ -0,0 +1,178 @@
+
+from typing import Any, Callable, Optional
+import inspect
+import os
+import argparse
+from crocodile.core import Display
+from crocodile.file_management import P
+from machineconfig.utils.utils import choose_ssh_host
+
+
+def search_for_files_of_interest(path_obj: P):
+    if path_obj.joinpath(".venv").exists():
+        path_objects = path_obj.search("*", not_in=[".venv"]).list
+        files: list[P] = []
+        for a_path_obj in path_objects:
+            files += search_for_files_of_interest(path_obj=a_path_obj)
+        return files
+    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True).list
+    ps_files = path_obj.search(pattern="*.ps1", r=True).list
+    sh_files = path_obj.search(pattern="*.sh", r=True).list
+    files = py_files + ps_files + sh_files
+    return files
+
+
+def convert_kwargs_to_fire_kwargs_str(kwargs: dict[str, Any]) -> str:
+    # https://google.github.io/python-fire/guide/
+    # https://github.com/google/python-fire/blob/master/docs/guide.md#argument-parsing
+    if not kwargs:  # empty dict
+        kwargs_str = ''
+    else:
+        if len(kwargs) == 1:
+            kwargs_str = f""" --{list(kwargs.keys())[0]} {list(kwargs.values())[0]} """
+        else:
+            # print(f"len(kwargs) = {len(kwargs)}")
+            tmp_list: list[str] = []
+            for k, v in kwargs.items():
+                if v is not None:
+                    item = f'"{k}": "{v}"'
+                else:
+                    item = f'"{k}": None'
+                tmp_list.append(item)
+            tmp__ = ", ".join(tmp_list)
+            kwargs_str = "'{" + tmp__  + "}'"
+    return kwargs_str
+
+
+def parse_pyfile(file_path: str):
+    print(f"🔍 Loading {file_path} ...")
+    from typing import NamedTuple
+    args_spec = NamedTuple("args_spec", [("name", str), ("type", str), ("default", Optional[str])])
+    func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
+
+    import ast
+    parsed_ast = ast.parse(P(file_path).read_text(encoding='utf-8'))
+    functions = [
+        node
+        for node in ast.walk(parsed_ast)
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+    ]
+    module__doc__ = ast.get_docstring(parsed_ast)
+    main_option = f"RUN AS MAIN -- {Display.get_repr(module__doc__, limit=150) if module__doc__ is not None else 'NoDocs'}"
+    options = [main_option]
+    for function in functions:
+        if function.name.startswith('__') and function.name.endswith('__'): continue
+        if any(arg.arg == 'self' for arg in function.args.args): continue
+        if any(arg.arg == 'self' for arg in function.args.args): continue
+        doc_string_tmp: str | None = ast.get_docstring(function)
+        if doc_string_tmp is None: doc_string = "NoDocs"
+        else: doc_string = doc_string_tmp.replace('\n', ' ')
+        options.append(f"{function.name} -- {', '.join([arg.arg for arg in function.args.args])} -- {doc_string}")
+        tmp = []
+        for idx, arg in enumerate(function.args.args):
+            if arg.annotation is not None:
+                try: type_ = arg.annotation.__dict__['id']
+                except KeyError as ke:
+                    # type_ = arg.annotation.__name__
+                    # print(f"Failed to get type for {arg.annotation}. {ke}")
+                    # Struct(get_attrs(arg.annotation)).print(as_yaml=True)
+                    type_ = "Any"  # e.g. a callable object
+                    _ = ke
+                    # raise ke
+            else: type_ = "Any"
+            default_tmp = function.args.defaults[idx] if idx < len(function.args.defaults) else None
+            if default_tmp is None: default = None
+            else:
+                if hasattr(default_tmp, "__dict__"): default = default_tmp.__dict__.get("value", None)
+                else: default = None
+            tmp.append(args_spec(name=arg.arg, type=type_, default=default))
+        func_args.append(tmp)
+    return options, func_args
+
+
+def interactively_run_function(func: Callable[[Any], Any]):
+    sig = inspect.signature(func)
+    params = list(sig.parameters.values())
+    args = []
+    kwargs = {}
+    for param in params:
+        if param.annotation is not inspect.Parameter.empty: hint = f" ({param.annotation.__name__})"
+        else: hint = ""
+        if param.default is not inspect.Parameter.empty:
+            default = param.default
+            value = input(f"Please enter a value for argument `{param.name}` (type = {hint}) (default = {default}) : ")
+            if value == "": value = default
+        else: value = input(f"Please enter a value for argument `{param.name}` (type = {hint}) : ")
+        try:
+            if param.annotation is not inspect.Parameter.empty:
+                value = param.annotation
+        except (TypeError, ValueError) as err:
+            raise ValueError(f"Invalid input: {value} is not of type {param.annotation}") from err
+        if param.kind == inspect.Parameter.KEYWORD_ONLY: kwargs[param.name] = value
+        else: args.append((param.name, value))
+    args_to_kwargs = dict(args)
+    return args_to_kwargs, kwargs
+
+
+def get_attrs_recursively(obj: Any):
+    if hasattr(obj, '__dict__'):
+        res = {}
+        for k, v in obj.__dict__.items():
+            res[k] = get_attrs_recursively(v)
+        return res
+    return obj
+
+
+def run_on_remote(func_file: str, args: argparse.Namespace):
+    host = choose_ssh_host(multi=False)
+    assert isinstance(host, str), f"host must be a string. Got {type(host)}"
+    from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig
+    config = RemoteMachineConfig(copy_repo=True, update_repo=False, update_essential_repos=True,
+                                 notify_upon_completion=True, ssh_params=dict(host=host),
+                                 # to_email=None, email_config_name='enaut',
+                                 data=[],
+                                 ipython=False, interactive=args.interactive, pdb=False, pudb=args.debug, wrap_in_try_except=False,
+                                 transfer_method="sftp")
+    m = RemoteMachine(func=func_file, func_kwargs=None, config=config)
+    m.run()
+
+
+def find_repo_root_path(start_path: str) -> Optional[str]:
+    root_files = ['setup.py', 'pyproject.toml', '.git']
+    path: str=start_path
+    trials = 0
+    root_path = os.path.abspath(os.sep)
+    while path != root_path and trials < 20:
+        for root_file in root_files:
+            if os.path.exists(os.path.join(path, root_file)):
+                # print(f"Found repo root path: {path}")
+                return path
+        path = os.path.dirname(path)
+        trials += 1
+    return None
+
+
+def get_import_module_code(module_path: str):
+    root_path = find_repo_root_path(module_path)
+    if root_path is None:  # just make a desperate attempt to import it
+        module_name = module_path.lstrip(os.sep).replace(os.sep, '.')
+        if module_name.endswith(".py"):
+            module_name = module_name[:-3]
+    else:
+        relative_path = module_path.replace(root_path, '')
+        module_name = relative_path.lstrip(os.sep).replace(os.sep, '.')
+        if module_name.endswith(".py"):
+            module_name = module_name[:-3]
+        # module_name = module_name.replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "")
+        if module_name.startswith("src."):
+            module_name = module_name[4:]
+        if module_name.startswith("myresources."):
+            module_name = module_name[12:]
+        if module_name.startswith("resources."):
+            module_name = module_name[10:]
+        if module_name.startswith("source."):
+            module_name = module_name[7:]
+    if any(char in module_name for char in "- :/\\"):
+        module_name = "IncorrectModuleName"
+    # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
+    return f"from {module_name} import *"

machineconfig/scripts/python/helpers/helpers5.py

@@ -0,0 +1,50 @@
+def get_jupyter_notebook(python_code: str):
+    template = """
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7412902a-3074-475b-9820-71b82e670a2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import math"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+"""
+    template.replace('"import math"', python_code)
+    return template
+
+
+def create_jupyter_notebook(py_script: str) -> None:
+    import nbformat as nbf
+    from nbformat.notebooknode import NotebookNode
+    nb: NotebookNode = nbf.v4.new_notebook()
+    nb.cells.append(nbf.v4.new_code_cell(py_script))
+    with open("new_notebook.ipynb", mode="w", encoding="utf-8") as f:
+        nbf.write(nb,f)

machineconfig/scripts/python/helpers/repo_sync_helpers.py

@@ -0,0 +1,126 @@
+
+from crocodile.file_management import P, Read
+from crocodile.meta import Terminal
+from machineconfig.scripts.python.get_zellij_cmd import get_zellij_cmd
+from machineconfig.utils.utils import CONFIG_PATH, DEFAULTS_PATH, get_shell_script, write_shell_script
+import platform
+
+
+def delete_remote_repo_copy_and_push_local(remote_repo: str, local_repo: str, cloud: str):
+    print(f"""
+╔{'═' * 70}╗
+║ 🗑️  Deleting remote repo copy and pushing local copy                       ║
+╚{'═' * 70}╝
+""")
+    repo_sync_root = P(remote_repo).expanduser().absolute()
+    repo_root_path = P(local_repo).expanduser().absolute()
+    repo_sync_root.delete(sure=True)
+    print("🧹 Removed temporary remote copy")
+    from git.remote import Remote
+    from git.repo import Repo
+    try:
+        Remote.remove(Repo(repo_root_path), "originEnc")
+        print("🔗 Removed originEnc remote reference")
+    except Exception: pass  # type: ignore
+    print(f"""
+╭{'─' * 70}╮
+│ 📤 Uploading local repository to cloud...                                │
+╰{'─' * 70}╯
+""")
+
+    repo_root_path.to_cloud(cloud=cloud, zip=True, encrypt=True, rel2home=True, os_specific=False)
+
+    print(f"""
+╔{'═' * 70}╗
+║ ✅ Repository successfully pushed to cloud                                ║
+╚{'═' * 70}╝
+""")
+
+
+# import sys
+# import subprocess
+
+
+def get_wt_cmd(wd1: P, wd2: P) -> str:
+    lines = [
+        f"""wt --window 0 new-tab --profile pwsh --title "gitdiff" --tabColor `#3b04d1 --startingDirectory {wd1} ` --colorScheme "Solarized Dark" """,
+        f"""split-pane --horizontal --profile pwsh --startingDirectory {wd2} --size 0.5 --colorScheme "Tango Dark" -- pwsh -Interactive """
+    ]
+    return " `; ".join(lines)
+
+
+def inspect_repos(repo_local_root: str, repo_remote_root: str):
+    print(f"""
+╔{'═' * 70}╗
+║ 🔍 Inspecting Repositories                                                ║
+╠{'═' * 70}╣
+║ 📂 Local:  {repo_local_root}                      
+║ 📂 Remote: {repo_remote_root}                    
+╚{'═' * 70}╝
+""")
+
+    if platform.system() == "Windows":
+        program = get_wt_cmd(wd1=P(repo_local_root), wd2=P(repo_local_root))
+        write_shell_script(program=program, execute=True, desc="Inspecting repos ...", preserve_cwd=True, display=True)
+        return None
+    elif platform.system() == "Linux":
+        program = get_zellij_cmd(wd1=P(repo_local_root), wd2=P(repo_remote_root))
+        write_shell_script(program=program, execute=True, desc="Inspecting repos ...", preserve_cwd=True, display=True)
+        return None
+    else: raise NotImplementedError(f"Platform {platform.system()} not implemented.")
+
+
+def fetch_dotfiles():
+    print(f"""
+╔{'═' * 70}╗
+║ 📁 Fetching Dotfiles                                                      ║
+╚{'═' * 70}╝
+""")
+
+    cloud_resolved = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+    print(f"""
+╭{'─' * 70}╮
+│ ⚠️  Using default cloud: `{cloud_resolved}` from {DEFAULTS_PATH}     │
+╰{'─' * 70}╯
+""")
+
+    dotfiles_local = P.home().joinpath("dotfiles")
+    CONFIG_PATH.joinpath("remote").create()
+    dotfiles_remote = CONFIG_PATH.joinpath("remote", dotfiles_local.rel2home())
+    remote_path = dotfiles_local.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
+
+    print(f"""
+╭{'─' * 70}╮
+│ 📥 Downloading dotfiles from cloud...                                    │
+╰{'─' * 70}╯
+""")
+
+    dotfiles_remote.from_cloud(remotepath=remote_path, cloud=cloud_resolved,
+        unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=None)
+
+    print(f"""
+╭{'─' * 70}╮
+│ 🗑️  Removing old dotfiles and replacing with cloud version...            │
+╰{'─' * 70}╯
+""")
+
+    dotfiles_local.delete(sure=True)
+    dotfiles_remote.move(folder=P.home())
+    script = f"""
+# rm -rf {dotfiles_local}
+# mv {dotfiles_remote} {dotfiles_local}
+"""
+    if platform.system() == "Linux": script += """
+sudo chmod 600 $HOME/.ssh/*
+sudo chmod 700 $HOME/.ssh
+sudo chmod +x $HOME/dotfiles/scripts/linux -R
+"""
+    shell_path = get_shell_script(shell_script=script)
+    Terminal().run(f". {shell_path}", shell="bash").capture().print()
+
+    print(f"""
+╔{'═' * 70}╗
+║ ✅ Dotfiles successfully fetched and installed                            ║
+╚{'═' * 70}╝
+""")
+

machineconfig/scripts/python/mount_nfs.py

@@ -1,54 +1,85 @@
-
 """NFS mounting script
 """
 
-
 from crocodile.file_management import P
 from crocodile.meta import SSH, Terminal
 from crocodile.core import List as L
 from machineconfig.utils.utils import display_options, PROGRAM_PATH, choose_ssh_host
 import platform
 
-
 def main():
-    print("Mounting NFS Share ... ")
-    share_info = input("share path? (e.g. machine:~/data/share_nfs) [press enter for interactive choice] = ")
+    print("\n" + "=" * 50)
+    print("🚀 Starting NFS Mounting Process")
+    print("=" * 50 + "\n")
+
+    share_info = input("🔗 Enter share path (e.g., machine:~/data/share_nfs) [Press Enter for interactive choice]: ")
     if share_info == "":
+        print("\n🔍 Interactive mode selected for choosing share path.")
         tmp = choose_ssh_host(multi=False)
         assert isinstance(tmp, str)
         ssh = SSH(tmp)
         default = f"{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_nfs"
-        share_info = display_options("Choose a share path: ", options=L(ssh.run("cat /etc/exports").op.split("\n")).filter(lambda x: not x.startswith("#")).apply(lambda x: f"{ssh.hostname}:{x.split(' ')[0]}").list + [default], default=default)
-        assert isinstance(share_info, str), f"share_info must be a string. Got {type(share_info)}"
+        share_info = display_options(
+            "📂 Choose a share path:",
+            options=L(ssh.run("cat /etc/exports").op.split("\n"))
+                .filter(lambda x: not x.startswith("#"))
+                .apply(lambda x: f"{ssh.hostname}:{x.split(' ')[0]}").list + [default],
+            default=default
+        )
+        assert isinstance(share_info, str), f"❌ share_info must be a string. Got {type(share_info)}"
+
     remote_server = share_info.split(":")[0]
     share_path = share_info.split(":")[1]
 
+    print(f"\n🌐 Remote Server: {remote_server}")
+    print(f"📁 Share Path: {share_path}\n")
+
     if platform.system() == "Linux":
         mount_path_1 = P(share_path)
-        print(remote_server)
         mount_path_2 = P.home().joinpath(f"data/mount_nfs/{remote_server}")
-        if str(mount_path_1).startswith("/home"): mount_path_3 = P.home().joinpath(*mount_path_1.parts[3:])
-        else: mount_path_3 = mount_path_2
-        local_mount_point = display_options(msg="choose mount path OR input custom one", options=[mount_path_1, mount_path_2, mount_path_3], default=mount_path_2, custom_input=True)
-        assert isinstance(local_mount_point, P), f"local_mount_point must be a pathlib.Path. Got {type(local_mount_point)}"
+        if str(mount_path_1).startswith("/home"):
+            mount_path_3 = P.home().joinpath(*mount_path_1.parts[3:])
+        else:
+            mount_path_3 = mount_path_2
+
+        print("🔧 Preparing mount paths...")
+        local_mount_point = display_options(
+            msg="📂 Choose mount path OR input custom one:",
+            options=[mount_path_1, mount_path_2, mount_path_3],
+            default=mount_path_2,
+            custom_input=True
+        )
+        assert isinstance(local_mount_point, P), f"❌ local_mount_point must be a pathlib.Path. Got {type(local_mount_point)}"
         local_mount_point = P(local_mount_point).expanduser()
+
         PROGRAM_PATH.write_text(f"""
 share_info={share_info}
 remote_server={remote_server}
 share_path={share_path}
 local_mount_point={local_mount_point}
-    """)
+        """)
+
+        print("✅ Mount paths prepared successfully!\n")
+
     elif platform.system() == "Windows":
+        print("\n🔍 Checking existing drives...")
         print(Terminal().run("Get-PSDrive -PSProvider 'FileSystem'", shell="powershell").op)
-        driver_letter = input(r"Choose driver letter (e.g. Z:\) (avoid the ones already used) : ") or "Z:\\"
+        driver_letter = input(r"🖥️ Choose driver letter (e.g., Z:\\) [Avoid already used ones]: ") or "Z:\\"
+
         PROGRAM_PATH.write_text(f"""
 $server = "{remote_server}"
 $sharePath = "{share_path}"
 $driveLetter = "{driver_letter}"
 """)
-    # P.home().joinpath(f"data/mount_nfs/{remote_server}").symlink_to(target="")  # can't be created until the mount is finished
+
+        print("✅ Drive letter selected and configuration saved!\n")
+
+    print("\n📄 Configuration File Content:")
+    print("-" * 50)
     print(PROGRAM_PATH.read_text())
+    print("-" * 50 + "\n")
 
+    print("🎉 NFS Mounting Process Completed Successfully!\n")
 
 if __name__ == '__main__':
     main()

machineconfig/scripts/python/mount_nw_drive.py

@@ -1,21 +1,29 @@
-
-
 from machineconfig.utils.utils import PROGRAM_PATH
 from crocodile.file_management import P
 import platform
 
-
 def main():
-    print("Welcome to the WindowsNetworkDrive Mounting Wizard")
-    drive_location = input("Enter the network drive location (ex: //192.168.1.100/Share): ")
+    print("\n" + "=" * 50)
+    print("🚀 Welcome to the Windows Network Drive Mounting Wizard")
+    print("=" * 50 + "\n")
+
+    drive_location = input("🔗 Enter the network drive location (e.g., //192.168.1.100/Share): ")
     machine_name = drive_location.split("//")[1].split("/")[0]
-    mount_point = input(f"Enter the mount point directory (ex: /mnt/network) [default: ~/data/mount_nw/{machine_name}]: ")
-    if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_nw/{machine_name}")
-    else: mount_point = P(mount_point).expanduser()
 
-    username = input("Enter the username: ")
-    password = input("Enter the password: ")
+    mount_point = input(f"📂 Enter the mount point directory (e.g., /mnt/network) [Default: ~/data/mount_nw/{machine_name}]: ")
+    if mount_point == "":
+        mount_point = P.home().joinpath(fr"data/mount_nw/{machine_name}")
+    else:
+        mount_point = P(mount_point).expanduser()
+
+    print(f"\n🌐 Network Drive Location: {drive_location}")
+    print(f"📁 Mount Point: {mount_point}\n")
+
+    username = input("👤 Enter the username: ")
+    password = input("🔒 Enter the password: ")
+
     if platform.system() == "Linux":
+        print("\n🔧 Saving configuration for Linux...")
         PROGRAM_PATH.write_text(f"""
 drive_location='{drive_location}'
 mount_point='{mount_point}'
@@ -23,9 +31,13 @@ username='{username}'
 password='{password}'
 
 """)
+        print("✅ Configuration saved successfully!\n")
+
     elif platform.system() == "Windows":
+        print("❌ Windows platform is not yet supported.")
         raise NotImplementedError
 
+    print("🎉 Windows Network Drive Mounting Process Completed!\n")
 
 if __name__ == '__main__':
     main()

machineconfig/scripts/python/mount_ssh.py

@@ -1,43 +1,59 @@
-
 """Mount a remote SSHFS share on a local directory
 """
 
-
 from platform import system
 from crocodile.meta import SSH, Terminal
 from crocodile.file_management import P
-
 from machineconfig.utils.utils import PROGRAM_PATH, choose_ssh_host
 
-
 def main():
-    print("Mounting SSHFS ... ")
-    share_info = input("share path? (e.g. user@host:/path) [press enter for interactive choice] = ")
+    print("\n" + "=" * 50)
+    print("🚀 Starting SSHFS Mounting Process")
+    print("=" * 50 + "\n")
+
+    share_info = input("🔗 Enter share path (e.g., user@host:/path) [Press Enter for interactive choice]: ")
     if share_info == "":
+        print("\n🔍 Interactive mode selected for choosing share path.")
         tmp = choose_ssh_host(multi=False)
         assert isinstance(tmp, str)
         ssh = SSH(host=tmp)
         share_info = f"{ssh.username}@{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_ssh"
     else:
         ssh = SSH(share_info.split(":")[0])
-    print(Terminal().run("net use", shell="powershell").op)
-    driver_letter = input(r"Choose driver letter (e.g. Z:\) (avoid the ones already used) : ") or "Z:\\"
 
-    mount_point = input(f"Enter the mount point directory (ex: /mnt/network) [default: ~/data/mount_ssh/{ssh.hostname}]: ")
-    if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
+    print(f"\n🌐 Share Info: {share_info}")
+
+    if system() == "Windows":
+        print("\n🔍 Checking existing drives...")
+        print(Terminal().run("net use", shell="powershell").op)
+        driver_letter = input(r"🖥️ Choose driver letter (e.g., Z:\\) [Avoid already used ones]: ") or "Z:\\"
+    else:
+        driver_letter = None
+
+    mount_point = input(f"📂 Enter the mount point directory (e.g., /mnt/network) [Default: ~/data/mount_ssh/{ssh.hostname}]: ")
+    if mount_point == "":
+        mount_point = P.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
+
+    print(f"\n📁 Mount Point: {mount_point}")
 
     if system() == "Linux":
         txt = """
 sshfs alex@:/media/dbhdd /media/dbhdd\
 """
+        print("\n🔧 Preparing SSHFS mount command for Linux...")
     elif system() == "Windows":
         txt = fr"""
 net use {driver_letter} {share_info}
 fusermount -u /mnt/dbhdd
 """
-    else: raise ValueError(f"Not implemented for this system {system()}")
+        print("\n🔧 Preparing SSHFS mount command for Windows...")
+    else:
+        raise ValueError(f"❌ Not implemented for this system: {system()}")
+
     PROGRAM_PATH.write_text(txt)
+    print("✅ Configuration saved successfully!\n")
 
+    print("🎉 SSHFS Mounting Process Completed!\n")
 
 if __name__ == '__main__':
-    pass
+    main()

machineconfig/scripts/python/onetimeshare.py

@@ -1,4 +1,3 @@
-
 """Share
 """
 
@@ -6,18 +5,15 @@
 # this script is pure python and connects to server to create a secret
 # or use ots executable to do this job
 
-
 import requests
 import crocodile.file_management as fm
 from crocodile.core import install_n_import
 import base64
 from typing import Optional
 
-
 def encrypt(key: str, pwd: str):
+    print("\n🔒 Encrypting the secret...")
     install_n_import(library="Crypto.Cipher", package="pycryptodome")
-    # from Crypto.Cipher import AES
-    # from Crypto.Hash import MD5
     AES = __import__("Crypto", fromlist=["Cipher"]).Cipher.AES
     MD5 = __import__("Crypto", fromlist=["Hash"]).Hash.MD5
     pwd_enc = pwd.encode("utf-8")
@@ -28,33 +24,45 @@ def encrypt(key: str, pwd: str):
     pad = 16 - (len(pwd_enc) % 16)
     pwd_enc += bytes([pad] * pad)
     encrypted_password = cipher.encrypt(pwd_enc)
+    print("✅ Encryption completed successfully!\n")
     return base64.b64encode(encrypted_password).decode("utf-8")
 
-
 def share(secret: str, password: Optional[str]):
-    if password is not None: encoded_secret = encrypt(password, secret)
-    else: encoded_secret = secret
+    print("\n🚀 Initiating the sharing process...")
+    if password is not None:
+        print("🔑 Password provided. Encrypting the secret...")
+        encoded_secret = encrypt(password, secret)
+    else:
+        print("🔓 No password provided. Sharing the secret as is.")
+        encoded_secret = secret
 
     url = "https://ots.fyi/api/create"
 
     payload = {"secret": encoded_secret}
     headers = {'Content-Type': 'application/json'}
 
+    print("\n🌐 Sending request to the server...")
     response = requests.post(url, json=payload, headers=headers, timeout=10)
 
     if response.status_code == 201:
         res = response.json()
-        print(res)
-        assert res["success"] is True, "Request have failed"
+        print("✅ Request successful! Response received.")
+        assert res["success"] is True, "❌ Request failed."
         share_url = fm.P(f"https://ots.fyi/#{res['secret_id']}") + (f"|{password}" if password is not None else "")
-        print(repr(share_url))
+        print(f"\n🔗 Share URL: {repr(share_url)}\n")
         return share_url
     else:
-        print("Request failed")
+        print("❌ Request failed. Server returned an error.")
         raise RuntimeError(response.text)
 
-
 if __name__ == "__main__":
-    sc = input("Secret: ")
-    pwdd = input("Password: ") or None
+    print("\n" + "=" * 50)
+    print("🔐 Welcome to the One-Time Secret Sharing Tool")
+    print("=" * 50 + "\n")
+
+    sc = input("📝 Enter the secret to share: ")
+    pwdd = input("🔑 Enter a password (optional): ") or None
+
+    print("\n📤 Sharing the secret...")
     share(secret=sc, password=pwdd)
+    print("🎉 Secret shared successfully!\n")