machineconfig 5.15__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/utils/meta.py

@@ -0,0 +1,255 @@
+"""Metaprogramming utilities for analyzing and serializing Python functions."""
+
+from collections.abc import Callable
+from typing import Any
+
+
+def get_import_module_string(py_file: str) -> str:
+    from machineconfig.scripts.python.helpers_fire_command.file_wrangler import get_import_module_code
+    from machineconfig.utils.accessories import get_repo_root
+    from pathlib import Path
+    repo_root = get_repo_root(Path(py_file))
+    import_line = get_import_module_code(py_file)
+    if repo_root is not None:
+        repo_root_add = f"""sys.path.append(r'{repo_root}')"""
+    else:
+        repo_root_add = ""
+    txt: str = f"""
+try:
+    {import_line}
+except (ImportError, ModuleNotFoundError) as ex:
+    print(fr"❌ Failed to import `{py_file}` as a module: {{ex}} ")
+    print(fr"⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
+    import sys
+    sys.path.append(r'{Path(py_file).parent}')
+    {repo_root_add}
+    from {Path(py_file).stem} import *
+    print(fr"✅ Successfully imported `{py_file}`")
+"""
+    return txt
+
+
+def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_module: bool) -> str:
+    """
+    caveats: always use keyword arguments in the lambda call for best results.
+    return statement not allowed in the wrapped function (otherwise it can be put in the global space)
+    type hint in kwargs has nothing that is not built in, e.g. Optional will not work as it requires an import.
+
+    Given a no-arg lambda like `lambda: func(a=var1, b=var2)`,
+    return a string containing the full function definition of `func`
+    but with the defaults for the parameters provided in the call replaced
+    by the *actual* values (repr) taken from the lambda's globals.
+
+    All imports are local to this function.
+    
+    Args:
+        lmb: A lambda function with no arguments
+        in_global: If True, return kwargs as global variable assignments followed by dedented body.
+                   If False, return the full function definition with updated defaults.
+        import_module: When True, prepend module import bootstrap code for the function's source file.
+    """
+    # local imports
+    import inspect as _inspect
+    import ast as _ast
+    import textwrap as _textwrap
+    import types as _types
+    from pathlib import Path as _Path
+
+    def _stringify_annotation(annotation: Any) -> Any:
+        if annotation is _inspect.Signature.empty or annotation is _inspect.Parameter.empty:
+            return annotation
+        if isinstance(annotation, str):
+            return annotation
+        try:
+            return _inspect.formatannotation(annotation)
+        except Exception:
+            return str(annotation)
+
+    # sanity checks
+    if not (callable(lmb) and isinstance(lmb, _types.LambdaType)):
+        raise TypeError("Expected a lambda function object")
+
+    src = _inspect.getsource(lmb)
+    src = _textwrap.dedent(src)
+    tree = _ast.parse(src)
+
+    # find first Lambda node
+    lambda_node = None
+    for n in _ast.walk(tree):
+        if isinstance(n, _ast.Lambda):
+            lambda_node = n
+            break
+    if lambda_node is None:
+        raise ValueError("Could not find a lambda expression in source")
+
+    body = lambda_node.body
+    if not isinstance(body, _ast.Call):
+        raise ValueError("Lambda body is not a call expression")
+
+    globals_dict = getattr(lmb, "__globals__", {})
+    
+    # Also capture closure variables from the lambda
+    closure_dict: dict[str, Any] = {}
+    if lmb.__closure__:
+        code_obj = lmb.__code__
+        freevars = code_obj.co_freevars
+        for i, var_name in enumerate(freevars):
+            closure_dict[var_name] = lmb.__closure__[i].cell_contents
+    
+    # Merge globals and closures (closures take precedence for shadowing)
+    eval_namespace = {**globals_dict, **closure_dict}
+
+    # resolve the function object being called
+    try:
+        func_ref_src = _ast.unparse(body.func)
+    except AttributeError:
+        func_ref_src = _ast.get_source_segment(src, body.func) or ""
+    try:
+        func_obj = eval(func_ref_src, eval_namespace)
+    except Exception as e:
+        raise RuntimeError(f"Could not resolve function reference '{func_ref_src}': {e}")
+
+    if not callable(func_obj):
+        raise TypeError("Resolved object is not callable")
+
+    func_name = getattr(func_obj, "__name__", "<unknown>")
+
+    import_prefix: str = ""
+    if import_module:
+        module_file = _inspect.getsourcefile(func_obj)
+        module_path_candidate: str = module_file if module_file is not None else _inspect.getfile(func_obj)
+        import_prefix = get_import_module_string(str(_Path(module_path_candidate)))
+
+    # Evaluate each keyword argument value in the lambda's globals to get real Python objects
+    call_kwargs: dict[str, Any] = {}
+    for kw in body.keywords:
+        if kw.arg is None:
+            # **kwargs in call — evaluate to dict and merge
+            try:
+                val = eval(compile(_ast.Expression(kw.value), "<lambda_eval>", "eval"), eval_namespace)
+                if isinstance(val, dict):
+                    call_kwargs.update(val)
+                else:
+                    raise ValueError("Keyword expansion did not evaluate to a dict")
+            except Exception as e:
+                raise RuntimeError(f"Failed to evaluate **kwargs expression: {e}")
+        else:
+            try:
+                val = eval(compile(_ast.Expression(kw.value), "<lambda_eval>", "eval"), eval_namespace)
+                call_kwargs[kw.arg] = val
+            except Exception as e:
+                raise RuntimeError(f"Failed to evaluate value for kw '{kw.arg}': {e}")
+
+    # Try to get original source and dedent it for body extraction
+    try:
+        orig_src = _inspect.getsource(func_obj)
+        ded = _textwrap.dedent(orig_src)
+        lines = ded.splitlines()
+        def_index = None
+        for i, ln in enumerate(lines):
+            if ln.lstrip().startswith(f"def {func_name}("):
+                def_index = i
+                break
+        if def_index is None:
+            body_lines = ded.splitlines()
+        else:
+            signature_end_index = None
+            for i in range(def_index, len(lines)):
+                line_no_comment = lines[i].split("#", 1)[0].rstrip()
+                if line_no_comment.endswith(":"):
+                    signature_end_index = i
+                    break
+            if signature_end_index is None:
+                body_lines = lines[def_index + 1 :]
+            else:
+                body_lines = lines[signature_end_index + 1 :]
+        # ensure we have a body, otherwise use pass
+        if not any(line.strip() for line in body_lines):
+            body_text = "    pass\n"
+        else:
+            joined_body = "\n".join(body_lines)
+            if not joined_body.endswith("\n"):
+                joined_body = f"{joined_body}\n"
+            body_text = joined_body
+    except (OSError, IOError, TypeError):
+        body_text = "    pass\n"
+
+    # Build a replaced signature using inspect.signature
+    sig = _inspect.signature(func_obj)
+    new_params: list[_inspect.Parameter] = []
+    for name, param in sig.parameters.items():
+        # If the call provided a value for this parameter, replace default
+        if name in call_kwargs:
+            new_default = call_kwargs[name]
+        else:
+            new_default = param.default
+
+        normalized_annotation = _stringify_annotation(param.annotation)
+
+        if new_default is _inspect.Parameter.empty:
+            new_param = _inspect.Parameter(name, param.kind, annotation=normalized_annotation)
+        else:
+            new_param = _inspect.Parameter(
+                name, param.kind, default=new_default, annotation=normalized_annotation
+            )
+        new_params.append(new_param)
+
+    return_annotation = _stringify_annotation(sig.return_annotation)
+    new_sig = _inspect.Signature(parameters=new_params, return_annotation=return_annotation)
+
+    # If in_global mode, return kwargs as global assignments + dedented body
+    if in_global:
+        global_assignments: list[str] = []
+        for name, param in sig.parameters.items():
+            # Get the value from call_kwargs if provided, else use original default
+            if name in call_kwargs:
+                value = call_kwargs[name]
+            elif param.default is not _inspect.Parameter.empty:
+                value = param.default
+            else:
+                # No value provided and no default - skip this parameter
+                continue
+            
+            # Build type annotation string if available
+            if param.annotation is not _inspect.Parameter.empty:
+                annotation_literal = _stringify_annotation(param.annotation)
+                if isinstance(annotation_literal, str):
+                    global_assignments.append(f"{name}: {repr(annotation_literal)} = {repr(value)}")
+                else:
+                    global_assignments.append(f"{name} = {repr(value)}")
+            else:
+                global_assignments.append(f"{name} = {repr(value)}")
+        
+        # Dedent the body text to remove function indentation
+        dedented_body = _textwrap.dedent(body_text).rstrip()
+        
+        # Combine global assignments and body
+        if global_assignments:
+            result_parts: list[str] = ["\n".join(global_assignments), "", dedented_body]
+            result_text = "\n".join(result_parts)
+        else:
+            result_text = dedented_body
+    else:
+        header = f"def {func_name}{new_sig}:\n"
+        result_text = header + body_text
+
+    if in_global:
+        lines = result_text.splitlines()
+        if lines[-1].startswith("return "):
+            lines[-1] = lines[-1].replace("return ", "# return ", 1)
+            result_text = "\n".join(lines)
+
+    if "Optional" in result_text or "Any" in result_text or "Union" in result_text or "Literal" in result_text:
+        result_text = "from typing import Optional, Any, Union, Literal\n\n" + result_text
+    if import_prefix:
+        result_text = f"{import_prefix}{result_text}"
+    return result_text
+
+if __name__ == "__main__":
+    from machineconfig.utils.code import print_code
+    import_code_robust = "<import_code_robust>"
+    res = lambda_to_python_script(
+            lmb=lambda: print_code(code=import_code_robust, lexer="python", desc="import as module code"),
+            in_global=True, import_module=False
+        )
+    print(res)

machineconfig/utils/notifications.py

@@ -110,7 +110,7 @@ encryption = ssl
 
     def send_message(self, to: str, subject: str, body: str, txt_to_html: bool = True, attachments: Optional[list[Any]] = None):
         _ = attachments
-        body += "\n\nThis is an automated email sent via crocodile.comms script."
+        body += "\n\nThis is an automated email sent via machineconfig.comms script."
         # msg = message.EmailMessage()
         msg = MIMEMultipart("alternative")
         msg["subject"] = subject

machineconfig/utils/options.py

@@ -1,10 +1,17 @@
 from pathlib import Path
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
+from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
 from rich.text import Text
 from rich.panel import Panel
 from rich.console import Console
 import subprocess
-from typing import Optional, Union, Iterable, overload, Literal
+from typing import Optional, Union, Iterable, overload, Literal, cast
+
+
+# def strip_ansi_codes(text: str) -> str:
+#     """Remove ANSI color codes from text."""
+#     import re
+#     return re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)
+
 
 @overload
 def choose_from_options[T](msg: str, options: Iterable[T], multi: Literal[False], custom_input: bool = False, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False) -> T: ...
@@ -22,17 +29,20 @@ def choose_from_options[T](msg: str, options: Iterable[T], multi: bool, custom_i
         from pyfzf.pyfzf import FzfPrompt
         fzf_prompt = FzfPrompt()
         nl = "\n"
-        choice_string_multi: list[str] = fzf_prompt.prompt(choices=options_strings, fzf_options=("--multi" if multi else "") + f' --prompt "{prompt.replace(nl, " ")}" ')  # --border-label={msg.replace(nl, ' ')}")
+        choice_string_multi: list[str] = fzf_prompt.prompt(choices=options_strings, fzf_options=("--multi" if multi else "") + f' --prompt "{prompt.replace(nl, " ")}" --ansi')  # --border-label={msg.replace(nl, ' ')}")
         # --border=rounded doens't work on older versions of fzf installed at Ubuntu 20.04
         if not multi:
             try:
                 choice_one_string = choice_string_multi[0]
+                if isinstance(list(options)[0], str): return cast(T, choice_one_string)
                 choice_idx = options_strings.index(choice_one_string)
                 return list(options)[choice_idx]
             except IndexError as ie:
                 print(f"❌ Error: {options=}, {choice_string_multi=}")
                 print(f"🔍 Available choices: {choice_string_multi}")
                 raise ie
+        if isinstance(list(options)[0], str):
+            return cast(list[T], choice_string_multi)
         choice_idx_s = [options_strings.index(x) for x in choice_string_multi]
         return [list(options)[x] for x in choice_idx_s]
     else:

machineconfig/utils/path_extended.py

@@ -1,4 +1,5 @@
 from machineconfig.utils.accessories import randstr
+from machineconfig.utils.io import decrypt, encrypt
 
 from datetime import datetime
 import time
@@ -10,10 +11,12 @@ from platform import system
 from typing import Any, Optional, Union, Callable, TypeAlias, Literal
 
 
+
 OPLike: TypeAlias = Union[str, "PathExtended", Path, None]
 PLike: TypeAlias = Union[str, "PathExtended", Path]
 FILE_MODE: TypeAlias = Literal["r", "w", "x", "a"]
 SHUTIL_FORMATS: TypeAlias = Literal["zip", "tar", "gztar", "bztar", "xztar"]
+DECOMPRESS_SUPPORTED_FORMATS = [".tar.gz", ".tgz", ".tar", ".gz", ".tar.bz", ".tbz", ".tar.xz", ".zip", ".7z"]
 
 
 def _is_user_admin() -> bool:
@@ -54,81 +57,6 @@ def _run_shell_command(
     )
 
 
-def pwd2key(password: str, salt: Optional[bytes] = None, iterations: int = 10) -> bytes:  # Derive a secret key from a given password and salt"""
-    import base64
-
-    if salt is None:
-        import hashlib
-
-        m = hashlib.sha256()
-        m.update(password.encode(encoding="utf-8"))
-        return base64.urlsafe_b64encode(s=m.digest())  # make url-safe bytes required by Ferent.
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-
-    return base64.urlsafe_b64encode(PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=iterations, backend=None).derive(password.encode()))
-
-
-def encrypt(msg: bytes, key: Optional[bytes] = None, pwd: Optional[str] = None, salted: bool = True, iteration: Optional[int] = None, gen_key: bool = False) -> bytes:
-    import base64
-    from cryptography.fernet import Fernet
-
-    salt, iteration = None, None
-    if pwd is not None:  # generate it from password
-        assert (key is None) and (type(pwd) is str), "❌ You can either pass key or pwd, or none of them, but not both."
-        import secrets
-
-        iteration = iteration or secrets.randbelow(exclusive_upper_bound=1_000_000)
-        salt = secrets.token_bytes(nbytes=16) if salted else None
-        key_resolved = pwd2key(password=pwd, salt=salt, iterations=iteration)
-    elif key is None:
-        if gen_key:
-            key_resolved = Fernet.generate_key()
-            Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").write_bytes(key_resolved)
-        else:
-            try:
-                key_resolved = Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").read_bytes()
-                print(f"⚠️ Using key from: {Path.home().joinpath('dotfiles/creds/data/encrypted_files_key.bytes')}")
-            except FileNotFoundError as err:
-                print("\n" * 3, "~" * 50, """Consider Loading up your dotfiles or pass `gen_key=True` to make and save one.""", "~" * 50, "\n" * 3)
-                raise FileNotFoundError(err) from err
-    elif isinstance(key, (str, PathExtended, Path)):
-        key_resolved = Path(key).read_bytes()  # a path to a key file was passed, read it:
-    elif type(key) is bytes:
-        key_resolved = key  # key passed explicitly
-    else:
-        raise TypeError("❌ Key must be either a path, bytes object or None.")
-    code = Fernet(key=key_resolved).encrypt(msg)
-    if pwd is not None and salt is not None and iteration is not None:
-        return base64.urlsafe_b64encode(b"%b%b%b" % (salt, iteration.to_bytes(4, "big"), base64.urlsafe_b64decode(code)))
-    return code
-
-
-def decrypt(token: bytes, key: Optional[bytes] = None, pwd: Optional[str] = None, salted: bool = True) -> bytes:
-    import base64
-
-    if pwd is not None:
-        assert key is None, "❌ You can either pass key or pwd, or none of them, but not both."
-        if salted:
-            decoded = base64.urlsafe_b64decode(token)
-            salt, iterations, token = decoded[:16], decoded[16:20], base64.urlsafe_b64encode(decoded[20:])
-            key_resolved = pwd2key(password=pwd, salt=salt, iterations=int.from_bytes(bytes=iterations, byteorder="big"))
-        else:
-            key_resolved = pwd2key(password=pwd)  # trailing `;` prevents IPython from caching the result.
-    elif type(key) is bytes:
-        assert pwd is None, "❌ You can either pass key or pwd, or none of them, but not both."
-        key_resolved = key  # passsed explicitly
-    elif key is None:
-        key_resolved = Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").read_bytes()  # read from file
-    elif isinstance(key, (str, Path)):
-        key_resolved = Path(key).read_bytes()  # passed a path to a file containing kwy
-    else:
-        raise TypeError(f"❌ Key must be either str, P, Path, bytes or None. Recieved: {type(key)}")
-    from cryptography.fernet import Fernet
-
-    return Fernet(key=key_resolved).decrypt(token)
-
-
 def validate_name(astring: str, replace: str = "_") -> str:
     import re
 
@@ -167,7 +95,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             print(f"🗑️ ❌ DELETED {repr(self)}.")
         return self
 
-    def move(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, rel2it: bool = False, overwrite: bool = False, verbose: bool = True, parents: bool = True, content: bool = False) -> "PathExtended":
+    def move(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, rel2it: bool = False, overwrite: bool = False, verbose: bool = True, parents: bool = True, content: bool = False) -> "PathExtended":  # type: ignore
         path = self._resolve_path(folder=folder, name=name, path=path, default_name=self.absolute().name, rel2it=rel2it)
         if parents:
             path.parent.mkdir(parents=True, exist_ok=True)
@@ -193,9 +121,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             print(f"🚚 MOVED {repr(self)} ==> {repr(path)}`")
         return path
 
-    def copy(
-        self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, content: bool = False, verbose: bool = True, append: Optional[str] = None, overwrite: bool = False, orig: bool = False
-    ) -> "PathExtended":  # tested %100  # TODO: replace `content` flag with ability to interpret "*" in resolve method.
+    def copy(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, content: bool = False, verbose: bool = True, append: Optional[str] = None, overwrite: bool = False, orig: bool = False) -> "PathExtended":  # type: ignore
         dest = self._resolve_path(folder=folder, name=name, path=path, default_name=self.name, rel2it=False)
         dest = dest.expanduser().resolve()
         dest.parent.mkdir(parents=True, exist_ok=True)
