abstract-utilities 0.2.2.540__py3-none-any.whl → 0.2.2.667__py3-none-any.whl

abstract_utilities/file_utils/src/file_filters/filter_utils.py

@@ -0,0 +1,78 @@
+from ...imports import *
+import re
+def combine_params(*values,typ=None):
+    nu_values = None
+    for value in values:
+        if value is not None:
+            typ = typ or type(value)
+            if nu_values is None:
+                nu_values = typ()
+            
+            if typ is set:
+                nu_values = nu_values | typ(value)
+            if typ is list:
+                nu_values += typ(value)
+    return nu_values
+def get_safe_kwargs(canonical_map, **kwargs):
+    # Lowercase all keys for safety
+    canonical_map = canonical_map or CANONICAL_MAP
+    norm_kwargs = {k.lower(): v for k, v in kwargs.items() if v is not None}
+
+    # Inverse lookup: alias → canonical key
+    alias_lookup = {
+        alias: canon
+        for canon, aliases in canonical_map.items()
+        if aliases
+        for alias in aliases
+    }
+
+    # Preserve correctly named keys
+    safe_kwargs = {k: v for k, v in norm_kwargs.items() if k in canonical_map}
+
+    for k, v in norm_kwargs.items():
+        if k in alias_lookup:
+            canonical_key = alias_lookup[k]
+            prev = safe_kwargs.get(canonical_key)
+            if prev is None:
+                safe_kwargs[canonical_key] = v
+            else:
+                # merge intelligently if both exist
+                if isinstance(prev, (set, list)) and isinstance(v, (set, list)):
+                    safe_kwargs[canonical_key] = list(set(prev) | set(v))
+                else:
+                    safe_kwargs[canonical_key] = v  # overwrite for non-iterables
+
+    # fill defaults if missing
+    for canon in canonical_map:
+        safe_kwargs.setdefault(canon, None)
+
+    return safe_kwargs
+
+def create_canonical_map(*args,canonical_map=None):
+    keys = [arg for arg in args if arg]
+    if not keys:
+        return CANONICAL_MAP
+    canonical_map = canonical_map or CANONICAL_MAP
+
+    return {key:canonical_map.get(key) for key in keys}
+def get_safe_canonical_kwargs(*args,canonical_map=None,**kwargs):
+    canonical_map = canonical_map or create_canonical_map(*args)
+    
+    return get_safe_kwargs(canonical_map=canonical_map,**kwargs)    
+def get_dir_filter_kwargs(**kwargs):
+    canonical_map = create_canonical_map("directories")
+    return get_safe_kwargs(canonical_map=canonical_map,**kwargs)
+def get_file_filter_kwargs(**kwargs):
+    """
+    Normalize arbitrary keyword arguments for file scanning configuration.
+    
+    Examples:
+      - 'excluded_ext' or 'unallowed_exts' → 'exclude_exts'
+      - 'include_dirs' or 'allow_dir' → 'allowed_dirs'
+      - 'excludePattern' or 'excluded_patterns' → 'exclude_patterns'
+      - 'allowed_type' or 'include_types' → 'allowed_types'
+    """
+    # Canonical keys and aliases
+    canonical_keys =["allowed_exts","exclude_exts","allowed_types","exclude_types","allowed_dirs","exclude_dirs","allowed_patterns","exclude_patterns"]
+   
+    return get_safe_canonical_kwargs(*canonical_keys,**kwargs)

abstract_utilities/file_utils/src/file_filters/predicate_utils.py

@@ -0,0 +1,44 @@
+from .ensure_utils import *
+
+def get_globs(items,recursive: bool = True,allowed=None,cfg=None,**kwargs):
+    glob_paths = []
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    items = [item for item in make_list(items) if item]
+    for item in items:
+        pattern = os.path.join(item, "**/*")  # include all files recursively\n
+        nuItems = glob.glob(pattern, recursive=recursive)
+        if allowed:
+            nuItems = [nuItem for nuItem in nuItems if nuItem and allowed(nuItem)]
+        glob_paths += nuItems
+    return glob_paths
+def get_allowed_files(items,allowed=True,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    return [item for item in items if item and os.path.isfile(item) and allowed(item)]
+def get_allowed_dirs(items,allowed=False,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    return [item for item in items if item and os.path.isdir(item) and allowed(item)]
+
+def get_filtered_files(items,allowed=None,files = [],cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    glob_paths = get_globs(items,allowed=allowed,cfg=cfg,**kwargs)
+    return [glob_path for glob_path in glob_paths if glob_path and os.path.isfile(glob_path) and glob_path not in files and allowed(glob_path)]
+def get_filtered_dirs(items,allowed=None,dirs = [],cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    glob_paths = get_globs(items,allowed=allowed,cfg=cfg,**kwargs)
+    return [glob_path for glob_path in glob_paths if glob_path and os.path.isdir(glob_path) and glob_path not in dirs and allowed(glob_path)]
+
+def get_all_allowed_files(items,allowed=None,cfg=None,**kwargs):
+    dirs = get_all_allowed_dirs(items,allowed=allowed,cfg=cfg,**kwargs)
+    files = get_allowed_files(items,allowed=allowed,cfg=cfg,**kwargs)
+    nu_files = []
+    for directory in dirs:
+        files += get_filtered_files(directory,allowed=allowed,files=files,cfg=cfg,**kwargs)
+    return files
+def get_all_allowed_dirs(items,allowed=None,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    dirs = get_allowed_dirs(items,allowed=allowed,cfg=cfg,**kwargs)
+    nu_dirs=[]
+    for directory in dirs:
+        nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs,cfg=cfg,**kwargs)
+    return nu_dirs
+

abstract_utilities/file_utils/src/file_reader.py

@@ -1,7 +1,6 @@
 # file_reader.py
 from ..imports import *
 # -------- Public API drop-ins that mirror your originals --------
-from .filter_params import *
 from .file_filters import *
 from .pdf_utils import *
 # ---------------------------------------------------------------------------

abstract_utilities/file_utils/src/find_collect.py

@@ -1,76 +1,8 @@
 from ..imports import *
 from .file_filters import *
-from .filter_params import *
 from pathlib import Path
 from typing import Optional, List, Set
 
-def get_proper_type_str(string):
-    if not string:
-        return None
-    string_lower = string.lower()
-    items = {
-        "d":["dir","dirs","directory","directories","d","dirname"],
-        "f":["file","filepath","file_path","files","filepaths","file_paths","f"]
-     }
-    for key,values in items.items():
-        if string_lower in values:
-            return key
-    init = string_lower[0] if len(string_lower)>0 else None
-    if init in items:
-        return init
-def check_path_type(
-    path: str,
-    user: Optional[str] = None,
-    host: Optional[str] = None,
-    user_as_host: Optional[str] = None,
-    use_shell: bool = False
-) -> Literal["file", "directory", "missing", "unknown"]:
-    """
-    Determine whether a given path is a file, directory, or missing.
-    Works locally or remotely (via SSH).
-
-    Args:
-        path: The path to check.
-        user, host, user_as_host: SSH parameters if remote.
-        use_shell: Force shell test instead of Python os.path.
-    Returns:
-        One of: 'file', 'directory', 'missing', or 'unknown'
-    """
-
-    # --- remote check if user/host is given ---
-    if user_as_host or (user and host):
-        remote_target = user_as_host or f"{user}@{host}"
-        cmd = f"if [ -f '{path}' ]; then echo file; elif [ -d '{path}' ]; then echo directory; else echo missing; fi"
-        try:
-            result = subprocess.check_output(
-                ["ssh", remote_target, cmd],
-                stderr=subprocess.DEVNULL,
-                text=True,
-                timeout=5
-            ).strip()
-            return result if result in ("file", "directory", "missing") else "unknown"
-        except Exception:
-            return "unknown"
-
-    # --- local check ---
-    if not use_shell:
-        if os.path.isfile(path):
-            return "file"
-        elif os.path.isdir(path):
-            return "directory"
-        elif not os.path.exists(path):
-            return "missing"
-        return "unknown"
-    else:
-        # fallback using shell tests (useful for sandboxed contexts)
-        cmd = f"if [ -f '{path}' ]; then echo file; elif [ -d '{path}' ]; then echo directory; else echo missing; fi"
-        try:
-            output = subprocess.check_output(
-                cmd, shell=True, stderr=subprocess.DEVNULL, text=True
-            ).strip()
-            return output if output in ("file", "directory", "missing") else "unknown"
-        except Exception:
-            return "unknown"
 
 
 
@@ -95,15 +27,15 @@ def get_find_cmd(
     """
     # Normalize inputs into canonical form
     kwargs = get_safe_canonical_kwargs(*args, **kwargs)
-    cfg = define_defaults(**kwargs)
+    cfg = kwargs.get('cfg') or define_defaults(**kwargs)
 
     # Get directory list (may come from args or kwargs)
-    directories = [r for r in make_list(kwargs.get("directories")) if r]
-    if not directories:
+    kwargs["directories"] = ensure_directories(*args, **kwargs)
+    if not kwargs["directories"]:
         return []
 
     # Build base command for all directories
-    dir_expr = " ".join(shlex.quote(d) for d in directories)
+    dir_expr = " ".join(shlex.quote(d) for d in kwargs["directories"])
     cmd = [f"find {dir_expr}"]
 
     # --- depth filters ---
@@ -183,18 +115,7 @@ def get_find_cmd(
 
     return " ".join(cmd)
 
-def ensure_directories(*args,**kwargs):
-    directories = []
-    for arg in args:
-        arg_str = str(arg)
-        if is_dir(arg_str,**kwargs):
-            directories.append(arg_str)
-        elif is_file(arg_str,**kwargs):
-            dirname = os.path.dirname(arg_str)
-            directories.append(dirname)
-    safe_directories = get_dir_filter_kwargs(**kwargs)
-    directories+= make_list(safe_directories.get('directories',[]))
-    return list(set([r for r in directories if r]))
+
 
 def collect_globs(
     *args,
@@ -212,9 +133,10 @@ def collect_globs(
     - If file_type is "f" or "d" → returns a list of that type
     - Supports SSH mode via `user_at_host`
     """
+    user_pass_host_key = get_user_pass_host_key(**kwargs)
     kwargs["directories"] = ensure_directories(*args, **kwargs)
     kwargs= get_safe_canonical_kwargs(**kwargs)
-    kwargs["cfg"] = define_defaults(**kwargs)
+    kwargs["cfg"] = kwargs.get('cfg') or define_defaults(**kwargs)
     
     type_strs = {"f":"files","d":"dirs"}
     file_type = get_proper_type_str(file_type)
@@ -227,11 +149,13 @@ def collect_globs(
         type_str = type_strs.get(file_type)
         # Remote path (SSH)
         find_cmd = get_find_cmd(
+            directories=kwargs.get("directories"),
+            cfg=kwargs.get('cfg'),
                 mindepth=mindepth,
                 maxdepth=maxdepth,
                 depth=depth,
                 file_type=file_type,
-                **{k: v for k, v in kwargs.items() if v},
+                **user_pass_host_key,
             )
         result = run_pruned_func(run_cmd,find_cmd,
             **kwargs

abstract_utilities/file_utils/src/find_content.py

@@ -0,0 +1,210 @@
+from .file_filters import *
+from .reader_utils import *
+from .find_collect import *
+STOP_SEARCH = False
+
+def request_find_console_stop():
+    global STOP_SEARCH
+    STOP_SEARCH = True
+
+def reset_find_console_stop():
+    global STOP_SEARCH
+    STOP_SEARCH = False
+
+def get_contents(
+    full_path=None,
+    parse_lines=False,
+    content=None
+    ):
+    if full_path:
+        content = content or read_any_file(full_path)
+    if content:
+        if parse_lines:
+            content = str(content).split('\n')
+        return make_list(content)
+    return []
+
+def _normalize(s: str, strip_comments=True, collapse_ws=True, lower=True):
+    if s is None:
+        return ""
+    if strip_comments:
+        s = s.split('//', 1)[0]
+    if collapse_ws:
+        s = re.sub(r'\s+', ' ', s)
+    if lower:
+        s = s.lower()
+    return s.strip()
+
+def stringInContent(content, strings, total_strings=False, normalize=False):
+    if not content:
+        return False
+    if normalize:
+        c = _normalize(str(content))
+        
+        found = [s for s in strings if _normalize(s) and _normalize(s) in c]
+    else:
+        c = str(content)
+        found = [s for s in strings if s and s in c]
+    if not found:
+        return False
+    return len(found) == len(strings) if total_strings else True
+def find_file(content, spec_line, strings, total_strings=False):
+    lines = content.split('\n')
+    if 1 <= spec_line <= len(lines):
+        return stringInContent(lines[spec_line - 1], strings, total_strings=total_strings)
+    return False
+def find_lines(content, strings, total_strings=False, normalize=True, any_per_line=True):
+    lines = content.split('\n')
+    hits = []
+    for i, line in enumerate(lines):
+        # match one line either if ANY string matches or if ALL match (configurable)
+        if any_per_line:
+            match = stringInContent(line, strings, total_strings=False, normalize=normalize)
+        else:
+            match = stringInContent(line, strings, total_strings=True,  normalize=normalize)
+        if match:
+            hits.append({"line": i+1, "content": line})
+    return hits
+def getPaths(files, strings):
+    tot_strings = strings
+    nu_files, found_paths = [], []
+    if isinstance(strings,list):
+        if len(strings) >1:
+            tot_strings = '\n'.join(strings)
+        else:
+            if len(strings) == 0:
+                return nu_files, found_paths
+            tot_strings = strings[0]
+    
+    
+    for file_path in files:
+        try:
+            og_content = read_any_file(file_path)
+            if tot_strings not in og_content:
+                continue
+            if file_path not in nu_files:
+                nu_files.append(file_path)
+            ogLines = og_content.split('\n')
+            # find all occurrences of the block
+            for m in re.finditer(re.escape(tot_strings), og_content):
+                start_line = og_content[:m.start()].count('\n') + 1  # 1-based
+                curr = {'file_path': file_path, 'lines': []}
+                for j in range(len(strings)):
+                    ln = start_line + j
+                    curr['lines'].append({'line': ln, 'content': ogLines[ln - 1]})
+                found_paths.append(curr)
+        except Exception as e:
+            print(f"{e}")
+    return nu_files, found_paths
+
+def findContent(
+    *args,
+    strings: list=[],
+    total_strings=True,
+    parse_lines=False,
+    spec_line=False,
+    get_lines=True,
+    diffs=False,
+    **kwargs
+):
+    global STOP_SEARCH
+    kwargs["directories"] = ensure_directories(*args,**kwargs)
+
+    found_paths = []
+
+    dirs, files = get_files_and_dirs(
+        **kwargs
+    )
+    nu_files, found_paths = getPaths(files, strings)
+
+    if diffs and found_paths:
+        return found_paths
+
+    for file_path in nu_files:
+        if STOP_SEARCH:
+            return found_paths   # early exit
+
+        if file_path:
+            og_content = read_any_file(file_path)
+            contents = get_contents(
+                file_path,
+                parse_lines=parse_lines,
+                content=og_content
+            )
+            found = False
+            for content in contents:
+                if STOP_SEARCH:
+                    return found_paths  # bail out cleanly
+
+                if stringInContent(content, strings, total_strings=True, normalize=True):
+                    found = True
+                    if spec_line:
+                        found = find_file(og_content, spec_line, strings, total_strings=True)
+                    if found:
+                        if get_lines:
+                            lines = find_lines(
+                                og_content,
+                                strings=strings,
+                                total_strings=False,
+                                normalize=True,
+                                any_per_line=True
+                            )
+                            if lines:
+                                file_path = {"file_path": file_path, "lines": lines}
+                        found_paths.append(file_path)
+                        break
+    return found_paths
+def return_function(start_dir=None,preferred_dir=None,basenames=None,functionName=None):
+    if basenames:
+        basenames = make_list(basenames)
+        abstract_file_finder = AbstractFileFinderImporter(start_dir=start_dir,preferred_dir=preferred_dir)
+        paths = abstract_file_finder.find_paths(basenames)
+        func = abstract_file_finder.import_function_from_path(paths[0], functionName)
+        return func
+def getLineNums(file_path):
+    lines=[]
+    if file_path and isinstance(file_path,dict):
+        lines = file_path.get('lines')
+        file_path = file_path.get('file_path')
+    return file_path,lines
+def get_line_content(obj):
+    line,content=None,None
+    if obj and isinstance(obj,dict):
+        line=obj.get('line')
+        content = obj.get('content')
+    #print(f"line: {line}\ncontent: {content}")
+    return line,content
+def get_edit(file_path):
+    if file_path and os.path.isfile(file_path):
+        os.system(f"code {file_path}")
+        input()
+def editLines(file_paths):
+    for file_path in file_paths:
+        file_path,lines = getLineNums(file_path)
+        for obj in lines:
+            line,content = get_line_content(obj)
+        get_edit(file_path)
+def findContentAndEdit(*args,
+    strings: list=[],
+    total_strings=True,
+    parse_lines=False,
+    spec_line=False,
+    get_lines=True,
+    edit_lines=False,
+    diffs=False,
+    **kwargs
+    ):
+    file_paths = findContent(
+        *args,
+        strings=strings,
+        total_strings=total_strings,
+        parse_lines=parse_lines,
+        spec_line=spec_line,
+        get_lines=get_lines,
+        diffs=diffs,
+        **kwargs
+        )
+    if edit_lines:
+        editLines(file_paths)
+    return file_paths
+

abstract_utilities/file_utils/src/initFunctionsGen.py

@@ -1,8 +1,10 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-from .find_collect import *
+from .find_collect import get_files_and_dirs
 from ..imports import *
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)
 
 def caller_path():
     frame = inspect.stack()[1]
@@ -209,28 +211,37 @@ def get_for_all_tabs(root = None):
     root = root or caller_path()
     if os.path.isfile(root):
         root = os.path.dirname(root)
-    all_tabs = get_dirs(root = root)
+    all_tabs = get_files_and_dirs(root,allowed_patterns='*Tab')[0]
+    
     for ROOT in all_tabs:
-        FUNCS_DIR = ifFunctionsInFile(ROOT)
-        if FUNCS_DIR == None:
-            for ROOT in get_dirs(root = ROOT):
-                apply_inits(ROOT)
-        else: 
-            apply_inits(ROOT)
+        if os.path.isdir(ROOT):
+            [apply_inits(os.path.join(ROOT,func)) for func in os.listdir(ROOT) if 'functions'  == os.path.splitext(func)[0]]
+        
+      
             
 
 def apply_inits(ROOT):
-    FUNCS_DIR = ifFunctionsInFile(ROOT)
-
-    
-    if_fun_dir = isDir(FUNCS_DIR)
-    if if_fun_dir != None:
-        
-        if if_fun_dir:
-           filepaths = collect_filepaths(FUNCS_DIR,allowed_exts='.py',add=True)
+        filepaths=[ROOT]
+        TAB_DIR = os.path.dirname(ROOT)
+        INIT_FUNCS_PAPTH = os.path.join(TAB_DIR, "initFuncs.py")
+        if_fun_dir=False
+##        if os.path.isfile(ROOT):
+##            dirname= os.path.dirname(ROOT)
+##            basename= os.path.basename(ROOT)
+##            functions_dir = os.path.join(dirname,'functions')
+##            functions_path = os.path.join(functions_dir,basename)
+##            input(get_clean_imports(ROOT))
+##            
+##            os.makedirs(functions_dir,exist_ok=True)
+##            shutil.move(ROOT,functions_path)
+##            ROOT=functions_dir
+        if os.path.isdir(ROOT):
+            INIT_PATH = os.path.join(ROOT, "__init__.py")
             
-        else:
-            filepaths = [FUNCS_DIR]
+            filepaths = get_files_and_dirs(directory=ROOT,allowed_exts='py',add=True)[-1]
+            if_fun_dir=True
+    
+   
         
         # Parse top-level def names
         def extract_funcs(path: str):
@@ -240,7 +251,7 @@ def apply_inits(ROOT):
                 if m:
                     funcs.append(m.group(1))
             return funcs
-
+        
         # Build functions/__init__.py that re-exports all discovered functions
         import_lines = []
         all_funcs = []
@@ -252,7 +263,7 @@ def apply_inits(ROOT):
                 all_funcs.extend(funcs)
         if if_fun_dir:
             functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
-            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
+            write_to_file(contents=functions_init, file_path=INIT_PATH)
 
         # Prepare the tuple literal of function names for import + loop
         uniq_funcs = sorted(set(all_funcs))
@@ -261,9 +272,10 @@ def apply_inits(ROOT):
         # Generate apiConsole/initFuncs.py using the safer setattr-loop
         init_funcs_src = textwrap.dedent(f"""\
             
-
+            
+            from abstract_utilities import get_logFile
             from .functions import ({func_tuple})
-
+            logger=get_logFile(__name__)
             def initFuncs(self):
                 try:
                     for f in ({func_tuple}):
@@ -273,8 +285,9 @@ def apply_inits(ROOT):
                 return self
         """)
 
-        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
+        write_to_file(contents=init_funcs_src, file_path=INIT_FUNCS_PAPTH)
 
 def call_for_all_tabs():
     root = get_caller_dir(2)
+    
     get_for_all_tabs(root)