machineconfig 1.96__py3-none-any.whl → 2.0__py3-none-any.whl

machineconfig/utils/path_reduced.py

@@ -1,17 +1,14 @@
 
 
-
-
-from crocodile.core import List, timestamp, randstr, install_n_import, validate_name
-from crocodile.file_management_helpers.file1 import encrypt, decrypt
-from crocodile.file_management_helpers.file2 import Compression
-from crocodile.file_management_helpers.file3 import Read
-
+from machineconfig.utils.utils2 import randstr
 from datetime import datetime
+import time
 from pathlib import Path
 import sys
 import subprocess
+from platform import system
 from typing import Any, Optional, Union, Callable, TypeAlias, Literal
+import os
 
 
 OPLike: TypeAlias = Union[str, 'P', Path, None]
@@ -20,6 +17,68 @@ FILE_MODE: TypeAlias = Literal['r', 'w', 'x', 'a']
 SHUTIL_FORMATS: TypeAlias = Literal["zip", "tar", "gztar", "bztar", "xztar"]
 
 
+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, P, 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
+    return re.sub(r'[^-a-zA-Z0-9_.()]+', replace, str(astring))
+def timestamp(fmt: Optional[str] = None, name: Optional[str] = None) -> str:
+    return ((name + '_') if name is not None else '') + datetime.now().strftime(fmt or '%Y-%m-%d-%I-%M-%S-%p-%f')  # isoformat is not compatible with file naming convention, fmt here is.
+
+
 def modify_text(txt_raw: str, txt_search: str, txt_alt: Union[str, Callable[[str], str]], replace_line: bool = True, notfound_append: bool = False, prepend: bool = False, strict: bool = False):
     lines, bingo = txt_raw.split("\n"), False
     if not replace_line:  # no need for line splitting
@@ -38,6 +97,76 @@ def modify_text(txt_raw: str, txt_search: str, txt_alt: Union[str, Callable[[str
         else: lines.append(txt_alt)  # txt not found, add it anyway.
     return "\n".join(lines)
 
+
+class Compression:
+    @staticmethod
+    def compress_folder(root_dir: str, op_path: str, base_dir: str, fmt: SHUTIL_FORMATS = 'zip', verbose: bool = False, **kwargs: Any) -> str:  # shutil works with folders nicely (recursion is done interally) # directory to be archived: root_dir\base_dir, unless base_dir is passed as absolute path. # when archive opened; base_dir will be found."""
+        base_name = op_path[:-4] if op_path.endswith(".zip") else op_path  # .zip is added automatically by library, hence we'd like to avoid repeating it if user sent it.
+        import shutil
+        return shutil.make_archive(base_name=base_name, format=fmt, root_dir=root_dir, base_dir=base_dir, verbose=verbose, **kwargs)  # returned path possible have added extension.
+    @staticmethod
+    def zip_file(ip_path: str, op_path: str, arcname: Optional[str]= None, password: Optional[bytes] = None, mode: FILE_MODE = "w", **kwargs: Any):
+        """arcname determines the directory of the file being archived inside the archive. Defaults to same as original directory except for drive.
+        When changed, it should still include the file path in its end. If arcname = filename without any path, then, it will be in the root of the archive."""
+        import zipfile
+        with zipfile.ZipFile(op_path, mode=mode) as jungle_zip:
+            if password is not None: jungle_zip.setpassword(pwd=password)
+            jungle_zip.write(filename=str(ip_path), arcname=str(arcname) if arcname is not None else None, compress_type=zipfile.ZIP_DEFLATED, **kwargs)
+        return Path(op_path)
+    @staticmethod
+    def unzip(ip_path: str, op_path: str, fname: Optional[str]= None, password: Optional[bytes] = None, memory: bool = False, **kwargs: Any) -> Path | dict[str, bytes] | bytes:
+        import zipfile
+        with zipfile.ZipFile(str(ip_path), 'r') as zipObj:
+            if memory:
+                return {name: zipObj.read(name) for name in zipObj.namelist()} if fname is None else zipObj.read(fname)
+            if fname is None:
+                zipObj.extractall(op_path, pwd=password, **kwargs)
+                return Path(op_path)
+            else:
+                zipObj.extract(member=str(fname), path=str(op_path), pwd=password)
+                return Path(op_path) / fname
+    @staticmethod
+    def gz(file: str, op_path: str):  # see this on what to use: https://stackoverflow.com/questions/10540935/what-is-the-difference-between-tar-and-zip
+        import shutil
+        import gzip
+        with open(file, 'rb') as f_in:
+            with gzip.open(op_path, 'wb') as f_out: shutil.copyfileobj(f_in, f_out)
+        return Path(op_path)
+    @staticmethod
+    def ungz(path: str, op_path: str):
+        import gzip
+        import shutil
+        with gzip.open(path, 'r') as f_in, open(op_path, 'wb') as f_out: shutil.copyfileobj(f_in, f_out)
+        return Path(op_path)
+    @staticmethod
+    def unbz(path: str, op_path: str):
+        import bz2
+        import shutil
+        with bz2.BZ2File(path, 'r') as fr, open(str(op_path), 'wb') as fw: shutil.copyfileobj(fr, fw)
+        return Path(op_path)
+    @staticmethod
+    def xz(path: str, op_path: str):
+        import lzma
+        with lzma.open(op_path, "w") as f: f.write(Path(path).read_bytes())
+    @staticmethod
+    def unxz(ip_path: str, op_path: str):
+        import lzma
+        with lzma.open(ip_path) as file: Path(op_path).write_bytes(file.read())
+    @staticmethod
+    def tar(path: str, op_path: str):
+        import tarfile
+        with tarfile.open(op_path, "w:gz") as tar_: tar_.add(str(path), arcname=os.path.basename(path))
+        return Path(op_path)
+    @staticmethod
+    def untar(path: str, op_path: str, fname: Optional[str]= None, mode: Literal['r', 'w'] = 'r', **kwargs: Any):
+        import tarfile
+        with tarfile.open(str(path), mode) as file:
+            if fname is None: file.extractall(path=op_path, **kwargs)  # extract all files in the archive
+            else: file.extract(fname, **kwargs)
+        return Path(op_path)
+
+
+
 class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     # ============= Path management ==================
     """ The default behaviour of methods acting on underlying disk object is to perform the action and return a new path referring to the mutated object in disk drive.
@@ -65,7 +194,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         slf = self.expanduser().resolve()
         if content:
             assert self.is_dir(), NotADirectoryError(f"💥 When `content` flag is set to True, path must be a directory. It is not: `{repr(self)}`")
-            self.search("*").apply(lambda x: x.move(folder=path.parent, content=False, overwrite=overwrite))
+            [x.move(folder=path.parent, content=False, overwrite=overwrite) for x in self.search("*")]
             return path  # contents live within this directory.
         if overwrite:
             tmp_path = slf.rename(path.parent.absolute() / randstr())
@@ -103,47 +232,6 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         else: print(f"💥 Could NOT COPY. Not a file nor a path: {repr(slf)}.")
         return dest if not orig else self
     # ======================================= File Editing / Reading ===================================
-    def readit(self, reader: Optional[Callable[[PLike], Any]] = None, strict: bool = True, default: Optional[Any] = None, verbose: bool = False, **kwargs: Any) -> 'Any':
-        slf = self.expanduser().resolve()
-        if not slf.exists():
-            if strict: raise FileNotFoundError(f"`{slf}` is no where to be found!")
-            else:
-                if verbose: print(f"💥 P.readit warning: FileNotFoundError, skipping reading of file `{self}")
-                return default
-        if verbose: print(f"Reading {slf} ({slf.size()} MB) ...")
-        if '.tar.gz' in str(slf) or '.tgz' in str(slf) or '.gz' in str(slf) or '.tar.bz' in str(slf) or 'tbz' in str(slf) or 'tar.xz' in str(slf) or '.zip' in str(slf):
-            filename = slf.decompress(folder=slf.tmp(folder="tmp_unzipped"), verbose=True)
-            if filename.is_dir():
-                tmp_content = filename.search("*")
-                if len(tmp_content) == 1:
-                    print(f"⚠️ Found only one file in the unzipped folder: {tmp_content[0]}")
-                    filename = tmp_content.list[0]
-                else:
-                    if strict: raise ValueError(f"❌ Expected only one file in the unzipped folder, but found {len(tmp_content)} files.")
-                    else: print(f"⚠️ Found {len(tmp_content)} files in the unzipped folder. Using the first one: {tmp_content[0]}")
-                    filename = tmp_content.list[0]
-        else: filename = slf
-        try:
-            return Read.read(filename, **kwargs) if reader is None else reader(str(filename), **kwargs)
-        except IOError as ioe: raise IOError from ioe
-    # DEPRECATED: append_text has been removed. Use the inline equivalent instead:
-    #   p.write_text(p.read_text() + appendix)
-    # Returning the path (p) is preserved by write_text in this class.
-    # Example:
-    #   p = p.write_text(p.read_text() + appendix)
-    # def append_text(self, appendix: str) -> 'P':
-    #     self.write_text(self.read_text() + appendix)
-    #     return self
-    # DEPRECATED: Instance method modify_text is deprecated and left commented-out to prevent new usage.
-    # Please inline using the module-level modify_text helper:
-    #   current = p.read_text() if p.exists() else ""
-    #   updated = modify_text(current, search, alt, replace_line=..., notfound_append=..., prepend=...)
-    #   p.write_text(updated)
-    # def modify_text(self, txt_search: str, txt_alt: str, replace_line: bool = False, notfound_append: bool = False, prepend: bool = False, encoding: str = 'utf-8'):
-    #     if not self.exists():
-    #         self.parent.mkdir(parents=True, exist_ok=True)
-    #         self.write_text(txt_search)
-    #     return self.write_text(modify_text(txt_raw=self.read_text(encoding=encoding), txt_search=txt_search, txt_alt=txt_alt, replace_line=replace_line, notfound_append=notfound_append, prepend=prepend), encoding=encoding)
     def download(self, folder: OPLike = None, name: Optional[str]= None, allow_redirects: bool = True, timeout: Optional[int] = None, params: Any = None) -> 'P':
         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').
@@ -156,7 +244,8 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 f_name = validate_name(str(P(response.history[-1].url).name if len(response.history) > 0 else P(response.url).name))
         dest_path = (P.home().joinpath("Downloads") if folder is None else P(folder)).joinpath(f_name)
         dest_path.parent.mkdir(parents=True, exist_ok=True)
-        return dest_path.write_bytes(response.content)
+        dest_path.write_bytes(response.content)
+        return dest_path
     def _return(self, res: Union['P', 'Path'], operation: Literal['rename', 'delete', 'Whack'], inplace: bool = False, overwrite: bool = False, orig: bool = False, verbose: bool = False, strict: bool = True, msg: str = "", __delayed_msg__: str = "") -> 'P':
         res = P(res)
         if inplace:
@@ -180,11 +269,6 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             try: print(__delayed_msg__)
             except UnicodeEncodeError: print("P._return warning: UnicodeEncodeError, could not print message.")
         return self if orig else res
-    # # ================================ Path Object management ===========================================
-    # """ Distinction between Path object and the underlying file on disk that the path may refer to. Two distinct flags are used:
-    #     `inplace`: the operation on the path object will affect the underlying file on disk if this flag is raised, otherwise the method will only alter the string.
-    #     `inliue`: the method acts on the path object itself instead of creating a new one if this flag is raised.
-    #     `orig`: whether the method returns the original path object or a new one."""
     def append(self, name: str = '', index: bool = False, suffix: Optional[str] = None, verbose: bool = True, **kwargs: Any) -> 'P':
         """Returns a new path object with the name appended to the stem of the path. If `index` is True, the name will be the index of the path in the parent directory."""
         if index:
@@ -196,12 +280,6 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         return self._return(self.parent.joinpath(subpath), operation="rename", verbose=verbose, **kwargs)
     def with_name(self, name: str, verbose: bool = True, inplace: bool = False, overwrite: bool = False, **kwargs: Any):
         return self._return(self.parent / name, verbose=verbose, operation="rename", inplace=inplace, overwrite=overwrite, **kwargs)
-    # ============================= attributes of object ======================================
-    # @property
-    # def items(self) -> List[str]: return List(self.parts)
-    # def __len__(self) -> int: return len(self.parts)
-    # def __contains__(self, item: PLike): return P(item).as_posix() in self.as_posix()
-    # def __iter__(self): return self.parts.__iter__()
     def __deepcopy__(self, *args: Any, **kwargs: Any) -> 'P':
         _ = args, kwargs
         return P(str(self))
@@ -213,10 +291,10 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     def __sub__(self, other: PLike) -> 'P':
         res = P(str(self).replace(str(other), ""))
         return (res[1:] if str(res[0]) in {"\\", "/"} else res) if len(res.parts) else res  # paths starting with "/" are problematic. e.g ~ / "/path" doesn't work.
-    
+
     def rel2home(self, ) -> 'P': return self._return(P(self.expanduser().absolute().relative_to(Path.home())), operation='Whack')  # very similat to collapseuser but without "~" being added so its consistent with rel2cwd.
     def collapseuser(self, strict: bool = True, placeholder: str = "~") -> 'P':  # opposite of `expanduser` resolve is crucial to fix Windows cases insensitivty problem.
-        if strict: assert P.home() in self.expanduser().absolute().resolve(), ValueError(f"`{P.home()}` is not in the subpath of `{self}`")
+        if strict: assert str(self.expanduser().absolute().resolve()).startswith(str(P.home())), ValueError(f"`{P.home()}` is not in the subpath of `{self}`")
         if (str(self).startswith(placeholder) or P.home().as_posix() not in self.resolve().as_posix()): return self
         return self._return(res=P(placeholder) / (self.expanduser().absolute().resolve(strict=strict) - P.home()), operation='Whack')  # resolve also solves the problem of Windows case insensitivty.
     def __getitem__(self, slici: Union[int, list[int], slice]):
@@ -268,7 +346,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             case "a": tmp = self.stat().st_atime
             case "c": tmp = self.stat().st_ctime
         return datetime.fromtimestamp(tmp, **kwargs)
-    
+
     # ================================ String Nature management ====================================
     def clickable(self, ) -> 'P': return self._return(res=P(self.expanduser().resolve().as_uri()), operation='Whack')
     def as_url_str(self) -> 'str': return self.as_posix().replace("https:/", "https://").replace("http:/", "http://")
@@ -293,39 +371,17 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             elif self.is_dir(): return "📁"
             return "👻NotExist"
         return "📍Relative"
-    def write_text(self, data: str, encoding: str = 'utf-8', newline: Optional[str] = None) -> 'P':
-        self.parent.mkdir(parents=True, exist_ok=True)
-        super(P, self).write_text(data, encoding=encoding, newline=newline)
-        return self
-    def read_text(self, encoding: Optional[str] = 'utf-8') -> str: return super(P, self).read_text(encoding=encoding)
-    def write_bytes(self, data: bytes, overwrite: bool = False) -> 'P':
-        slf = self.expanduser().absolute()
-        if overwrite and slf.exists(): slf.delete(sure=True)
-        res = super(P, slf).write_bytes(data)
-        if res == 0: raise RuntimeError("Could not save file on disk.")
-        return self
-    # def touch(self, mode: int = 0o666, parents: bool = True, exist_ok: bool = True) -> 'P':  # pylint: disable=W0237
-    #     """Deprecated: rely on pathlib.Path.touch at call sites.
-    #     Behavior was:
-    #       - if parents: ensure parent directories exist
-    #       - then call Path.touch(mode=mode, exist_ok=exist_ok)
-    #       - return self
-    #     Replace usages with:
-    #         p.parent.mkdir(parents=True, exist_ok=True); p.touch(mode=..., exist_ok=...)
-    #     """
-    #     if parents: self.parent.mkdir(parents=parents, exist_ok=True)
-    #     super(P, self).touch(mode=mode, exist_ok=exist_ok)
-    #     return self
-
-    def symlink_to(self, target: PLike, verbose: bool = True, overwrite: bool = False, orig: bool = False, strict: bool = True):  # pylint: disable=W0237
+    def symlink_to(self, target: PLike, verbose: bool = True, overwrite: bool = False, orig: bool = False, strict: bool = True):  # type: ignore[override]  # pylint: disable=W0237
         self.parent.mkdir(parents=True, exist_ok=True)
         target_obj = P(target).expanduser().resolve()
         if strict: assert target_obj.exists(), f"Target path `{target}` (aka `{target_obj}`) doesn't exist. This will create a broken link."
         if overwrite and (self.is_symlink() or self.exists()): self.delete(sure=True, verbose=verbose)
-        from platform import system
-        from crocodile.meta import Terminal
+        from machineconfig.utils.terminal import Terminal
         if system() == "Windows" and not Terminal.is_user_admin():  # you cannot create symlink without priviliages.
-            Terminal.run_as_admin(file=sys.executable, params=f" -c \"from pathlib import Path; Path(r'{self.expanduser()}').symlink_to(r'{str(target_obj)}')\"", wait=True)
+            import win32com.shell.shell
+            _proce_info = win32com.shell.shell.ShellExecuteEx(lpVerb='runas', lpFile=sys.executable, lpParameters=f" -c \"from pathlib import Path; Path(r'{self.expanduser()}').symlink_to(r'{str(target_obj)}')\"")
+            # TODO update PATH for this to take effect immediately.
+            time.sleep(1)  # wait=True equivalent
         else: super(P, self.expanduser()).symlink_to(str(target_obj))
         return self._return(target_obj, operation='Whack', inplace=False, orig=orig, verbose=verbose, msg=f"LINKED {repr(self)} ➡️ {repr(target_obj)}")
     def resolve(self, strict: bool = False):
@@ -333,7 +389,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         except OSError: return self
     # ======================================== Folder management =======================================
     def search(self, pattern: str = '*', r: bool = False, files: bool = True, folders: bool = True, compressed: bool = False, dotfiles: bool = False, filters_total: Optional[list[Callable[[Any], bool]]] = None, not_in: Optional[list[str]] = None,
-               exts: Optional[list[str]] = None, win_order: bool = False) -> List['P']:
+               exts: Optional[list[str]] = None, win_order: bool = False) -> list['P']:
         if isinstance(not_in, list):
             filters_notin = [lambda x: all([str(a_not_in) not in str(x) for a_not_in in not_in])]  # type: ignore
         else: filters_notin = []
@@ -349,11 +405,13 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             import fnmatch
             root = slf.as_zip_path()
             if not r:
-                raw = List(root.iterdir())
+                raw = list(root.iterdir())
             else:
-                raw = List(zipfile.ZipFile(str(slf)).namelist()).apply(root.joinpath)
-            res1 = raw.filter(lambda zip_path: fnmatch.fnmatch(zip_path.at, pattern))  # type: ignore
-            return res1.filter(lambda x: (folders or x.is_file()) and (files or x.is_dir()))  # type: ignore
+                raw = [root.joinpath(item) for item in zipfile.ZipFile(str(slf)).namelist()]
+            # res1 = raw.filter(lambda zip_path: fnmatch.fnmatch(zip_path.at, pattern))  # type: ignore
+            res1 = [item for item in raw if fnmatch.fnmatch(item.at, pattern)]
+            # return res1.filter(lambda x: (folders or x.is_file()) and (files or x.is_dir()))
+            return [item for item in res1 if (folders or item.is_file()) and (files or item.is_dir())]  # type: ignore
         elif dotfiles: raw = slf.glob(pattern) if not r else self.rglob(pattern)
         else:
             from glob import glob
@@ -363,31 +421,19 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 raw = glob(str(slf.joinpath(pattern)))  # glob ignroes dot and hidden files
         if ".zip" not in str(slf) and compressed:
             filters_notin = [P(comp_file).search(pattern=pattern, r=r, files=files, folders=folders, compressed=True, dotfiles=dotfiles, filters_total=filters_total, not_in=not_in, win_order=win_order) for comp_file in self.search("*.zip", r=r)]
-            haha = List(filters_notin).reduce(func=lambda x, y: x + y)
+            from functools import reduce
+            # haha = List(filters_notin).reduce(func=lambda x, y: x + y)
+            haha = reduce(lambda x, y: x + y, filters_notin) if len(filters_notin) else []
             raw = raw + haha  # type: ignore
         processed = []
         for item in raw:
             item_ = P(item)
             if all([afilter(item_) for afilter in filters_total]):
                 processed.append(item_)
-        if not win_order: return List(processed)
+        if not win_order: return list(processed)
         import re
         processed.sort(key=lambda x: [int(k) if k.isdigit() else k for k in re.split('([0-9]+)', string=x.stem)])
-        return List(processed)
-    
-    # def create(self, parents: bool = True, exist_ok: bool = True, parents_only: bool = False) -> 'P':
-    #     """Deprecated. Use Path.mkdir directly at the call site:
-    #     - When creating a directory: self.mkdir(parents=True, exist_ok=True)
-    #     - When ensuring parent exists: self.parent.mkdir(parents=True, exist_ok=True)
-    #     This method used to:
-    #         target_path = self.parent if parents_only else self
-    #         target_path.mkdir(parents=parents, exist_ok=exist_ok)
-    #         return self
-    #     """
-    #     target_path = self.parent if parents_only else self
-    #     target_path.mkdir(parents=parents, exist_ok=exist_ok)
-    #     return self
-
+        return list(processed)
     @staticmethod
     def tmpdir(prefix: str = "") -> 'P':
         return P.tmp(folder=rf"tmp_dirs/{prefix + ('_' if prefix != '' else '') + randstr()}")
@@ -403,20 +449,19 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         return base
     # ====================================== Compression & Encryption ===========================================
     def zip(self, path: OPLike = None, folder: OPLike = None, name: Optional[str]= None, arcname: Optional[str] = None, inplace: bool = False, verbose: bool = True,
-            content: bool = False, orig: bool = False, use_7z: bool = False, pwd: Optional[str] = None, mode: FILE_MODE = 'w', **kwargs: Any) -> 'P':
+            content: bool = False, orig: bool = False, pwd: Optional[str] = None, mode: FILE_MODE = 'w', **kwargs: Any) -> 'P':
         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)
+        # 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 = P(arcname or slf.name)
+        if arcname_obj.name != slf.name: arcname_obj /= slf.name  # arcname has to start from somewhere and end with filename
+        if slf.is_file():
+            path_resolved = Compression.zip_file(ip_path=str(slf), op_path=str(path_resolved + ".zip" if path_resolved.suffix != ".zip" else path_resolved), arcname=str(arcname_obj), mode=mode, **kwargs)
         else:
-            arcname_obj = P(arcname or slf.name)
-            if arcname_obj.name != slf.name: arcname_obj /= slf.name  # arcname has to start from somewhere and end with filename
-            if slf.is_file():
-                path_resolved = Compression.zip_file(ip_path=str(slf), op_path=str(path_resolved + ".zip" if path_resolved.suffix != ".zip" else path_resolved), arcname=str(arcname_obj), mode=mode, **kwargs)
-            else:
-                if content: root_dir, base_dir = slf, "."
-                else: root_dir, base_dir = slf.split(at=str(arcname_obj[0]), sep=1)[0], str(arcname_obj)
-                path_resolved = P(Compression.compress_folder(root_dir=str(root_dir), op_path=str(path_resolved), base_dir=base_dir, fmt='zip', **kwargs))  # TODO: see if this supports mode
+            if content: root_dir, base_dir = slf, "."
+            else: root_dir, base_dir = slf.split(at=str(arcname_obj[0]), sep=1)[0], str(arcname_obj)
+            path_resolved = P(Compression.compress_folder(root_dir=str(root_dir), op_path=str(path_resolved), base_dir=base_dir, fmt='zip', **kwargs))  # TODO: see if this supports mode
         return self._return(path_resolved, inplace=inplace, operation="delete", orig=orig, verbose=verbose, msg=f"ZIPPED {repr(slf)} ==>  {repr(path)}")
     def unzip(self, folder: OPLike = None, path: OPLike = None, name: Optional[str]= None, verbose: bool = True, content: bool = False, inplace: bool = False, overwrite: bool = False, orig: bool = False,
               pwd: Optional[str] = None, tmp: bool = False, pattern: Optional[str] = None, merge: bool = False) -> 'P':
@@ -428,26 +473,31 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             tmp__ = [item for item in (".zip", ".7z", "") if item in str(slf)]
             ztype = tmp__[0]
             if ztype == "": return slf
-            zipfile__, name__ = slf.split(at=str(List(slf.parts).filter(lambda x: ztype in x)[0]), sep=-1)
+            # zipfile__, name__ = slf.split(at=str(List(slf.parts).filter(lambda x: ztype in x)[0]), sep=-1)
+            zipfile__, name__ = slf.split(at=str(next(item for item in slf.parts if ztype in item)), sep=-1)
             name = str(name__)
         folder = (zipfile__.parent / zipfile__.stem) if folder is None else P(folder).expanduser().absolute().resolve().joinpath(zipfile__.stem)
+        assert isinstance(folder, P), "folder should be a P object at this point"
         folder = folder if not content else folder.parent
         if slf.suffix == ".7z":
-            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)
+            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: P(folder).joinpath(name or "").delete(sure=True, verbose=True)  # deletes a specific file / folder that has the same name as the zip file without extension.
                 else:
                     import zipfile
-                    List([x for x in zipfile.ZipFile(str(self)).namelist() if "/" not in x or (len(x.split('/')) == 2 and x.endswith("/"))]).apply(lambda item: P(folder).joinpath(name or "", item.replace("/", "")).delete(sure=True, verbose=True))
+                    mylist = [x for x in zipfile.ZipFile(str(self)).namelist() if "/" not in x or (len(x.split('/')) == 2 and x.endswith("/"))]
+                    # List().apply(lambda item: P(folder).joinpath(name or "", item.replace("/", "")).delete(sure=True, verbose=True))
+                    for item in mylist: P(folder).joinpath(name or "", item.replace("/", "")).delete(sure=True, verbose=True)
             result = Compression.unzip(str(zipfile__), str(folder), None if name is None else P(name).as_posix())
             assert isinstance(result, Path)
         return self._return(P(result), inplace=inplace, operation="delete", orig=orig, verbose=verbose, msg=f"UNZIPPED {repr(zipfile__)} ==> {repr(result)}")
@@ -492,7 +542,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     def decrypt(self, key: Optional[bytes] = None, pwd: Optional[str] = None, path: OPLike = None, folder: OPLike = None, name: Optional[str]= None, verbose: bool = True, suffix: str = ".enc", inplace: bool = False) -> 'P':
         slf = self.expanduser().resolve()
         path = self._resolve_path(folder=folder, name=name, path=path, default_name=slf.name.replace(suffix, "") if suffix in slf.name else "decrypted_" + slf.name)
-        path.write_bytes(data=decrypt(token=slf.read_bytes(), key=key, pwd=pwd))
+        path.write_bytes(decrypt(token=slf.read_bytes(), key=key, pwd=pwd))
         return self._return(path, operation="delete", verbose=verbose, msg=f"🔓🔑 DECRYPTED: {repr(slf)} ==> {repr(path)}.", inplace=inplace)
     def zip_n_encrypt(self, key: Optional[bytes] = None, pwd: Optional[str] = None, inplace: bool = False, verbose: bool = True, orig: bool = False, content: bool = False) -> 'P':
         return self.zip(inplace=inplace, verbose=verbose, content=content).encrypt(key=key, pwd=pwd, verbose=verbose, inplace=True) if not orig else self
@@ -502,12 +552,13 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         if path is not None:
             path = P(self.joinpath(path).resolve() if rel2it else path).expanduser().resolve()
             assert folder is None and name is None, "If `path` is passed, `folder` and `name` cannot be passed."
+            assert isinstance(path, P), "path should be a P object at this point"
             assert not path.is_dir(), f"`path` passed is a directory! it must not be that. If this is meant, pass it with `folder` kwarg. `{path}`"
             return path
         name, folder = (default_name if name is None else str(name)), (self.parent if folder is None else folder)  # good for edge cases of path with single part.  # means same directory, just different name
         return P(self.joinpath(folder).resolve() if rel2it else folder).expanduser().resolve() / name
 
-    def get_remote_path(self, root: Optional[str], os_specific: bool = False, rel2home: bool = True, strict: bool = True, obfuscate: bool = False) -> 'P':
+    def get_remote_path(self, root: Optional[str], os_specific: bool = False, rel2home: bool = True, strict: bool = True) -> 'P':
         import platform
         tmp1: str = (platform.system().lower() if os_specific else 'generic_os')
         if not rel2home: path = self
@@ -516,10 +567,10 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             except ValueError as ve:
                 if strict: raise ve
                 path = self
-        if obfuscate:
-            from crocodile.msc.obfuscater import obfuscate as obfuscate_func
-            name = obfuscate_func(seed=P.home().joinpath('dotfiles/creds/data/obfuscation_seed').read_text().rstrip(), data=path.name)
-            path = path.with_name(name=name)
+        # if obfuscate:
+        #     msc.obfuscater import obfuscate as obfuscate_func
+        #     name = obfuscate_func(seed=P.home().joinpath('dotfiles/creds/data/obfuscation_seed').read_text(encoding="utf-8").rstrip(), data=path.name)
+        #     path = path.with_name(name=name)
         if isinstance(root, str):  # the following is to avoid the confusing behaviour of A.joinpath(B) if B is absolute.
             part1 = path.parts[0]
             if part1 == "/": sanitized_path = path[1:].as_posix()
@@ -528,7 +579,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         return tmp1 / path
     def to_cloud(self, cloud: str, remotepath: OPLike = None, zip: bool = False,encrypt: bool = False,  # pylint: disable=W0621, W0622
                  key: Optional[bytes] = None, pwd: Optional[str] = None, rel2home: bool = False, strict: bool = True,
-                 obfuscate: bool = False,
+                #  obfuscate: bool = False,
                  share: bool = False, verbose: bool = True, os_specific: bool = False, transfers: int = 10, root: Optional[str] = "myhome") -> 'P':
         to_del = []
         localpath = self.expanduser().absolute() if not self.exists() else self
@@ -539,10 +590,10 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             localpath = localpath.encrypt(key=key, pwd=pwd, inplace=False)
             to_del.append(localpath)
         if remotepath is None:
-            rp = localpath.get_remote_path(root=root, os_specific=os_specific, rel2home=rel2home, strict=strict, obfuscate=obfuscate)  # if rel2home else (P(root) / localpath if root is not None else localpath)
+            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 = P(remotepath)
         rclone_cmd = f"""rclone copyto '{localpath.as_posix()}' '{cloud}:{rp.as_posix()}' {'--progress' if verbose else ''} --transfers={transfers}"""
-        from crocodile.meta import Terminal
+        from machineconfig.utils.terminal import Terminal
         if verbose: print(f"{'⬆️'*5} UPLOADING with `{rclone_cmd}`")
         shell_to_use = "powershell" if sys.platform == "win32" else "bash"
         res = Terminal(stdout=None if verbose else subprocess.PIPE).run(rclone_cmd, shell=shell_to_use).capture()
@@ -559,7 +610,8 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 raise RuntimeError(f"💥 Could not get link for {self}.")
             else:
                 res.print_if_unsuccessful(desc="Cloud Storage Operation", strict_err=True, strict_returncode=True)
-            return tmp
+            link_p: 'P' = P(str(tmp))
+            return link_p
         return self
     def from_cloud(self, cloud: str, remotepath: OPLike = None, decrypt: bool = False, unzip: bool = False,  # type: ignore  # pylint: disable=W0621
                    key: Optional[bytes] = None, pwd: Optional[str] = None, rel2home: bool = False, os_specific: bool = False, strict: bool = True,
@@ -573,7 +625,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         localpath += ".zip" if unzip else ""
         localpath += ".enc" if decrypt else ""
         rclone_cmd = f"""rclone copyto '{cloud}:{remotepath.as_posix()}' '{localpath.as_posix()}' {'--progress' if verbose else ''} --transfers={transfers}"""
-        from crocodile.meta import Terminal
+        from machineconfig.utils.terminal import Terminal
         if verbose: print(f"{'⬇️' * 5} DOWNLOADING with `{rclone_cmd}`")
         shell_to_use = "powershell" if sys.platform == "win32" else "bash"
         res = Terminal(stdout=None if verbose else subprocess.PIPE).run(rclone_cmd, shell=shell_to_use)
@@ -597,7 +649,7 @@ class P(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             rclone_cmd = f"""rclone sync '{source}' '{target}' """
         rclone_cmd += f" --progress --transfers={transfers} --verbose"
         rclone_cmd += (" --delete-during" if delete else "")
-        from crocodile.meta import Terminal
+        from machineconfig.utils.terminal import Terminal
         if verbose : print(rclone_cmd)
         shell_to_use = "powershell" if sys.platform == "win32" else "bash"
         res = Terminal(stdout=None if verbose else subprocess.PIPE).run(rclone_cmd, shell=shell_to_use)