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

abstract_utilities/import_utils/src/clean_imports.py

@@ -1,12 +1,64 @@
 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):
-    text = text or ''
-    imports_js = {}
-    if not text and file_path and os.path.isfile(file_path):
+    file_path = get_pkg_or_init(file_path)
+    if not text and file_path:
         text=read_from_file(file_path)
-    return text
+    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
@@ -25,19 +77,18 @@ def is_from_line_group(line):
     return False
 
 def get_all_imports(text=None,file_path=None,import_pkg_js=None):
-    if text and os.path.isfile(text):
-        file_path = text
-        text = read_from_file(text)    
-    text = get_text_or_read(text=text,file_path=file_path)
+    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)
+            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
@@ -46,18 +97,16 @@ def get_all_imports(text=None,file_path=None,import_pkg_js=None):
                    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)
+                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)
+                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 clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
-    if text and os.path.isfile(text):
-        file_path = text
-        text = read_from_file(text)    
+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)
@@ -87,11 +136,11 @@ def clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False
                     nu_lines[line] += imports
     return import_pkg_js
 def clean_all_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
-    clean_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js,fill_nulines=import_pkg_js)
-    import_pkg_js["context"]["nulines"]=nu_lines
+    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 = clean_imports(import_pkg_js=import_pkg_js,fill_nulines=fill_nulines)
+    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']:
@@ -130,18 +179,100 @@ def get_dot_fro_lines(lines,file_path,all_imps):
             all_imps.append(line)
     return all_imps
 def get_all_real_imps(text=None,file_path=None,all_imps=None):
-    if text and os.path.isfile(text):
-        file_path = text
-        text = read_from_file(text)    
+  
     all_imps = all_imps or []
-    contents = get_text_or_read(text=text,file_path=file_path)
-    lines = contents.split('\n')
+    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):
-    import_pkg_js=get_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    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

@@ -1,4 +1,15 @@
 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))

abstract_utilities/import_utils/src/extract_utils.py

@@ -40,3 +40,7 @@ def extract_class(path: str):
         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

@@ -1,7 +1,8 @@
 # --- auto-package bootstrap (run-safe) ---------------------------------
 from ..imports import *
 from .dot_utils import get_dot_range
-from .sysroot_utils import get_sysroot
+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:
@@ -9,6 +10,13 @@ def clean_imports(imports,commaClean=True):
     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:
@@ -17,7 +25,7 @@ def get_cleaned_import_list(line,commaClean=True):
     return cleaned_import_list
 def get_module_from_import(imp,path=None):
     path = path or os.getcwd()
-    i = get_dot_range(None,[imp])
+    i = get_dot_range(imp)
     imp = eatAll(imp,'.')
     sysroot = get_sysroot(path,i)
     return os.path.join(sysroot, imp)
@@ -42,5 +50,42 @@ def safe_import(name: str, *, package: str | None = None, member: str | None = N
     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())
 

abstract_utilities/import_utils/src/pkg_utils.py

@@ -1,6 +1,36 @@
 # safe_import_utils.py
 from ..imports import *
 from .import_functions import *
+from ...safe_utils import *
+from .sysroot_utils import get_import_with_sysroot
+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 ensure_import_pkg_js(import_pkg_js,file_path=None):
     import_pkg_js = import_pkg_js or {"context":{}}
@@ -79,18 +109,42 @@ def ensure_caller_package(caller_file: str, caller_globals: dict | None = None)
     if caller_globals and caller_globals.get("__name__") == "__main__" and not caller_globals.get("__package__"):
         caller_globals["__package__"] = pkg
     return pkg
+def get_init_dots(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
+def make_relative_pkg(import_pkg,file_path):
+    full_pkg = eatAll(import_pkg,'.')
+    if file_path:
+        dirname = file_path
+        dot_count = get_init_dots(import_pkg)
+        for i in range(dot_count):
+            dirname = os.path.dirname(dirname)
+            dirbase = os.path.basename(dirname)
+            full_pkg=f"{dirbase}.{full_pkg}"
+    return full_pkg
+def is_local_import(import_pkg,file_path=None):
+    relative_pkg = get_module_from_import(import_pkg,file_path)
+    if get_pkg_or_init(relative_pkg):
+        return True
+    return False
 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):
+def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None,file_path=None):
     import_pkg_js = ensure_import_pkg_js(import_pkg_js)
     imports = clean_imports(imports)
+    pkg_path = get_module_from_import(import_pkg,file_path)
+    local_import = get_pkg_or_init(pkg_path)
     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_pkg_js[import_pkg]={"imports":imports,"line":i,"file_path":file_path,"local_import":local_import,"is_local":is_local_import(import_pkg,file_path=file_path)}
         import_line = f"from {import_pkg} import "
         if import_pkg == "import":
             import_line = IMPORT_TAG
@@ -98,12 +152,12 @@ def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None):
     else:
         import_pkg_js[import_pkg]["imports"]+=imports
     return import_pkg_js
-def update_import_pkg_js(line,import_pkg_js=None):
+def update_import_pkg_js(line,import_pkg_js=None,file_path=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)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=import_pkg_js,file_path=file_path)
     else:
         if len(import_pkg_js["context"]["nulines"]) >0 and line == '' and is_line_import(import_pkg_js["context"]["nulines"][-1]):
             pass

abstract_utilities/import_utils/src/sysroot_utils.py

@@ -1,6 +1,9 @@
 from ..imports import *
 from .dot_utils import *
-
+from .extract_utils import get_all_py_file_paths
+def get_py_files(directory=None):
+    directory = directory or get_caller_dir(2)
+    return get_all_py_file_paths(directory,add=True)
 def ensure_on_path(p: Path):
     s = str(p)
     if s not in sys.path:
@@ -19,7 +22,59 @@ def get_dot_range_sysroot(filepath):
         sysroot = get_sysroot(sysroot,dot_range)
     
     return sysroot
