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

abstract_utilities/import_utils/circular_import_finder2.py

@@ -0,0 +1,118 @@
+from abstract_utilities import *
+import os
+from collections import defaultdict
+
+def get_path_or_init(pkg_info):
+    root_dirname = pkg_info.get("root_dirname")
+    pkg = pkg_info.get("pkg")
+    rel_path = pkg.replace('.', '/')
+    dirname = os.path.dirname(root_dirname)
+    pkg_path = os.path.join(dirname, rel_path)
+    pkg_py_path = f"{pkg_path}.py"
+    if os.path.isfile(pkg_py_path):
+        return pkg_py_path
+    pkg_init_path = os.path.join(pkg_path, '__init__.py')
+    if os.path.isdir(pkg_path) and os.path.isfile(pkg_init_path):
+        return pkg_init_path
+    # optional: silence instead of blocking input()
+    print(f"⚠️ not found == {pkg_info}")
+    return None
+
+
+def get_dot_fro_line(line, dirname=None, file_path=None, get_info=False):
+    info_js = {"nuline": line, "og_line": line, "pkg": line, "dirname": dirname,
+               "file_path": file_path, "root_dirname": None, "local": False}
+    if dirname and is_file(dirname):
+        file_path = dirname
+        dirname = os.path.dirname(dirname)
+        info_js["file_path"] = file_path
+        info_js["dirname"] = dirname
+
+    from_line = line.split(FROM_TAG)[-1]
+    dot_fro = ""
+    for char in from_line:
+        if char != '.':
+            pkg = f"{dot_fro}{eatAll(from_line, '.')}"
+            nuline = f"from {pkg}"
+            info_js["nuline"] = nuline
+            info_js["pkg"] = pkg
+            break
+        if dirname:
+            info_js["root_dirname"] = dirname
+            dirbase = os.path.basename(dirname)
+            dirname = os.path.dirname(dirname)
+            dot_fro = f"{dirbase}.{dot_fro}"
+
+    if get_info:
+        if dot_fro and os.path.isdir(info_js.get("root_dirname") or ""):
+            info_js["local"] = True
+            info_js["pkg_path"] = get_path_or_init(info_js)
+        return info_js
+    return line
+
+
+def return_local_imps(file_path):
+    local_imps = []
+    dirname = os.path.dirname(file_path)
+    imports_js = get_all_imports(file_path)
+    for pkg, imps in imports_js.items():
+        if pkg not in ['context', 'nulines']:
+            full_imp_info = get_dot_fro_line(pkg, dirname, file_path=file_path, get_info=True)
+            if full_imp_info.get("local"):
+                local_imps.append(full_imp_info)
+    return local_imps
+
+
+def get_all_pkg_paths(file_path):
+    pkg_paths = []
+    local_imps = return_local_imps(file_path)
+    for local_imp in local_imps:
+        pkg_path = local_imp.get('pkg_path')
+        if pkg_path:
+            pkg_paths.append(pkg_path)
+    return pkg_paths
+
+
+# --- NEW: Build dependency graph and detect circular imports ---
+
+def build_graph(main_directory):
+    dirs, all_local_scripts = get_files_and_dirs(main_directory, allowd_exts='.py', files_only=True)
+    graph = defaultdict(set)
+    for file_path in all_local_scripts:
+        deps = get_all_pkg_paths(file_path)
+        for dep in deps:
+            if dep:  # only valid files
+                graph[file_path].add(dep)
+    return graph
+
+
+def find_cycles(graph):
+    visited, stack, cycles = set(), [], []
+
+    def dfs(node, path):
+        visited.add(node)
+        path.append(node)
+        for dep in graph.get(node, []):
+            if dep not in visited:
+                dfs(dep, path.copy())
+            elif dep in path:
+                cycle_start = path.index(dep)
+                cycles.append(path[cycle_start:] + [dep])
+
+    for node in graph:
+        if node not in visited:
+            dfs(node, [])
+    return cycles
+
+
+if __name__ == "__main__":
+    main_directory = "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/abstract_utilities"
+    graph = build_graph(main_directory)
+    cycles = find_cycles(graph)
+
+    if not cycles:
+        print("✅ No circular imports found.")
+    else:
+        print("❌ Circular imports detected:")
+        for cycle in cycles:
+            print(" → ".join(cycle))

abstract_utilities/import_utils/imports/__init__.py

@@ -0,0 +1,4 @@
+from .imports import *
+from .module_imports import *
+from .constants import *
+from .utils import *

abstract_utilities/import_utils/imports/constants.py

@@ -0,0 +1,2 @@
+IMPORT_TAG = 'import '
+FROM_TAG = 'from '

abstract_utilities/import_utils/imports/imports.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+from typing import *
+from types import MethodType
+from ...imports import os, sys, importlib, os, inspect, re, hashlib

abstract_utilities/import_utils/imports/module_imports.py

@@ -0,0 +1,8 @@
+from ...read_write_utils import read_from_file,write_to_file,get_text_or_read
+from ...string_utils import eatAll,eatInner,eatElse,clean_line
+from ...class_utils import get_caller_path,get_caller_dir,if_none_default,get_initial_caller_dir
+from ...list_utils import make_list
+from ...path_utils import get_file_parts
+from ...type_utils  import is_number,make_list
+from ...file_utils  import collect_filepaths,collect_globs
+from ...directory_utils import get_shortest_path,get_common_root

abstract_utilities/import_utils/imports/utils.py

@@ -0,0 +1,30 @@
+import os
+from .constants import *
+
+def is_line_import(line):
+    if line and (line.startswith(FROM_TAG) or line.startswith(IMPORT_TAG)):
+        return True
+    return False
+def is_line_group_import(line):
+    if line and (line.startswith(FROM_TAG) and IMPORT_TAG in line):
+        return True
+    return False
+
+def is_from_line_group(line):
+    if line and line.startswith(FROM_TAG) and IMPORT_TAG in line and '(' in line:
+        import_spl = line.split(IMPORT_TAG)[-1]
+        import_spl_clean = clean_line(line)
+        if not import_spl_clean.endswith(')'):
+            return True
+    return False
+def get_unique_name(string,list_obj):
+    if isinstance(list_obj,dict):
+        list_obj = list(list_obj.keys())
+    if string in list_obj:
+        nustring = f"{string}"
+        for i in range(len(list_obj)):
+            nustring = f"{string}_{i}"
+            if nustring not in list_obj:
+                break
+        string = nustring
+    return string

abstract_utilities/import_utils/src/__init__.py

@@ -0,0 +1,7 @@
+from .clean_imports import *
+from .dot_utils import *
+from .extract_utils import *
+from .import_utils import *
+from .import_functions import *
+from .pkg_utils import *
+from .sysroot_utils import *

abstract_utilities/import_utils/src/clean_imports.py

@@ -0,0 +1,278 @@
+from ..imports import *
+from .pkg_utils import *
+from ...safe_utils import *
+def is_local_import(line):
+    print(line)
+    imports_from_import_pkg = clean_imports(line)
+    input(imports_from_import_pkg)
+def try_is_file(file_path):
+    try:
+        return os.path.isfile(file_path)
+    except:
+        return False
+def try_is_dir(file_path):
+    try:
+        return os.path.isdir(file_path)
+    except:
+        return False
+def try_join(*args):
+    try:
+        return safe_join(*args)
+    except:
+        return False
+def get_pkg_or_init(pkg_path):
+    if pkg_path:
+        if try_is_file(pkg_path):
+            return pkg_path
+        pkg_py_path = f"{pkg_path}.py"
+        if try_is_file(pkg_py_path):
+            return pkg_py_path
+        pkg_init_path = try_join(pkg_path,'__init__.py')
+        if try_is_dir(pkg_path):
+            if os.path.isfile(pkg_init_path):
+                return pkg_init_path
+def get_text_and_file_and_js(text=None,file_path=None,import_pkg_js=None):
+    inputs = {"text":text,"file_path":file_path,"import_pkg_js":import_pkg_js}
+    for key,value in inputs.items():
+        if value:
+            if isinstance(value,str):
+                _file_path = get_pkg_or_init(file_path)
+                if _file_path:
+                    file_path=_file_path
+                    if key == "text" or text == None:
+                        text=read_from_file(file_path)
+                if isinstance(value,dict):
+                    if key in ["text","file_path"]:
+                        if key == "text":
+                            text = None
+                        if key == "file_path":
+                            file_path = None
+                    import_pkg_js=value
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
+    return text,file_path,import_pkg_js
+def get_text_or_read(text=None,file_path=None):
+    file_path = get_pkg_or_init(file_path)
+    if not text and file_path:
+        text=read_from_file(file_path)
+    if text and not file_path:
+        file_path=get_pkg_or_init(text)
+        if file_path:
+            text = None
+    return text,file_path 
+def is_line_import(line):
+    if line and (line.startswith(FROM_TAG) or line.startswith(IMPORT_TAG)):
+        return True
+    return False
+def is_line_group_import(line):
+    if line and (line.startswith(FROM_TAG) and IMPORT_TAG in line):
+        return True
+    return False
+
+def is_from_line_group(line):
+    if line and line.startswith(FROM_TAG) and IMPORT_TAG in line and '(' in line:
+        import_spl = line.split(IMPORT_TAG)[-1]
+        import_spl_clean = clean_line(line)
+        if not import_spl_clean.endswith(')'):
+            return True
+    return False
+
+def get_all_imports(text=None,file_path=None,import_pkg_js=None):
+    text,file_path = get_text_or_read(text=text,file_path=file_path)
+    lines = text.split('\n')
+    cleaned_import_list=[]
+    nu_lines = []
+    is_from_group = False
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
+    for line in lines:
+        
+        if line.startswith(IMPORT_TAG) and ' from ' not in line:
+            
+            cleaned_import_list = get_cleaned_import_list(line)
+            import_pkg_js = add_imports_to_import_pkg_js("import",cleaned_import_list,import_pkg_js=import_pkg_js,file_path=file_path)
+        else:
+            if is_from_group:
+                import_pkg=is_from_group
+                line = clean_line(line)
+                if line.endswith(')'):
+                   is_from_group=False
+                   line=line[:-1]
+                imports_from_import_pkg = clean_imports(line)
+                import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports_from_import_pkg,import_pkg_js=import_pkg_js,file_path=file_path)
+                
+            else:
+                import_pkg_js=update_import_pkg_js(line,import_pkg_js=import_pkg_js,file_path=file_path)
+            if is_from_line_group(line) and is_from_group == False:
+                is_from_group=get_import_pkg(line)
+    return import_pkg_js
+
+def get_clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    text,file_path,_ = get_text_and_file_and_js(text=text,file_path=file_path,import_pkg_js=import_pkg_js)   
+    if not import_pkg_js:
+        import_pkg_js = get_all_imports(text=text,file_path=file_path)
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
+    nu_lines = import_pkg_js["context"]["nulines"]
+    for pkg,values in import_pkg_js.items():
+        comments = []
+        if pkg not in ["context"]: 
+            
+            imports = values.get('imports')
+            for i,imp in enumerate(imports):
+                if '#' in imp:
+                    imp_spl = imp.split('#')
+                    comments.append(imp_spl[-1])
+                    imports[i] = clean_line(imp_spl[0])
+            imports = list(set(imports))   
+            if '*' in imports:
+                imports="*"
+            else:
+                imports=','.join(imports)
+                if comments:
+                    comments=','.join(comments)
+                    imports+=f" #{comments}"
+            import_pkg_js[pkg]["imports"]=imports
+            if fill_nulines:
+                line = values.get('line')
+                if len(nu_lines) >= line:
+                    nu_lines[line] += imports
+    return import_pkg_js
+def clean_all_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    import_pkg_js = get_clean_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js,fill_nulines=import_pkg_js)
+    import_pkg_js["context"]["nulines"]=import_pkg_js["context"]["nulines"]
+    return import_pkg_js
+def get_clean_import_string(import_pkg_js,fill_nulines=False,get_locals=False):
+    import_pkg_js = get_clean_imports(import_pkg_js=import_pkg_js,fill_nulines=fill_nulines)
+    import_ls = []
+    for key,values in import_pkg_js.items():
+        if key not in ['context','nulines']:
+            imports = None
+            imp_values= values.get('imports')
+            if key == 'import':
+                imports = f'import {imp_values}'
+            elif get_locals or not key.startswith('.'):
+                imports = f'from {key} import {imp_values}'
+            if imports:
+                import_ls.append(imports)
+    return '\n'.join(import_ls)
+def get_clean_imports_from_files(files):
+    import_pkg_js={}
+    for file in files:
+        import_pkg_js = get_all_imports(file,import_pkg_js=import_pkg_js)
+    return get_clean_import_string(import_pkg_js)
+def get_dot_fro_line(line,dirname):
+    from_line = line.split(FROM_TAG)[-1]
+    dot_fro = ""
+    for char in from_line:
+        if  char != '.':
+            line = f"from {dot_fro}{eatAll(from_line,'.')}"
+            break
+        dirname = os.path.dirname(dirname)
+        dirbase = os.path.basename(dirname)
+        dot_fro = f"{dirbase}.{dot_fro}"
+    return line
+def get_dot_fro_lines(lines,file_path,all_imps):
+    for line in lines:
+        if line.startswith(FROM_TAG):
+            line = get_dot_fro_line(line,file_path)
+            if line in all_imps:
+                line = ""
+        if line:
+            all_imps.append(line)
+    return all_imps
+def get_all_real_imps(text=None,file_path=None,all_imps=None):
+  
+    all_imps = all_imps or []
+    text,file_path = get_text_or_read(text=text,file_path=file_path)
+    lines = text.split('\n')
+    all_imps = get_dot_fro_lines(lines,file_path,all_imps)
+    return '\n'.join(all_imps)
+def save_cleaned_imports(text=None,file_path=None,write=False,import_pkg_js=None):
+    text,file_path,import_pkg_js = get_text_and_file_and_js(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    import_pkg_js = clean_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    contents = '\n'.join(import_pkg_js["context"]["nulines"])
+    if file_path and write:
+        write_to_file(contents=contents,file_path=file_path)
+    return contents
+def convert_to_sysroot_relative(import_pkg, file_path, sysroot):
+    """
+    Convert an absolute package import into a dotted relative import based on
+    the file's depth inside sysroot.
+    """
+
+    if not sysroot:
+        return import_pkg  # no conversion
+
+    file_path = os.path.abspath(file_path)
+    sysroot = os.path.abspath(sysroot)
+
+    # Ignore imports outside sysroot
+    file_dir = os.path.dirname(file_path)
+    if not file_dir.startswith(sysroot):
+        return import_pkg
+
+    # Compute how many directories deep the file is
+    rel = os.path.relpath(file_dir, sysroot)
+    depth = 0 if rel == "." else len(rel.split(os.sep))
+
+    # Depth N means N dots (i.e. N relative levels)
+    dots = "." * depth
+
+    return f"{dots}{import_pkg}"
+
+import os
+
+def rewrite_import_with_sysroot(line, file_path, sysroot):
+    """
+    Rewrite imports like:
+        from imports.constants import *
+    into:
+        from <relative_path>.imports.constants import *
+    Where <relative_path> is computed relative to sysroot.
+    """
+
+    line = line.rstrip()
+    if not line.startswith("from "):
+        return line
+
+    # Split import structure
+    try:
+        after_from = line[len("from "):]
+        pkg, after_import = after_from.split(" import ", 1)
+    except ValueError:
+        return line  # Not a normal from X import Y
+
+    # Absolute paths
+    file_dir = os.path.dirname(os.path.abspath(file_path))
+    sysroot = os.path.abspath(sysroot)
+
+    # Compute relative path
+    relpath = os.path.relpath(file_dir, sysroot)
+
+    # Turn filesystem path into dotted python path
+    if relpath == ".":
+        dotted = ""
+    else:
+        dotted = ".".join(part for part in relpath.split(os.sep) if part)
+
+    # Import path you want to append the old import to
+    new_pkg = f"{dotted}.{pkg}".lstrip('.')
+
+    # Build final rewritten import
+    return f"from {new_pkg} import {after_import}"
+
+def trace_all_imports(file_path, sysroot=None):
+    import_pkg_js = {}
+    files = collect_filepaths(file_path, allowed_exts='.py', add=True)
+
+    for file in files:
+        text = get_all_real_imps(file_path=file)
+        lines = text.split("\n")
+
+        if sysroot:
+            new_lines = []
+            for line in lines:
+                new_lines.append(rewrite_import_with_sysroot(line, file, sysroot))
+            text = "\n".join(new_lines)
+
+        import_pkg_js = get_all_imports(text=text, file_path=file, import_pkg_js=import_pkg_js)
+
+    return get_clean_import_string(import_pkg_js)

abstract_utilities/import_utils/src/dot_utils.py

@@ -0,0 +1,80 @@
+from ..imports import *
+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 get_Path(path):
+    if isinstance(path,str):
+        path = Path(str(path))
+    return path
+def get_dot_range(filepath=None,list_obj=None):
+    imports = make_list(list_obj) or extract_imports(filepath)
+    highest=0
+    dots = [get_imp(fro) for fro in imports if fro]
+
+    if dots:
+        dots.sort()
+        highest = dots[0]
+    return highest
+def dotted_from(file: Path, sysroot: Path) -> str:
+    """
+    Build dotted name from sysroot (directory *above* top package)
+    e.g.  /repo/abstract_ide/consoles/launcherWindowTab/functions/core_utils.py
+        sysroot=/repo  -> abstract_ide.consoles.launcherWindowTab.functions.core_utils
+    """
+    file = get_Path(file)
+    sysroot = get_Path(sysroot)
+    file = file.resolve()
+    stem = file.with_suffix("")  # drop .py
+    return ".".join(stem.relative_to(sysroot).parts)
+def to_dotted_name(file_path: Path, top_package: str) -> str:
+    """
+    Convert .../abstract_ide/consoles/launcherWindowTab/functions/core_utils.py
+    -> abstract_ide.consoles.launcherWindowTab.functions.core_utils
+    """
+    # find the index of the top_package in the path parts
+    file_path = get_Path(file_path)
+    top_package = get_Path(top_package)
+    parts = file_path.resolve().parts
+    i = None
+    if is_number(top_package):
+        i= int(top_package)
+    if i is None:
+        try:
+            i = parts.index(top_package)
+        except ValueError:
+            raise RuntimeError(f"Cannot locate package '{top_package}' in {file_path}")
+    rel_parts = parts[i:]  # from top_package onward
+    if rel_parts[-1].endswith(".py"):
+        rel_parts = list(rel_parts)
+        rel_parts[-1] = rel_parts[-1][:-3]  # strip .py
+    return ".".join(rel_parts)
+def compute_dotted_and_sysroot(file_path: Path) -> Tuple[str, Path]:
+    """
+    If inside packages, build dotted name from the top package down.
+    sysroot will be the directory *above* the top package.
+    If not a package, we fall back to a repo-ish root guess (2 parents up).
+    """
+    file_path = get_Path(file_path)
+    file_path = file_path.resolve()
+    stem = file_path.with_suffix("")  # drop .py
+
+    top_pkg_dir = find_top_package_dir(file_path)
+    if top_pkg_dir:
+        sysroot = top_pkg_dir.parent
+        dotted = ".".join(stem.relative_to(sysroot).parts)
+        return dotted, sysroot
+
+    # Fallback: not in a package tree — guess a root a couple levels up
+    sysroot = file_path.parents[2]
+    dotted = ".".join(stem.relative_to(sysroot).parts)
+    return dotted, sysroot
+
+

abstract_utilities/import_utils/src/extract_utils.py

@@ -0,0 +1,46 @@
+from ..imports import *
+def get_imp(line):
+    lis = [li for li in line.split(' ') if li and li.startswith('.')]
+    if lis and len(lis) >0:
+        lis = lis[0]
+        lis = len(lis) - len(eatInner(lis,['.']))
+        return lis
+    return 0
+def extract_imports(path,strings=None):
+    strings = make_list(strings or ['from','import'])
+    funcs = []
+    lines = read_from_file(path).splitlines()
+    return [line for line in lines if [string for string in strings if string and eatAll(line,[' ','\n','\t']) and eatAll(line,[' ','\n','\t']).startswith(string)]]
+
+def extract_froms(path: str):
+    funcs = []
+    for line in read_from_file(path).splitlines():
+        m = re.match(r"^from\s+([A-Za-z_]\w*)\s*", line)
+        if m:
+            funcs.append(m.group(1))
+    return funcs
+def extract_selfs(path: str):
+    funcs = []
+    for line in read_from_file(path).splitlines():
+        m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
+        if m:
+            funcs.append(m.group(1))
+    return funcs
+def extract_funcs(path: str):
+    funcs = []
+    for line in read_from_file(path).splitlines():
+        m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(", line)
+        if m:
+            funcs.append(m.group(1))
+    return funcs
+def extract_class(path: str):
+    funcs = []
+    for line in read_from_file(path).splitlines():
+        m = re.match(r"^class\s+([A-Za-z_]\w*)\s*\(", line) or re.match(r"^class\s+([A-Za-z_]\w*)\s*\:", line)
+        if m:
+            funcs.append(m.group(1))
+    return funcs
+def get_all_py_file_paths(*args,**kwargs):
+    globs = collect_globs(*args,allowed_exts='.py',**kwargs)
+    globs = [glo for glo in globs.get('files') if glo]
+    return globs

abstract_utilities/import_utils/src/import_functions.py

@@ -0,0 +1,91 @@
+# --- auto-package bootstrap (run-safe) ---------------------------------
+from ..imports import *
+from .dot_utils import get_dot_range
+from .sysroot_utils import get_sysroot,get_import_with_sysroot,get_py_files,get_all_py_sysroots
+from .extract_utils import get_all_py_file_paths
+def clean_imports(imports,commaClean=True):
+    chars=["*"]
+    if not commaClean:
+        chars.append(',')
+    if isinstance(imports,str):
+        imports = imports.split(',')
+    return [eatElse(imp,chars=chars) for imp in imports if imp]
+def get_dot_range(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
+def get_cleaned_import_list(line,commaClean=True):
+    cleaned_import_list=[]
+    if IMPORT_TAG in line:
+        imports = line.split(IMPORT_TAG)[1]
+        cleaned_import_list+=clean_imports(imports,commaClean=commaClean)
+    return cleaned_import_list
+def get_module_from_import(imp,path=None):
+    path = path or os.getcwd()
+    i = get_dot_range(imp)
+    imp = eatAll(imp,'.')
+    sysroot = get_sysroot(path,i)
+    return os.path.join(sysroot, imp)
+
+def safe_import(name: str, *, package: str | None = None, member: str | None = None, file: str | None = None):
+    """
+    Wrapper over importlib.import_module that:
+    - if `name` is relative (starts with '.'), ensures `package` is set.
+    - if `package` is missing, derives it from `file` (defaults to __file__).
+    """
+    file = file or __file__
+    ensure_package_context(file)
+    if name.startswith(".") and not package:
+        
+            
+        pkg_name = get_module_from_import(name,path=None)
+        # also set __package__ if we are running as a script
+        if __name__ == "__main__" and (not globals().get("__package__")):
+            globals()["__package__"] = pkg_name
+        package = pkg_name
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod
+
+def dynamic_import(module_path: str, namespace: dict, all_imports = None):
+    """
+    Emulates:
+        from module_path import *
+    but includes private (_xxx) names too.
+    """
+    all_imports = if_none_default(all_imports,True,typ=bool)
+    if module_path:
+        module = importlib.import_module(module_path)
+
+        # Import literally everything except dunders, unless you want them too.
+        names = [n for n in dir(module) if n and ((not all_imports and not n.startswith("_")) or all_imports)]
+
+
+        for name in names:
+            namespace[name] = getattr(module, name)
+
+        return module
+
+
+def get_monorepo_root(directory=None,files=None):
+    directory = directory or get_initial_caller_dir()
+    py_files = get_all_py_file_paths(directory,add=True)
+    sysroots = get_all_py_sysroots(directory=directory,files=py_files)
+    monorepo_root = get_common_root(sysroots)
+    return monorepo_root
+def switch_to_monorepo_root(directory=None,files=None):
+    monorepo_root = get_monorepo_root(directory=directory,files=files)
+    if str(monorepo_root) not in sys.path:
+        sys.path.insert(0, str(monorepo_root))
+def get_all_imports(directory=None,sysroot=None):
+    sysroot = sysroot or get_initial_caller_dir()
+    directory = directory or sysroot
+    files = get_py_files(directory=directory)
+    switch_to_monorepo_root(directory=directory,files=files)
+    for glo in [glo for glo in globs.get('files') if glo]:
+        imp = get_import_with_sysroot(glo, sysroot)
+        dynamic_import(imp, globals())
+