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

abstract_utilities/file_utils/src/find_collect.py

@@ -1,79 +1,15 @@
 from ..imports import *
-from .filter_params import *
-from .file_filters import enumerate_source_files
+from .file_filters import *
 from pathlib import Path
 from typing import Optional, List, Set
 
-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"
 
 
 
 
 def get_find_cmd(
-    directory: str,
-    *,
-    cfg: Optional["ScanConfig"] = None,
-    *,
-    allowed_exts: Optional[Set[str]] = False,
-    unallowed_exts: Optional[Set[str]] = False,
-    allowed_types: Optional[Set[str]] = False,
-    exclude_types: Optional[Set[str]] = False,
-    allowed_dirs: Optional[List[str]] = False,
-    exclude_dirs: Optional[List[str]] = False,
-    allowed_patterns: Optional[List[str]] = False,
-    exclude_patterns: Optional[List[str]] = False,
+    *args,
     mindepth: Optional[int] = None,
     maxdepth: Optional[int] = None,
     depth: Optional[int] = None,
@@ -86,14 +22,23 @@ def get_find_cmd(
     **kwargs
 ) -> str:
     """
-    Construct a Unix `find` command string from cfg and explicit keyword args.
-
-    - Honors allowed/excluded patterns, dirs, and extensions from ScanConfig.
-    - Automatically applies mindepth/maxdepth/depth/file_type filters.
+    Construct a Unix `find` command string that supports multiple directories.
+    Accepts filtering via ScanConfig-compatible kwargs.
     """
-    cmd = [f"find {shlex.quote(directory)}"]
+    # Normalize inputs into canonical form
+    kwargs = get_safe_canonical_kwargs(*args, **kwargs)
+    cfg = kwargs.get('cfg') or define_defaults(**kwargs)
 
-    # --- depth ---
+    # Get directory list (may come from args or kwargs)
+    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 kwargs["directories"])
+    cmd = [f"find {dir_expr}"]
+
+    # --- depth filters ---
     if depth is not None:
         cmd += [f"-mindepth {depth}", f"-maxdepth {depth}"]
     else:
@@ -106,7 +51,7 @@ def get_find_cmd(
     if file_type in ("f", "d"):
         cmd.append(f"-type {file_type}")
 
-    # --- base attributes ---
+    # --- basic attributes ---
     if name:
         cmd.append(f"-name {shlex.quote(name)}")
     if size:
@@ -117,63 +62,53 @@ def get_find_cmd(
         cmd.append(f"-perm {shlex.quote(perm)}")
     if user:
         cmd.append(f"-user {shlex.quote(user)}")
-    cfg = cfg or define_defaults(
-            allowed_exts = allowed_exts,
-            unallowed_exts = unallowed_exts,
-            allowed_types = allowed_types,
-            exclude_types = exclude_types,
-            allowed_dirs = allowed_dirs,
-            exclude_dirs = exclude_dirs,
-            allowed_patterns = allowed_patterns,
-            exclude_patterns = exclude_patterns,
-            add = add
-        )
+
     # --- cfg-based filters ---
     if cfg:
-        # allowed extensions
+        # Allowed extensions
         if cfg.allowed_exts and cfg.allowed_exts != {"*"}:
             ext_expr = " -o ".join(
                 [f"-name '*{e}'" for e in cfg.allowed_exts if e]
             )
             cmd.append(f"\\( {ext_expr} \\)")
 
-        # disallowed extensions
-        if cfg.unallowed_exts:
-            for e in cfg.unallowed_exts:
+        # Excluded extensions
+        if cfg.exclude_exts:
+            for e in cfg.exclude_exts:
                 cmd.append(f"! -name '*{e}'")
 
-        # allowed directories (match any path)
+        # Allowed directories
         if cfg.allowed_dirs and cfg.allowed_dirs != ["*"]:
             dir_expr = " -o ".join(
                 [f"-path '*{d}*'" for d in cfg.allowed_dirs if d]
             )
             cmd.append(f"\\( {dir_expr} \\)")
 
-        # exclude directories
+        # Excluded directories
         if cfg.exclude_dirs:
             for d in cfg.exclude_dirs:
                 cmd.append(f"! -path '*{d}*'")
 
-        # allowed patterns
+        # Allowed patterns
         if cfg.allowed_patterns and cfg.allowed_patterns != ["*"]:
             pat_expr = " -o ".join(
                 [f"-name '{p}'" for p in cfg.allowed_patterns if p]
             )
             cmd.append(f"\\( {pat_expr} \\)")
 
-        # exclude patterns
+        # Excluded patterns
         if cfg.exclude_patterns:
             for p in cfg.exclude_patterns:
                 cmd.append(f"! -name '{p}'")
 
-        # allowed types
+        # Allowed types (semantic, not `-type`)
         if cfg.allowed_types and cfg.allowed_types != {"*"}:
             type_expr = " -o ".join(
                 [f"-path '*{t}*'" for t in cfg.allowed_types if t]
             )
             cmd.append(f"\\( {type_expr} \\)")
 
-        # excluded types
+        # Excluded types
         if cfg.exclude_types:
             for t in cfg.exclude_types:
                 cmd.append(f"! -path '*{t}*'")
@@ -183,24 +118,12 @@ def get_find_cmd(
 
 
 def collect_globs(
-    directory: str,
-    cfg: Optional["ScanConfig"] = None,
-    *,
-    allowed_exts: Optional[Set[str]] = False,
-    unallowed_exts: Optional[Set[str]] = False,
-    allowed_types: Optional[Set[str]] = False,
-    exclude_types: Optional[Set[str]] = False,
-    allowed_dirs: Optional[List[str]] = False,
-    exclude_dirs: Optional[List[str]] = False,
-    allowed_patterns: Optional[List[str]] = False,
-    exclude_patterns: Optional[List[str]] = False,
-    patterns: Optional[List[str]] = None,
+    *args,
     mindepth: Optional[int] = None,
     maxdepth: Optional[int] = None,
     depth: Optional[int] = None,
     file_type: Optional[str] = None,   # "f", "d", or None
-    user_at_host: Optional[str] = None,
-    add: bool = False,
+    allowed: Optional[Callable[[str], bool]] = None,
     **kwargs
 ) -> List[str] | dict:
     """
@@ -210,61 +133,58 @@ def collect_globs(
     - If file_type is "f" or "d" → returns a list of that type
     - Supports SSH mode via `user_at_host`
     """
-    cfg = cfg or define_defaults(
-            allowed_exts = allowed_exts,
-            unallowed_exts = unallowed_exts,
-            allowed_types = allowed_types,
-            exclude_types = exclude_types,
-            allowed_dirs = allowed_dirs,
-            exclude_dirs = exclude_dirs,
-            allowed_patterns = allowed_patterns,
-            exclude_patterns = exclude_patterns,
-            add = add
-        )
-    allowed = allowed or make_allowed_predicate(cfg)
-    directory = str(directory)
-
-    # Remote path (SSH)
-    if 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"] = kwargs.get('cfg') or define_defaults(**kwargs)
+    
+    type_strs = {"f":"files","d":"dirs"}
+    file_type = get_proper_type_str(file_type)
+    file_types = make_list(file_type)
+    if file_type == None:
+        file_types = ["f","d"]
+    return_results = {}
+    return_result=[]
+    for file_type in file_types:
+        type_str = type_strs.get(file_type)
+        # Remote path (SSH)
         find_cmd = get_find_cmd(
-            directory,
-            cfg=cfg,
-            mindepth=mindepth,
-            maxdepth=maxdepth,
-            depth=depth,
-            file_type=file_type,
-            **{k: v for k, v in kwargs.items() if v},
-        )
-        return run_cmd(find_cmd, user_at_host=user_at_host)
-
-    # Local path (Python-native walk)
-    root = Path(directory)
-    results_js = {"f": [], "d": []}
-
-    for p in root.rglob("*"):
-        if p.is_file():
-            kind = "f"
-        elif p.is_dir():
-            kind = "d"
-        else:
-            continue
-
-        # If file_type is specified, skip the other kind
-        if file_type and kind != file_type:
-            continue
-
-        if exts and kind == "f" and p.suffix.lower() not in exts:
-            continue
-
-        if patterns and not any(p.match(pat) for pat in patterns):
-            continue
-
-        results_js[kind].append(str(p))
-
-    # Return based on selection
-    if file_type is None:
-        return results_js
-    else:
-        return results_js[file_type]
-
-
+            directories=kwargs.get("directories"),
+            cfg=kwargs.get('cfg'),
+                mindepth=mindepth,
+                maxdepth=maxdepth,
+                depth=depth,
+                file_type=file_type,
+                **user_pass_host_key,
+            )
+        result = run_pruned_func(run_cmd,find_cmd,
+            **kwargs
+            
+            )
+        return_result = [res for res in result.split('\n') if res]
+        return_results[type_str]=return_result
+    if len(file_types) == 1:
+        return return_result
+    return return_results
+def get_files_and_dirs(
+    *args,
+    recursive: bool = True,
+    include_files: bool = True,
+    **kwargs
+    ):
+    if recursive == False:
+        kwargs['maxdepth']=1
+    if include_files == False:
+        kwargs['file_type']='d'
+    result = collect_globs(*args,**kwargs)
+    if include_files == False:
+        return result,[]
+    dirs = result.get("dirs")
+    files = result.get("files")
+    return dirs,files
+def collect_filepaths(
+    *args,
+    **kwargs
+    ) -> List[str]:
+    kwargs['file_type']='f'
+    return collect_globs(*args,**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,10 +1,11 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-from .file_utils import define_defaults,get_files_and_dirs
+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]
     return os.path.abspath(frame.filename)
@@ -210,33 +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:
-            CFG = define_defaults(allowed_exts='.py',
-                unallowed_exts = True,
-                exclude_types = True,
-                exclude_dirs = True,
-                exclude_patterns = True)
-            _,filepaths = get_files_and_dirs(FUNCS_DIR,cfg=CFG)
+        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):
@@ -246,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 = []
@@ -258,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))
@@ -267,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}):
@@ -279,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)