+def get_import_with_sysroot(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.
+    """
+
+
+    # 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)
+
+    bare_rel = eatAll(relpath,'.')
+    
+    # Turn filesystem path into dotted python path
+    if relpath == ".":
+        dotted = ""
+    else:
+        dotted = ".".join(part for part in relpath.split(os.sep) if part)
+    if bare_rel.startswith('/') and dotted.startswith('.'):
+        dotted = dotted[1:]
+
+
+    # Build final rewritten import
+    return dotted
+def get_all_sysroots(files):
+    sysroots=[]
+    for glo in files:
+        imp = compute_dotted_and_sysroot(glo)
+        sysroots.append(imp[-1])
+    return sysroots
+def get_shortest_sysroot(files):
+    sysroots = get_all_sysroots(files)
+    return get_shortest_path(*sysroots)
+def get_all_py_sysroots(directory=None,files=None):
+    py_files = files or get_py_files(directory=directory)
+    return [compute_dotted_and_sysroot(glo)[1] for glo in py_files]
 
+def get__imports(directory=None, sysroot=None):
+    directory = directory or get_caller_dir(1)
+    globs = collect_globs(directory, allowed_exts='.py')
+    globs = [glo for glo in globs.get('files') if glo]
+    sysroots = [compute_dotted_and_sysroot(glo)[1] for glo in globs]
+    # ⭐ Get unified monorepo root
+    monorepo_root = get_common_root(sysroots)
+    if str(monorepo_root) not in sys.path:
+        sys.path.insert(0, str(monorepo_root))
+    get_all_imports(directory=directory, sysroot=monorepo_root)
 def is_import_or_init(sysroot,likely=None):
     file_data = get_file_parts(sysroot)
     nuroot = sysroot

abstract_utilities/log_utils/log_file.py

@@ -12,14 +12,15 @@ def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int =
         bpName = os.path.splitext(os.path.basename(caller_path))[0]
         del frame_info
 
-    log_dir = mkdirs("logs")
-    log_path = os.path.join(log_dir, f"{bpName}.log")
+
 
     logger = logging.getLogger(bpName)
     logger.setLevel(logging.INFO)
 
     if not logger.handlers:
         try:
+            log_dir = mkdirs("logs")
+            log_path = os.path.join(log_dir, f"{bpName}.log")
             handler = RotatingFileHandler(log_path, maxBytes=maxBytes, backupCount=backupCount)
             handler.setLevel(logging.INFO)
 

abstract_utilities/path_utils/path_utils.py

@@ -225,27 +225,29 @@ def create_base_dir(directory=None, child=None):
 
 
 def get_file_parts(path):
-    
-    basename = get_safe_basename(path)
-    filename, ext = get_safe_splitext(basename=basename)
-
-    dirname = get_safe_dirname(path)
-    dirbase = get_safe_basename(dirname)
-    
-    parent_dirname = get_safe_dirname(dirname)
-    parent_dirbase = get_safe_basename(parent_dirname)
-    
-    super_dirname = get_safe_dirname(parent_dirname)
-    super_dirbase = get_safe_basename(super_dirname)
-
-    return {"dirname": dirname,
-            "basename": basename,
-            "filename": filename,
-            "ext": ext,
-            "dirbase":dirbase,
-            "parent_dirname":parent_dirname,
-            "parent_dirbase":parent_dirbase,
-            "super_dirname":super_dirname,
-            "super_dirbase":super_dirbase
-            }
+    if path:
+        path= str(path) 
+        basename = get_safe_basename(path)
+        filename, ext = get_safe_splitext(basename=basename)
+
+        dirname = get_safe_dirname(path)
+        dirbase = get_safe_basename(dirname)
+        
+        parent_dirname = get_safe_dirname(dirname)
+        parent_dirbase = get_safe_basename(parent_dirname)
+        
+        super_dirname = get_safe_dirname(parent_dirname)
+        super_dirbase = get_safe_basename(super_dirname)
+
+        return {"file_path":path,
+                "dirname": dirname,
+                "basename": basename,
+                "filename": filename,
+                "ext": ext,
+                "dirbase":dirbase,
+                "parent_dirname":parent_dirname,
+                "parent_dirbase":parent_dirbase,
+                "super_dirname":super_dirname,
+                "super_dirbase":super_dirbase
+                }
 

abstract_utilities/safe_utils/safe_utils.py

@@ -10,7 +10,37 @@ Designed for compatibility with the abstract_ ecosystem (e.g. abstract_utilities
 from .imports import *
 _BASE_DIR = get_caller_dir()
 
+class PathOutsideBase(Exception):
+    pass
 
+def safe_join_base(base: Union[str, Path], *parts: Union[str, Path], must_exist: bool = False) -> Path:
+    """
+    Join base with parts, normalize, and ensure the result lives under base.
+    Prevents '../' traversal and ignores leading slashes in parts.
+    """
+    base = Path(base).resolve(strict=True)
+    # Disallow absolute/drive-anchored parts by stripping their anchors before joining.
+    cleaned = []
+    for p in parts:
+        p = Path(p)
+        # Convert absolute to relative (security: we won't allow escaping base anyway)
+        if p.is_absolute():
+            p = Path(*p.parts[1:])  # drop leading '/'
+        cleaned.append(p)
+
+    # Build and resolve (non-strict so missing files are allowed unless must_exist=True)
+    target = (base.joinpath(*cleaned)).resolve(strict=False)
+
+    # Containment check (works even if target doesn't exist)
+    try:
+        target.relative_to(base)
+    except ValueError:
+        raise PathOutsideBase(f"{target} escapes base {base}")
+
+    if must_exist and not target.exists():
+        raise FileNotFoundError(target)
+
+    return target
 def safe_split(
     string: Any,
     char: Any,

{abstract_utilities-0.2.2.513.dist-info → abstract_utilities-0.2.2.583.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.513
+Version: 0.2.2.583
 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