@@ -227,7 +153,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     # ======================================= File Editing / Reading ===================================
     def download(self, folder: OPLike = None, name: Optional[str] = None, allow_redirects: bool = True, timeout: Optional[int] = None, params: Any = None) -> "PathExtended":
         import requests
-
         response = requests.get(self.as_url_str(), allow_redirects=allow_redirects, timeout=timeout, params=params)  # Alternative: from urllib import request; request.urlopen(url).read().decode('utf-8').
         assert response.status_code == 200, f"Download failed with status code {response.status_code}\n{response.text}"
         if name is not None:
@@ -555,9 +480,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         **kwargs: Any,
     ) -> "PathExtended":
         path_resolved, slf = self._resolve_path(folder, name, path, self.name).expanduser().resolve(), self.expanduser().resolve()
-        # if use_7z:  # benefits over regular zip and encrypt: can handle very large files with low memory footprint
-        #     path_resolved = path_resolved + '.7z' if not path_resolved.suffix == '.7z' else path_resolved
-        #     with install_n_import("py7zr").SevenZipFile(file=path_resolved, mode=mode, password=pwd) as archive: archive.writeall(path=str(slf), arcname=None)
         arcname_obj = PathExtended(arcname or slf.name)
         if arcname_obj.name != slf.name:
             arcname_obj /= slf.name  # arcname has to start from somewhere and end with filename
@@ -630,15 +552,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         folder = folder if not content else folder.parent
         if slf.suffix == ".7z":
             raise NotImplementedError("I have not implemented this yet")
-            # if overwrite: P(folder).delete(sure=True)
-            # result = folder
-            # import py7zr
-            # with py7zr.SevenZipFile(file=slf, mode='r', password=pwd) as archive:
-            #     if pattern is not None:
-            #         import re
-            #         pat = re.compile(pattern)
-            #         archive.extract(path=folder, targets=[f for f in archive.getnames() if pat.match(f)])
-            #     else: archive.extractall(path=folder)
         else:
             if overwrite:
                 if not content:
@@ -773,19 +686,52 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         return ret
 
     def decompress(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, inplace: bool = False, orig: bool = False, verbose: bool = True) -> "PathExtended":
-        if ".tar.gz" in str(self) or ".tgz" in str(self):
+        if str(self).endswith(".tar.gz") or str(self).endswith(".tgz"):
             # res = self.ungz_untar(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
             return self.ungz(name=f"tmp_{randstr()}.tar", inplace=inplace).untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)  # this works for .tgz suffix as well as .tar.gz
-        elif ".gz" in str(self):
+        elif str(self).endswith(".tar"):
+            res = self.untar(folder=folder, name=name, path=path, inplace=inplace, orig=orig, verbose=verbose)
+        elif str(self).endswith(".gz"):
             res = self.ungz(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
-        elif ".tar.bz" in str(self) or "tbz" in str(self):
+        elif str(self).endswith(".tar.bz") or str(self).endswith(".tbz"):
             res = self.unbz(name=f"tmp_{randstr()}.tar", inplace=inplace)
             return res.untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)
-        elif ".tar.xz" in str(self):
+        elif str(self).endswith(".tar.xz"):
             # res = self.unxz_untar(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
             res = self.unxz(inplace=inplace).untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)
-        elif ".zip" in str(self):
+        elif str(self).endswith(".zip"):
             res = self.unzip(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
+        elif str(self).endswith(".7z"):
+            def unzip_7z(archive_path: str, dest_dir: Optional[str] = None) -> Path:
+                """
+                Uncompresses a .7z archive to a directory and returns the Path to the extraction directory.
+
+                :param archive_path: path to the .7z archive file
+                :param dest_dir: optional path to directory to extract into; if None a temporary dir will be created
+                :return: pathlib.Path pointing to the destination directory where contents were extracted
+                :raises: FileNotFoundError if archive does not exist; py7zr.Bad7zFile or other error if extraction fails
+                """
+                import py7zr  # type: ignore
+                import tempfile
+                from pathlib import Path
+                archive_path_obj = Path(archive_path)
+                if not archive_path_obj.is_file():
+                    raise FileNotFoundError(f"Archive file not found: {archive_path_obj!r}")
+                if dest_dir is None:
+                    # create a temporary directory
+                    dest = Path(tempfile.mkdtemp(prefix=f"unzip7z_{archive_path_obj.stem}_"))
+                else:
+                    dest = Path(dest_dir)
+                    dest.mkdir(parents=True, exist_ok=True)
+                # Perform extraction
+                with py7zr.SevenZipFile(str(archive_path_obj), mode='r') as archive:
+                    archive.extractall(path=str(dest))
+                # Return the extraction directory path
+                return dest
+            from machineconfig.utils.code import run_lambda_function
+            destination_dir = str(self.expanduser().resolve()).replace(".7z", "")
+            run_lambda_function(lambda: unzip_7z(archive_path=str(self), dest_dir=destination_dir), uv_project_dir=None, uv_with=["py7zr"])
+            res = PathExtended(destination_dir)
         else:
             res = self
         return res
@@ -863,7 +809,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             path = self
         else:
             try:
-                path = self.rel2home()
+                path = PathExtended(self.expanduser().absolute().relative_to(Path.home()))
             except ValueError as ve:
                 if strict:
                     raise ve
@@ -911,9 +857,10 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             rp = localpath.get_remote_path(root=root, os_specific=os_specific, rel2home=rel2home, strict=strict)  # if rel2home else (P(root) / localpath if root is not None else localpath)
         else:
             rp = PathExtended(remotepath)
-
         from rclone_python import rclone
+        print(f"⬆️ UPLOADING {repr(localpath)} TO {cloud}:{rp.as_posix()}`") if verbose else None
         rclone.copyto(in_path=localpath.as_posix(), out_path=f"{cloud}:{rp.as_posix()}", )
+
         _ = [item.delete(sure=True) for item in to_del]
         if verbose:
             print(f"{'⬆️' * 5} UPLOAD COMPLETED.")
@@ -924,7 +871,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             command = f"rclone link '{cloud}:{rp.as_posix()}'"
             completed = _run_shell_command(command, shell_to_use)
             from machineconfig.utils.terminal import Response
-
             res = Response.from_completed_process(completed).capture()
             tmp = res.op2path(strict_err=False, strict_returncode=False)
             if tmp is None: