abstract-utilities 0.2.2.492__py3-none-any.whl → 0.2.2.495__py3-none-any.whl

abstract_utilities/import_utils/src/package_utils/__init__.py

@@ -0,0 +1,139 @@
+import ast
+from pathlib import Path
+from importlib.util import find_spec
+from typing import Dict, Set
+import ast, sys
+from pathlib import Path
+from importlib.util import find_spec
+from typing import Dict, Set
+from src.abstract_utilities.import_utils import *
+STDLIB_NAMES = set(sys.builtin_module_names)
+def parse_imports(file_path: Path):
+    """Return list of (module, level) for every import/from-import."""
+    try:
+        src = file_path.read_text(errors="ignore")
+        tree = ast.parse(src, filename=str(file_path))
+    except Exception:
+        return []
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append((alias.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            imports.append((node.module, node.level))
+    return imports
+
+
+def resolve_relative_import(base_file: Path, module: str | None, level: int) -> Path | None:
+    """Follow a relative import path to its real file if it exists."""
+    base = base_file.parent
+    for _ in range(level - 1):
+        base = base.parent
+    if not module:
+        target = base
+    else:
+        target = base / module.replace(".", "/")
+    if (target / "__init__.py").exists():
+        return target / "__init__.py"
+    if target.with_suffix(".py").exists():
+        return target.with_suffix(".py")
+    return None
+
+
+
+
+def classify_import(mod_name: str, root_pkg: str) -> str:
+    """Return 'local', 'internal', or 'external'."""
+    if not mod_name:
+        return "unknown"
+    if mod_name.startswith("."):
+        return "local"
+    if mod_name.split(".")[0] == root_pkg:
+        return "internal"
+    if mod_name.split(".")[0] in STDLIB_NAMES:
+        return "stdlib"
+    return "external"
+
+
+def follow_imports(entry: Path, root_pkg: str,
+                   visited: Dict[Path, Dict[str, Set[str]]] | None = None):
+    """
+    Recursively follow only internal/local imports.
+    Returns {file_path: {'internal': set(), 'external': set()}}
+    """
+    visited = visited or {}
+    if entry in visited:
+        return visited
+
+    visited[entry] = {"internal": set(), "external": set()}
+
+    for mod, level in parse_imports(entry):
+        if level > 0:
+            target = resolve_relative_import(entry, mod, level)
+            if target:
+                visited[entry]["internal"].add(str(target))
+                follow_imports(target, root_pkg, visited)
+            continue
+
+        category = classify_import(mod, root_pkg)
+        if category == "internal":
+            spec = find_spec(mod)
+            if spec and spec.origin and spec.origin.endswith(".py"):
+                visited[entry]["internal"].add(spec.origin)
+                follow_imports(Path(spec.origin), root_pkg, visited)
+        elif category == "external":
+            visited[entry]["external"].add(mod)
+        elif category == "stdlib":
+            # stdlib gets treated like external but labeled
+            visited[entry]["external"].add(mod + "  # stdlib")
+
+    return visited
+
+
+
+def build_master_imports(entry: Path, root_pkg: str, output: Path):
+    trace = follow_imports(entry, root_pkg)
+    lines = ["# Auto-generated master imports for abstract_utilities\n"]
+    all_modules = set()
+    external_modules = set()
+    imports = get_all_imports(path)
+    for _, data in trace.items():
+        for dep in data["internal"]:
+            path = Path(dep)
+            if path.suffix != ".py":
+                continue
+            try:
+                rel_parts = path.with_suffix("").parts
+                idx = rel_parts.index(root_pkg)
+                dotted = ".".join(rel_parts[idx:])
+                all_modules.add(dotted)
+            except ValueError:
+                continue
+        external_modules.update(data["external"])
+
+    for mod in sorted(all_modules):
+        short = mod.split(".", 1)[-1]
+        lines.append(f"from .{short} import *")
+
+    if external_modules:
+        lines.append("\n# External / stdlib imports (not traced, for reference)")
+        for ext in sorted(external_modules):
+            lines.append(f"# {ext}")
+    
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text("\n".join(lines+str(imports)))
+    print(f"✅ wrote master imports hub → {output}")
+
+
+
+if __name__ == "__main__":
+    entry = Path(
+        "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/"
+        "abstract_utilities/import_utils/src/import_functions.py"
+    )
+
+    
+    pkg = "abstract_utilities"
+    out = entry.parents[4] / "imports" / "__init__.py"
+    build_master_imports(entry, pkg, out)

abstract_utilities/import_utils/src/package_utils/context_utils.py

@@ -0,0 +1,27 @@
+import sys, os
+from pathlib import Path
+from .path_utils import find_top_package_dir, derive_package_for_file
+
+def ensure_package_context(file: str):
+    """Ensure that running this file directly gives correct package context."""
+    file = file or os.getcwd()
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_package_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py files up the tree.")
+
+    sysroot = top_pkg_dir.parent
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])
+    if (__name__ == "__main__") and not globals().get("__package__"):
+        globals()["__package__"] = pkg_name
+
+def ensure_caller_package(caller_file: str, caller_globals: dict | None = None) -> str:
+    """Ensure sysroot is on sys.path and return caller's dotted package name."""
+    pkg, _ = derive_package_for_file(caller_file)
+    if caller_globals and caller_globals.get("__name__") == "__main__" and not caller_globals.get("__package__"):
+        caller_globals["__package__"] = pkg
+    return pkg

abstract_utilities/import_utils/src/package_utils/import_collectors.py

@@ -0,0 +1,53 @@
+from ..imports import *
+from .import_functions import *
+
+def ensure_import_pkg_js(import_pkg_js=None, file_path=None):
+    import_pkg_js = import_pkg_js or {"context": {}}
+    if "context" not in import_pkg_js:
+        import_pkg_js["context"] = {}
+    for key in ["nulines", "file_path", "all_data"]:
+        import_pkg_js["context"].setdefault(key, [] if key != "file_path" else None)
+
+    if file_path and file_path != import_pkg_js["context"].get("file_path"):
+        found = False
+        nu_data = {
+            "file_path": import_pkg_js["context"]["file_path"],
+            "nulines": import_pkg_js["context"]["nulines"]
+        }
+        for i, data in enumerate(import_pkg_js["context"]["all_data"]):
+            if data.get("file_path") == import_pkg_js["context"]["file_path"]:
+                import_pkg_js["context"]["all_data"][i] = nu_data
+                found = True
+                break
+        if not found:
+            import_pkg_js["context"]["all_data"].append(nu_data)
+        import_pkg_js["context"]["nulines"] = []
+        import_pkg_js["context"]["file_path"] = file_path
+    return import_pkg_js
+
+def add_imports_to_import_pkg_js(import_pkg, imports, import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    imports = clean_imports(imports)
+    if import_pkg not in import_pkg_js:
+        i = len(import_pkg_js["context"]["nulines"])
+        file_path = import_pkg_js["context"]["file_path"]
+        file_parts = get_file_parts(file_path)
+        dirname = file_parts["dirname"]
+        import_pkg_js[import_pkg] = {"imports": imports, "line": i}
+        import_pkg_js["context"]["nulines"].append(f"from {import_pkg} import ")
+    else:
+        import_pkg_js[import_pkg]["imports"] += imports
+    return import_pkg_js
+
+def update_import_pkg_js(line, import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    if is_line_group_import(line):
+        import_pkg = get_import_pkg(line)
+        imports = get_imports_from_import_pkg(line)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg, imports, import_pkg_js=import_pkg_js)
+    else:
+        if import_pkg_js["context"]["nulines"] and line == "" and is_line_import(import_pkg_js["context"]["nulines"][-1]):
+            pass
+        else:
+            import_pkg_js["context"]["nulines"].append(line)
+    return import_pkg_js

abstract_utilities/import_utils/src/package_utils/path_utils.py

@@ -0,0 +1,28 @@
+import os, sys
+from pathlib import Path
+
+def find_top_package_dir(p: Path) -> Path | None:
+    """Walk upward until the topmost __init__.py-containing directory."""
+    p = p.resolve()
+    if p.is_file():
+        p = p.parent
+    top = None
+    while (p / "__init__.py").exists():
+        top = p
+        if p.parent == p:
+            break
+        p = p.parent
+    return top
+
+def derive_package_for_file(file: str) -> tuple[str, Path]:
+    """Return (pkg_name, sysroot) for the module file."""
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_package_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py up the tree.")
+    sysroot = top_pkg_dir.parent
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])
+    return pkg_name, sysroot

abstract_utilities/import_utils/src/package_utils/safe_import.py

@@ -0,0 +1,27 @@
+import inspect, importlib
+from .context_utils import ensure_caller_package
+
+def safe_import(
+    name: str,
+    *,
+    member: str | None = None,
+    package: str | None = None,
+    file: str | None = None,
+    caller_globals: dict | None = None,
+):
+    """
+    Safe dynamic import that resolves relative imports when run as a script.
+    """
+    if file is None:
+        frame = inspect.currentframe()
+        assert frame is not None
+        outer = frame.f_back
+        caller_file = (outer.f_globals.get("__file__") if outer else None) or __file__
+    else:
+        caller_file = file
+
+    if name.startswith(".") and not package:
+        package = ensure_caller_package(caller_file, caller_globals=caller_globals)
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod

abstract_utilities/import_utils/src/package_utils.py

@@ -0,0 +1,140 @@
+# safe_import_utils.py
+from ..imports import *
+from .import_functions import *
+
+def ensure_import_pkg_js(import_pkg_js,file_path=None):
+    import_pkg_js = import_pkg_js or {"context":{}}
+    if "context" not in import_pkg_js:
+        import_pkg_js["context"]={}
+    for key in ["nulines","file_path","all_data"]:
+        if key not in import_pkg_js["context"]:
+            import_pkg_js["context"][key]=[]
+    if file_path and file_path != import_pkg_js["context"]["file_path"]:
+        found=False
+        nu_data = {"file_path":import_pkg_js["context"]["file_path"],"nulines":import_pkg_js["context"]["nulines"]}
+        for i,data in enumerate(import_pkg_js["context"]["all_data"]):
+            if data.get('file_path') == import_pkg_js["context"]["file_path"]:
+                import_pkg_js["context"]["all_data"][i] = nu_data
+                found = True
+                break
+        if found == False:
+            import_pkg_js["context"]["all_data"].append(nu_data)
+        import_pkg_js["context"]["nulines"]=[]
+        import_pkg_js["context"]["file_path"]=file_path
+    return import_pkg_js
+def ensure_package_context(file: str):
+    """
+    Ensure that running this file directly still gives it the correct package.
+    Sets sys.path and __package__ based on the __init__.py chain.
+    """
+    file = file or os.getcwd()
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_pkg_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py files up the tree.")
+
+    sysroot = top_pkg_dir.parent  # dir ABOVE the top package (e.g., .../src)
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+
+    # Compute this module's package (exclude the filename)
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])  # e.g. abstract_ide.consoles.launcherWindowTab
+
+    # When run as a script, __package__ is empty -> set it
+    if (__name__ == "__main__") and (not globals().get("__package__")):
+        globals()["__package__"] = pkg_name
+# --- tiny utils ---
+def find_top_package_dir(p: Path) -> Path | None:
+    p = p.resolve()
+    if p.is_file():
+        p = p.parent
+    top = None
+    while (p / "__init__.py").exists():
+        top = p
+        if p.parent == p:
+            break
+        p = p.parent
+    return top
+
+def derive_package_for_file(file: str) -> tuple[str, Path]:
+    """Return (pkg_name, sysroot) for the module file."""
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_pkg_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py up the tree.")
+    sysroot = top_pkg_dir.parent
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])  # package of the module (drop the filename)
+    return pkg_name, sysroot
+
+def ensure_caller_package(caller_file: str, caller_globals: dict | None = None) -> str:
+    """
+    Ensure sysroot is on sys.path and return the caller's dotted package.
+    Optionally set caller_globals['__package__'] when running as a script.
+    """
+    pkg, _ = derive_package_for_file(caller_file)
+    if caller_globals and caller_globals.get("__name__") == "__main__" and not caller_globals.get("__package__"):
+        caller_globals["__package__"] = pkg
+    return pkg
+def get_import_pkg(line):
+    if is_line_group_import(line):
+        return clean_line(line.split(FROM_TAG)[1].split(IMPORT_TAG)[0])
+def get_imports_from_import_pkg(line):
+    if is_line_group_import(line):
+        return get_cleaned_import_list(line,commaClean=True)
+def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    imports = clean_imports(imports)
+    if import_pkg not in import_pkg_js:
+        i = len(import_pkg_js["context"]["nulines"])
+        import_pkg_js[import_pkg]={"imports":imports,"line":i}
+        import_line = f"from {import_pkg} import "
+        if import_pkg == "import":
+            import_line = IMPORT_TAG
+        import_pkg_js["context"]["nulines"].append(import_line)
+    else:
+        import_pkg_js[import_pkg]["imports"]+=imports
+    return import_pkg_js
+def update_import_pkg_js(line,import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    if is_line_group_import(line):
+        import_pkg = get_import_pkg(line)
+        imports = get_imports_from_import_pkg(line)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=import_pkg_js)
+    else:
+        if len(import_pkg_js["context"]["nulines"]) >0 and line == '' and is_line_import(import_pkg_js["context"]["nulines"][-1]):
+            pass
+        else:
+            import_pkg_js["context"]["nulines"].append(line)
+    return import_pkg_js
+# --- public API ---
+def safe_import(
+    name: str,
+    *,
+    member: str | None = None,
+    package: str | None = None,
+    file: str | None = None,
+    caller_globals: dict | None = None,
+):
+    """
+    Import `name` (relative or absolute).
+    - If `name` is relative and `package` is missing, derive it from `file` (or caller).
+    - If running the caller as a script, we can set its __package__ when caller_globals is provided.
+    """
+    if file is None:
+        # best-effort: use the immediate caller's file
+        frame = inspect.currentframe()
+        assert frame is not None
+        outer = frame.f_back
+        caller_file = (outer.f_globals.get("__file__") if outer else None) or __file__
+    else:
+        caller_file = file
+
+    if name.startswith(".") and not package:
+        package = ensure_caller_package(caller_file, caller_globals=caller_globals)
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod

abstract_utilities/import_utils/src/sysroot_utils.py

@@ -0,0 +1,57 @@
+from ..imports import *
+from .dot_utils import *
+
+def ensure_on_path(p: Path):
+    s = str(p)
+    if s not in sys.path:
+        sys.path.insert(0, s)
+def get_sysroot(filepath,i):
+    for j in range(i):
+        filepath = os.path.dirname(filepath)
+    return filepath
+
+def get_dot_range_sysroot(filepath):
+    sysroot = filepath
+    while True:
+        dot_range = get_dot_range(is_import_or_init(sysroot))
+        if dot_range == 0:
+            break
+        sysroot = get_sysroot(sysroot,dot_range)
+    
+    return sysroot
+
+def is_import_or_init(sysroot,likely=None):
+    file_data = get_file_parts(sysroot)
+    nuroot = sysroot
+    dirname = file_data.get('dirname')
+    if os.path.isdir(sysroot):
+        dirname = sysroot
+    ext = file_data.get('ext')
+    filename = file_data.get('filename')
+    
+    candidates = []
+    if likely:
+        candidates += [os.path.join(dirname,f"{likely}.py"),os.path.join(dirname,likely)]
+    candidates += [os.path.join(dirname,f"{filename}.py"),os.path.join(dirname,filename)]
+    files: List[Path] = []
+    for item in candidates:
+        
+        if os.path.exists(item):
+            if os.path.isdir(item):
+                
+                nuroot=None
+                init_name = '__init__.py'
+                rootList = os.listdir(item)
+                for basename in rootList:
+                    if get_file_parts(basename,'filename') == filename:
+                        nuroot = os.path.join(item,basename)
+                        break
+                if init_name in rootList:
+                    nuroot = os.path.join(item,init_name)
+                    break
+                    
+            else:
+               nuroot=sysroot
+               break
+
+    return nuroot

abstract_utilities/path_utils.py

@@ -23,7 +23,6 @@ Date: 05/31/2023
 Version: 0.1.2
 """
 import os
-from .read_write_utils import read_from_file,write_to_file
 from .string_clean import eatAll
 from .list_utils import make_list
 from .type_utils import get_media_exts, is_media_type,MIME_TYPES
@@ -540,8 +539,6 @@ def get_all_items(directory):
     file_list = [item for item in dir_list if is_path(directory,item)]
     return file_list
 
-def collate_text_docs(directory=None):
-    return [read_from_file(item) for item in get_all_files(directory=directory)]
 
 def get_dirlist(directory):
     path = get_directory(directory)
@@ -553,15 +550,7 @@ def get_dirlist(directory):
     elif is_file(path):
         dir_list = [os.path.basename(path)]
     return dir_list
-def get_content(*paths):
-    item_path = os.path.join(*paths)
-    if os.path.isfile(item_path):
-        try:
-            content = read_from_file(item_path)
-            return content
-        except:
-            pass
-    return None
+
 
 def is_directory_in_paths(path,directory):
     return directory in path 

abstract_utilities/read_write_utils.py

@@ -16,10 +16,10 @@ import os
 import shlex
 from .string_clean import *
 from .ssh_utils.utils import run_cmd,get_print_sudo_cmd,run_local_cmd,run_remote_cmd
-from .file_utils.file_utils.type_checks import is_file,is_dir,get_user_pass_host_key,is_exists
+from .file_utils import is_file,is_dir,get_user_pass_host_key,is_exists
 from .abstract_classes import run_pruned_func
 from .string_utils import get_from_kwargs
-
+from .path_utils import get_all_files
 _FILE_PATH_KEYS = ['file', 'filepath', 'file_path', 'path', 'directory', 'f', 'dst', 'dest']
 _CONTENTS_KEYS = ['cont', 'content', 'contents', 'data', 'datas', 'dat', 'src', 'source']
 
@@ -34,12 +34,12 @@ def string_in_keys(strings, kwargs):
     return None
 def make_dirs(path, exist_ok=True, **kwargs):
     remote = get_user_pass_host_key(**kwargs)
-    print(remote)
+ 
     if remote:
         kwargs['cmd'] = f"mkdir -p {path}"
-        print(kwargs)
+       
         resp = run_pruned_func(run_cmd, **kwargs)
-        print(resp)
+       
     else:
         os.makedirs(path, exist_ok=exist_ok)
     return path
@@ -53,16 +53,15 @@ def make_path(path, home_dir=None, file=None, **kwargs):
     # Detect whether this is a file or a folder
     is_file = file if file is not None else ('.' in basename)
     pieces = parts[:-1] if is_file else parts
-    print(pieces)
+  
     full_dir = home_dir or '/'
     for piece in pieces:
         full_dir = os.path.join(full_dir, piece)
         make_dirs(full_dir, exist_ok=True, **kwargs)
-        print(f"✅ full_dir == {full_dir}")
+       
     if is_file:
         full_dir = os.path.join(full_dir, basename)
 
-    print(f"✅ full_dir == {full_dir}")
     return full_dir
 def get_rel_path(src,src_rel,dst,**kwargs):
     if src.startswith(src_rel):
@@ -72,12 +71,12 @@ def get_rel_path(src,src_rel,dst,**kwargs):
         rel_path = os.path.join(dst,nu_src)
         return rel_path
 def make_relative_path(src,src_rel,dst,**kwargs):
-    print(f"src == {src}\nsrc_rel == {src_rel}\dst == {dst}")
+
     if src.startswith(src_rel):
         rel_path = get_rel_path(src,src_rel,dst)
-        print(rel_path)
+      
         path = make_path(rel_path,**kwargs)
-        print(f"path == {path}")
+      
         return path
 
 def path_join(*args):
@@ -157,7 +156,7 @@ def write_to_path(
     # shell command that fully overwrites
     # (no append, replaces contents entirely)
     base_cmd = f'sudo sh -c "echo {quoted_data} > {quoted_path}"'
-    input(base_cmd)
+
     # optional sudo password injection
     full_cmd = get_print_sudo_cmd(
         cmd=base_cmd,
@@ -250,27 +249,44 @@ def read_from_file(file_path,**kwargs):
     with open(file_path, "r", encoding="utf-8") as f:
         return f.read()
 
-def copy_dirs(dirs,dst,src_rel=None,**kwargs):
+
+def copy_dirs(dirs, dst_root, src_rel=None, **kwargs):
+    """
+    Recursively copy directory structures (without files) from dirs → dst_root.
+    """
     for src in dirs:
-        if rel_path:
-            dst = make_relative_path(src,src_rel,dst,**kwargs)
-        make_path(dst,**kwargs)
-        
-def copy_file(src,dst,rel_path=None,**kwargs):
-
-    if rel_path:
-        dst = make_relative_path(src,rel_path,dst,**kwargs)
-        print(dst)
-    if get_user_pass_host_key(**kwargs):
-        contents=read_from_file(src,**kwargs)
-        write_to_file(contents=contents,file_path=dst,**kwargs)
-    else:
-        shutil.copy(src,dst)
-    print(dst)
-    return dst
-def copy_files(files,dst,rel_path=None,**kwargs):
-    for file in files:
-        copy_file(src=file,dst=dst,rel_path=rel_path,**kwargs)
+        # build destination path preserving relative structure
+        dst_path = make_relative_path(src, src_rel, dst_root, **kwargs) if src_rel else dst_root
+        make_path(dst_path, **kwargs)  # ensures directory exists
+     
+
+
+def copy_file(src, dst_root, src_rel=None, **kwargs):
+    """
+    Copy a single file to dst_root, preserving relative structure if src_rel provided.
+    Supports remote copy via read/write.
+    """
+    # derive destination file path
+    dst_path = make_relative_path(src, src_rel, dst_root, **kwargs) if src_rel else os.path.join(dst_root, os.path.basename(src))
+    make_path(dst_path, **kwargs)
+
+    if get_user_pass_host_key(**kwargs):  # remote mode
+        contents = read_from_file(src, **kwargs)
+        write_to_file(contents=contents, file_path=dst_path, **kwargs)
+    else:  # local
+        os.makedirs(os.path.dirname(dst_path), exist_ok=True)
+        shutil.copy2(src, dst_path)
+
+
+    return dst_path
+
+
+def copy_files(files, dst_root, src_rel=None, **kwargs):
+    """
+    Copy a list of files to dst_root.
+    """
+    for src in files:
+        copy_file(src=src, dst_root=dst_root, src_rel=src_rel, **kwargs)
 
 def create_and_read_file(*args, **kwargs):
     """
@@ -309,3 +325,21 @@ def get_content_lines(*args, **kwargs):
     elif isinstance(contents, list):
         return contents
     return []
+def collate_text_docs(directory=None):
+    return [read_from_file(item) for item in get_all_files(directory=directory)]
+def get_content(*paths):
+    item_path = os.path.join(*paths)
+    if os.path.isfile(item_path):
+        try:
+            content = read_from_file(item_path)
+            return content
+        except:
+            pass
+    return None
+def get_text_or_read(text=None,file_path=None):
+    text = text or ''
+    imports_js = {}
+    if not text and file_path and os.path.isfile(file_path):
+        text=read_from_file(file_path)
+    return text
+##

{abstract_utilities-0.2.2.492.dist-info → abstract_utilities-0.2.2.495.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.492
+Version: 0.2.2.495
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff