abstract-utilities 0.2.2.480__py3-none-any.whl → 0.2.2.688__py3-none-any.whl

abstract_utilities/__init__.py

@@ -1,11 +1,6 @@
-import re,threading,os,shutil,requests,asyncio,time,subprocess,json,glob,sys,logging
-from datetime import timedelta
-from datetime import datetime
-from typing import *
+from .imports import *
 from .hash_utils import *
 ##from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
-from .robust_readers import *
-from .dynimport import get_abstract_import
 from .json_utils import (unified_json_loader,
                          find_keys,
                          get_key_values_from_path,
@@ -37,10 +32,11 @@ from .json_utils import (unified_json_loader,
                          safe_write_to_file,
                          safe_save_updated_json_data,
                          get_result_from_data,
-                         flatten_json
+                         flatten_json,
+                         to_json_safe
                          )
-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,
@@ -50,7 +46,9 @@ from .list_utils import (get_highest_value_obj,
                          compare_lists,
                          get_symetric_difference,
                          list_set,
-                         make_list_it)
+                         make_list_it,
+                         get_single_from_list
+                         )
 from .time_utils import (get_time_stamp,
                          get_sleep,
                          sleep_count_down,
@@ -61,7 +59,7 @@ from .time_utils import (get_time_stamp,
                          parse_timestamp,
                          get_time_now_iso,
                          is_valid_time)
-from .string_clean import (eatInner,
+from .string_utils import (eatInner,
                            eatAll,
                            eatOuter,
                            url_join,
@@ -88,7 +86,8 @@ from .type_utils import (make_bool,
                          get_numbers_comp,
                          is_any_instance,
                          break_string,
-                         MIME_TYPES
+                         MIME_TYPES,
+                         get_if_None
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,
@@ -106,20 +105,29 @@ from .compare_utils import (create_new_name,
                             best_match)
 from .thread_utils import ThreadManager
 from .history_utils import HistoryManager
-from .abstract_classes import *
+
 from .parse_utils import (num_tokens_from_string,
                           chunk_source_code,
                           chunk_any_to_tokens,
                           detect_language_from_text,
                           chunk_by_language_context,
-                          search_code)
+                          search_code,
+                          get_within_quotes)
 
 from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_response,initialize_call_log
 from .error_utils import try_func
+from .class_utils import *
 from .ssh_utils import *
 from .env_utils import *
 from .path_utils import *
 from .file_utils import *
-from .file_utils import call_for_all_tabs
 from .string_utils import *
-from .class_utils import alias,get_class_inputs,get_set_attr,get_caller_path,get_caller_dir
+from .import_utils import *
+from .read_write_utils import (read_from_file,
+                               write_to_file,
+                               make_dirs,
+                               make_dirs,
+                               copy_files,
+                               make_path,
+                               run_cmd
+                               )

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

@@ -0,0 +1,7 @@
+from .imports import *
+from .abstract_classes import *
+from .caller_utils import *
+from .class_utils import *
+from .function_utils import *
+from .module_utils import *
+from .global_utils import *

abstract_utilities/class_utils/abstract_classes.py

@@ -0,0 +1,144 @@
+from .imports import *
+class SingletonMeta(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+def get_inputs(cls, *args, **kwargs):
+    """
+    Dynamically construct a dataclass instance from args and kwargs,
+    filling missing values from defaults in the dataclass.
+    """
+    fields = list(cls.__annotations__.keys())
+    values = {}
+
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)  # default from dataclass
+
+    return cls(**values)
+
+
+from abstract_utilities import *
+class SingletonMeta(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+def get_inputs(cls, *args, **kwargs):
+    """
+    Dynamically construct a dataclass instance from args and kwargs,
+    filling missing values from defaults in the dataclass.
+    """
+    fields = list(cls.__annotations__.keys())
+    values = {}
+
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)  # default from dataclass
+
+    return cls(*args,**values)
+def get_input_params(func):
+    sig = inspect.signature(func)
+    return sig.parameters
+def get_args(func, *args,**kwargs):
+    parameters = get_input_params(func)
+    parameters = dict(parameters)
+    for key,value in parameters.items():
+        value = str(value)
+        if value.startswith('**'):
+            kwargs_key = key
+        elif value.startswith('*'):
+            args_key = key
+            kwargs_copy = kwargs.copy()
+            for k_key,k_value in kwargs.items():
+                if args_key == k_key and  isinstance(k_value,list or tuple or set):
+                    args = args | tuple(k_value)
+                    del kwargs[k_key]
+    return args,kwargs
+
+def prune_inputs(func, *args, **kwargs):
+    """
+    Smart argument adapter:
+    - Detects if func accepts *args or **kwargs
+    - Builds new positional arguments from kwargs when appropriate
+    - Handles explicit {"args": [...]} convention
+    """
+
+    sig = inspect.signature(func)
+    params = sig.parameters
+
+    has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params.values())
+    has_varkw   = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+    new_args = list(args)
+    new_kwargs = dict(kwargs)
+
+    # -----------------------------------------------------------
+    # 1. If user provided explicit args: {"args": [...]}
+    # -----------------------------------------------------------
+    if "args" in new_kwargs:
+        explicit_args = new_kwargs.pop("args")
+        if isinstance(explicit_args, (list, tuple)):
+            new_args.extend(explicit_args)
+        else:
+            new_args.append(explicit_args)
+
+    # -----------------------------------------------------------
+    # 2. If function has *args, infer which kwargs belong there
+    # -----------------------------------------------------------
+    if has_varargs:
+
+        # Heuristic rules for upgrading kwargs to args:
+        #   - if the function has NO named params, treat all scalar kwargs as positional
+        #   - common param names like "file_path" also qualify
+        preferred_as_args = {"path", "file", "file_path", "filename", "value"}
+
+        positional_candidates = []
+
+        for k in list(new_kwargs.keys()):
+            v = new_kwargs[k]
+
+            # candidate rules:
+            if k in preferred_as_args:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+            # scalars but not mappings/lists (optional)
+            elif isinstance(v, (str, int, float)) and len(positional_candidates) == 0:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+        new_args.extend(positional_candidates)
+
+    # -----------------------------------------------------------
+    # 3. If function does NOT accept **kwargs → strip extras
+    # -----------------------------------------------------------
+    if not has_varkw:
+        allowed = {
+            name for name, p in params.items()
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY
+            )
+        }
+        new_kwargs = {k: v for k, v in new_kwargs.items() if k in allowed}
+
+    return tuple(new_args), new_kwargs
+def run_pruned_func(func, *args, **kwargs):
+   args,kwargs = prune_inputs(func, *args, **kwargs)
+   return func(*args, **kwargs)

abstract_utilities/class_utils/caller_utils.py

@@ -0,0 +1,92 @@
+from .imports import *
+
+def get_initial_caller() -> str:
+    """
+    Return the TRUE original caller: the entrypoint script that launched the program.
+    """
+    main_mod = sys.modules.get('__main__')
+    
+    # interactive environments (REPL) may have no __file__
+    if not main_mod or not hasattr(main_mod, '__file__'):
+        return None
+
+    return os.path.realpath(main_mod.__file__)
+def get_initial_caller_dir() -> str:
+    """
+    Return the directory of the TRUE original entrypoint script.
+    """
+    caller = get_initial_caller()
+    return os.path.dirname(caller) if caller else None
+
+def get_caller(i: Optional[int] = None) -> str:
+    """
+    Return the filename of the calling frame.
+
+    Args:
+        i: Optional stack depth offset. 
+           None = immediate caller (depth 1).
+
+    Returns:
+        Absolute path of the file for the stack frame.
+    """
+    depth = 1 if i is None else int(i)
+    stack = inspect.stack()
+    if depth >= len(stack):
+        depth = len(stack) - 1
+    return stack[depth].filename
+
+
+def get_caller_path(i: Optional[int] = None) -> str:
+    """
+    Return the absolute path of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    file_path = get_caller(depth + 1)
+    return os.path.realpath(file_path)
+
+
+def get_caller_dir(i: Optional[int] = None) -> str:
+    """
+    Return the absolute directory of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    abspath = get_caller_path(depth + 1)
+    return os.path.dirname(abspath)
+
+
+def get_original_caller_dir(levels_up: int = None) -> Path:
+    """
+    Return the directory of the *original* caller in the call stack.
+
+    levels_up:
+        - None → automatically goes to the bottom-most user-level caller.
+        - N    → manually walk up N frames for custom behavior.
+    
+    Returns:
+        Path object pointing to caller's directory.
+    """
+
+    stack = inspect.stack()
+
+    # If the user specifies an exact depth
+    if levels_up is not None:
+        target = min(levels_up + 1, len(stack) - 1)
+        frame = stack[target]
+        return Path(frame.filename).resolve().parent
+
+    # Otherwise, auto-detect the FIRST file that isn't inside site-packages or abstract_* utilities
+    for frameinfo in reversed(stack):
+        file_path = Path(frameinfo.filename).resolve()
+
+        # Skip internal interpreter/frame files
+        if "site-packages" in str(file_path):
+            continue
+        if "abstract_" in file_path.name:
+            continue
+        if file_path.name.startswith("<"):
+            continue
+
+        return file_path.parent
+
+    # Fallback: last entry in the stack
+    return Path(stack[-1].filename).resolve().parent