abstract-utilities 0.2.2.504__py3-none-any.whl → 0.2.2.510__py3-none-any.whl

abstract_utilities/__init__.py

@@ -36,6 +36,7 @@ from .json_utils import (unified_json_loader,
                          )
 from .read_write_utils import (read_from_file,
                                write_to_file)
+from .directory_utils import *
 from .path_utils import *
 from .file_utils import *
 from .list_utils import (get_highest_value_obj,

abstract_utilities/circular_import_finder.py

@@ -0,0 +1,222 @@
+from abstract_utilities import *
+from collections import defaultdict
+def clean_line(line):
+    return eatAll(line,[' ','','\t','\n'])
+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 clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    if text and os.path.isfile(text):
+        file_path = text
+        input(file_path)
+        text = read_from_file(file_path)    
+    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 get_all_imports(text=None,file_path=None,import_pkg_js=None):
+    if text and os.path.isfile(text):
+        
+        try:
+            text = read_from_file(text)    
+        except:
+            pass
+        file_path = text
+    text = 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)
+        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)
+                
+            else:
+                import_pkg_js=update_import_pkg_js(line,import_pkg_js=import_pkg_js)
+            if is_from_line_group(line) and is_from_group == False:
+                is_from_group=get_import_pkg(line)
+    return import_pkg_js
+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):
+        if os.path.isfile(pkg_init_path):
+            return pkg_init_path
+    #input(f"nnot found == {pkg_info}")
+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["root_dirname"]):
+            info_js["local"]=True
+            info_js["pkg_path"]=get_path_or_init(info_js)
+        return info_js
+    return line
+def get_top_level_imp(line,dirname=None):
+    imp = get_dot_fro_line(line,dirname)
+    return imp.split('.')[0]
+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") == True:
+               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:
+        curr_file_path = local_imp.get('file_path')
+        pkg_path = local_imp.get('pkg_path')
+        if pkg_path != None:
+            pkg_paths.append(pkg_path)
+    return pkg_paths
+def get_cir_dir(pkg_path):
+    dirname = os.path.dirname(pkg_path)
+    dirbase = os.path.basename(dirname)
+    while True:
+        if dirname == "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/abstract_utilities":
+            break
+        dirbase = os.path.basename(dirname)
+        dirname = os.path.dirname(dirname)
+    #input(f"{dirbase} is circular")
+    return dirbase 
+def is_circular(pkg_path):
+    pkg_paths = get_all_pkg_paths(pkg_path)
+    if pkg_path in pkg_paths:
+        return pkg_path
+def are_circular(pkg_path,cir_dirs = None):
+    cir_dirs = cir_dirs or []
+    pkg_path = is_circular(pkg_path)
+    if pkg_path:
+        if pkg_path not in cir_dirs:
+            cir_dirs.append(pkg_path)
+    return cir_dirs
+
+
+def build_dependency_graph(main_directory):
+    """Map each file to all local imports (by resolved pkg_path)."""
+    graph = defaultdict(list)
+    dirs, all_local_scripts = get_files_and_dirs(
+        main_directory,
+        allowed_exts='.py',
+        exclude_dirs=['depriciate', 'junk'],
+        files_only=True
+    )
+    for file_path in all_local_scripts:
+        deps = get_all_pkg_paths(file_path)
+        for dep in deps:
+            if dep and os.path.isfile(dep):
+                graph[file_path].append(dep)
+    return graph
+
+
+def find_circular_chains(graph):
+    """Detect circular imports and return their full dependency paths."""
+    visited, cycles = set(), []
+
+    def dfs(node, path):
+        visited.add(node)
+        path.append(node)
+        for dep in graph.get(node, []):
+            if dep not in path:
+                dfs(dep, path.copy())
+            else:
+                # Found a circular import
+                cycle_start = path.index(dep)
+                cycle = path[cycle_start:] + [dep]
+                if cycle not in cycles:
+                    cycles.append(cycle)
+        return
+
+    for start in graph:
+        dfs(start, [])
+    return cycles
+
+
+def explain_circular_imports(cycles):
+    """Pretty-print circular import chains with file names and import lines."""
+    for i, cycle in enumerate(cycles, 1):
+        print(f"\n🔁 Circular import {i}:")
+        for j in range(len(cycle) - 1):
+            src, dst = cycle[j], cycle[j + 1]
+            print(f"  {os.path.basename(src)}  →  {os.path.basename(dst)}")
+        print(f"  ^ back to {os.path.basename(cycle[0])}")
+main_directory = "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/abstract_utilities"
+
+graph = build_dependency_graph(main_directory)
+cycles = find_circular_chains(graph)
+
+if not cycles:
+    print("✅ No circular imports found.")
+else:
+    print(f"❌ Found {len(cycles)} circular import(s).")
+    explain_circular_imports(cycles)

abstract_utilities/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/directory_utils/__init__.py

@@ -0,0 +1,4 @@
+from .directory_utils import *
+from .name_utils import *
+from .utils import *
+from .size_utils import *

abstract_utilities/directory_utils/directory_utils.py

@@ -0,0 +1,94 @@
+from ..imports import os,shlex
+from ..safe_utils import safe_join
+from .utils import *
+def get_dirs(path):
+    """
+    Get List of Immediate Subdirectories in a Path
+
+    This function uses the os.walk method to traverse through a directory tree and returns a list of immediate subdirectories
+    within the specified path.
+
+    Parameters:
+    - path (str): The path for which subdirectories need to be retrieved.
+
+    Returns:
+    - subdirectories (list): A list of immediate subdirectories within the specified path.
+
+    Example:
+    subdirs = get_dirs("/path/to/directory")
+    print("Immediate Subdirectories:", subdirs)
+    """
+    from os import walk
+    for (dirpath, dirnames, filenames) in walk(path):
+        return dirnames
+def get_directory(file_path: str) -> str:
+    """
+    Extracts and returns the directory path from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The directory path extracted from the file path.
+    """
+    return file_path[:-len(get_base_name(file_path))]
+def if_not_last_child_join(path:str,child:str):
+    """
+    Adds a child path to the given path if it's not already present at the end.
+
+    Args:
+        path (str): The parent path.
+        child (str): The child path to add.
+    
+    Returns:
+        str: The updated path.
+    """
+    if path.endswith(child):
+        return path
+    return simple_path_join(path, child)
+def createFolds(ls: list) -> None:
+    """
+    Creates multiple directories.
+
+    Args:
+        ls (list): The list of directory paths to create.
+    """
+    for k in range(len(ls)):
+        mkdirs(ls[k])
+def list_directory_contents(path: str) -> list:
+    """Returns a list of directory contents or a list with a single file, if the path is a file.
+
+    Args:
+        path (str): The path of the directory or file.
+
+    Returns:
+        list: A list of directory contents or a list with a single file path.
+    """
+    if is_file(path):
+        return [path]
+    elif is_valid_path(path):
+        return os.listdir(path)
+    return [path]
+def is_string_in_dir(path,strings):
+    dirname =  path
+    if is_file(path):
+        dirname = os.path.dirname(path)
+    pieces = [pa for pa in dirname.split('/') if pa and pa in strings]
+    logger.info(f"pieces = {pieces}\nstrings == {strings}")
+    if pieces:
+        return True
+    return False
+def raw_create_dirs(*paths):
+    """Recursively create all directories along the given path."""
+    full_path = os.path.abspath(safe_join(*paths))
+    sub_parts = [p for p in full_path.split(os.sep) if p]
+
+    current_path = "/" if full_path.startswith(os.sep) else ""
+    for part in sub_parts:
+        current_path = safe_join(current_path, part)
+        os.makedirs(current_path, exist_ok=True)
+    return full_path
+mkdirs=raw_create_dirs
+makedirs = mkdirs
+make_dirs = makedirs
+

abstract_utilities/directory_utils/name_utils.py

@@ -0,0 +1,43 @@
+from ..imports import *
+from .directory_utils import *
+def get_file_name(file_path: str) -> str:
+    """
+    Retrieves and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file (without extension).
+    """
+    return split_text(get_base_name(file_path))[0]
+def get_abs_name_of_this():
+    """
+    Returns the absolute name of the current module.
+
+    Returns:
+        Path: The absolute name of the current module.
+    """
+    return os.path.abspath(__name__)
+def sanitize_filename(name: str):
+    """
+    Sanitize a filename by removing invalid characters.
+    
+    Args:
+    name (str): Filename to sanitize.
+    
+    Returns:
+    str: Sanitized filename.
+    """
+    return re.sub(r'[\\/*?:"<>|]', "", name)
+def get_base_name(file_path: str) -> str:
+    """
+    Extracts and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file.
+    """
+    return os.path.basename(file_path)

abstract_utilities/directory_utils/size_utils.py

@@ -0,0 +1,57 @@
+from ..imports import *
+from .name_utils import *
+def get_os_info():
+    """
+    Get Operating System Information
+
+    This function retrieves information about the current operating system, including its name and bit size.
+
+    Returns:
+    - os_info (dict): A dictionary containing the operating system information.
+                      Keys:
+                      - "operating_system" (str): The name of the operating system (e.g., "Windows", "Linux", "Darwin").
+                      - "bit_size" (str): The bit size of the operating system (e.g., "32bit", "64bit").
+
+    Example:
+    os_info = get_os_info()
+    print("Operating System:", os_info["operating_system"])
+    print("Bit Size:", os_info["bit_size"])
+    """
+    os_name = platform.system()
+    bit_size = platform.architecture()[0]
+    return {"operating_system": os_name, "bit_size": bit_size}
+def mkGb(k) -> float:
+    """
+    Converts a value to Gigabytes (GB).
+
+    Args:
+        k (float): The value to convert to GB.
+
+    Returns:
+        float: The value converted to GB.
+    """
+    return float(float(k)*(10**9))
+
+def mkGbTrunk(k) -> float:
+    """
+    Converts a value to Gigabytes (GB) and truncates the result to five decimal places.
+
+    Args:
+        k (float): The value to convert to GB.
+
+    Returns:
+        float: The value converted to GB and truncated to five decimal places.
+    """
+    return trunc(mkGb(k), 5)
+
+def mkGbTrunFroPathTot(k) -> float:
+    """
+    Fetches the file size from a path, converts it to Gigabytes (GB) and truncates the result to five decimal places.
+
+    Args:
+        k (str): The file path.
+
+    Returns:
+        float: The file size converted to GB and truncated to five decimal places.
+    """
+    return trunc(mkGb(s.path.getsize(k)), 5)

abstract_utilities/directory_utils/utils.py

@@ -0,0 +1,116 @@
+from ..imports import *
+def split_text(string: str) -> tuple:
+    """
+    Splits a string into its base name and extension and returns them as a tuple.
+
+    Args:
+        string (str): A string to be split, typically representing a file name.
+
+    Returns:
+        tuple: A tuple containing the base name and extension of the input string.
+    """
+    return os.path.splitext(string)
+def get_ext(file_path: str) -> str:
+    """
+    Retrieves and returns the extension of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The extension of the file (including the dot).
+    """
+    return split_text(get_base_name(file_path))[1]
+
+def get_slash():
+    """
+    Returns the appropriate file path separator depending on the current operating system.
+    """
+    slash = '/'  # Assume a Unix-like system by default
+    if slash not in get_current_path():
+        slash = '\\'  # Use backslash for Windows systems
+    return slash
+def get_current_path():
+    """
+    Returns the current working directory.
+    
+    Returns:
+        str: The current working directory.
+    """
+    return os.getcwd()
+
+def get_home_folder():
+    """
+    Returns the path to the home directory of the current user.
+    
+    Returns:
+        str: The path to the home directory.
+    """
+    return os.path.expanduser("~")
+def simple_path_join(path_A:str, path_B:str):
+    """
+    Join two paths using the appropriate file path separator.
+
+    Args:
+        path_A (str): The first path to join.
+        path_B (str): The second path to join.
+    
+    Returns:
+        str: The joined path.
+    """
+    return os.path.join(str(path_A), str(path_B))
+
+def path_join(path_A, path_B=None):
+    """
+    Joins two paths or a list of paths using the appropriate file path separator.
+
+    Args:
+        path_A (str or list): The first path or list of paths to join.
+        path_B (str, optional): The second path to join. Defaults to None.
+    
+    Returns:
+        str: The joined path.
+    """
+    if path_B is not None:  # If path_B is provided, join path_A and path_B
+        return simple_path_join(path_A, path_B)
+    if isinstance(path_A, list):  # If path_A is a list, join all paths in the list
+        path = path_A[0]
+        for k in range(1, len(path_A)):
+            path = simple_path_join(path, path_A[k])
+        return path
+def update_global_variable(name: str, value) -> None:
+    """Updates the global variable with the provided name and value.
+
+    Args:
+        name (str): The name of the global variable.
+        value: The value to assign to the global variable.
+
+    Returns:
+        None
+    """
+    globals()[name] = value
+
+
+def trunc(a: float, x: int) -> float:
+    """
+    Truncates a float number to a specific number of decimal places.
+
+    Args:
+        a (float): The number to truncate.
+        x (int): The number of decimal places to retain.
+
+    Returns:
+        float: The truncated float number.
+    """
+    temp = str(a)
+    for i in range(len(temp)):
+        if temp[i] == '.':
+            try:
+                return float(temp[:i+x+1])
+            except:
+                return float(temp)
+    return float(temp)
+
+
+
+

abstract_utilities/env_utils/imports/imports.py

@@ -1,9 +1,10 @@
 from ...imports import os
 from dotenv import load_dotenv
+from ...ssh_utils import is_file
 from ...string_utils import eatAll,eatInner,eatOuter
 from ...safe_utils import safe_split
 from ...compare_utils import line_contains
 from ...type_utils import is_list,is_bool
-from ...path_utils import get_slash,path_join,if_not_last_child_join,get_home_folder,simple_path_join,is_file
+from ...directory_utils import get_slash,path_join,if_not_last_child_join,get_home_folder,simple_path_join
 DEFAULT_FILE_NAME = '.env'
 DEFAULT_KEY = 'MY_PASSWORD'

abstract_utilities/file_utils/imports/module_imports.py

@@ -5,5 +5,4 @@ from ...env_utils import *
 from ...read_write_utils import read_from_file,write_to_file
 from ...log_utils import get_logFile
 from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
-from ...ssh_utils import run_cmd
-from ...string_utils import get_from_kwargs,eatAll
+

abstract_utilities/file_utils/src/__init__.py

@@ -5,6 +5,5 @@ from .map_utils import *
 from .pdf_utils import *
 from .file_reader import *
 from .find_collect import *
-from .type_checks import *
 from .initFunctionsGen import call_for_all_tabs,get_for_all_tabs