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

abstract_utilities/file_utils/src/filter_params.py

@@ -0,0 +1,197 @@
+
+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)
+# -------------------------
+# Utility functions
+# -------------------------
+
+def _normalize_listlike(value, typ=list, sep=','):
+    """Normalize comma-separated or iterable values into the desired type."""
+    if value in [True, None, False]:
+        return value
+    if isinstance(value, str):
+        value = [v.strip() for v in value.split(sep) if v.strip()]
+    return typ(value)
+
+def ensure_exts(exts):
+    if exts in [True, None, False]:
+        return exts
+    out = []
+    for ext in _normalize_listlike(exts, list):
+        if not ext.startswith('.'):
+            ext = f".{ext}"
+        out.append(ext)
+    return set(out)
+
+def ensure_patterns(patterns):
+    """Normalize pattern list and ensure they are valid globs."""
+    if patterns in [True, None, False]:
+        return patterns
+    patterns = _normalize_listlike(patterns, list)
+    out = []
+    for pattern in patterns:
+        if not pattern:
+            continue
+        if '*' not in pattern and '?' not in pattern:
+            # Implicitly make it a prefix match
+            if pattern.startswith('.') or pattern.startswith('~'):
+                pattern = f"*{pattern}"
+            else:
+                pattern = f"{pattern}*"
+        out.append(pattern)
+    return out
+
+
+def _get_default_modular(value, default, add=False, typ=set):
+    """Merge user and default values intelligently."""
+    if value == None:
+        value = add
+    if value in [True]:
+        return default
+    if value is False:
+        return value
+    if add:
+        return combine_params(value,default,typ=None)
+
+    return typ(value)
+
+# -------------------------
+# Default derivation logic
+# -------------------------
+def _get_default_modular(value, default, add=None, typ=set):
+    """Merge user and default values intelligently."""
+    add = add or False
+    if value == None:
+        value = add
+    if value in [True]:
+        return default
+    if value is False:
+        return value
+    if add:
+        return combine_params(value,default,typ=None)
+    return typ(value)
+def derive_all_defaults(**kwargs):
+    kwargs = get_safe_canonical_kwargs(**kwargs)
+    add = kwargs.get("add",False)
+    nu_defaults = {}
+    for key,values in DEFAULT_CANONICAL_MAP.items():
+        default = values.get("default")
+        typ = values.get("type")
+        key_value = kwargs.get(key)
+        if key in DEFAULT_ALLOWED_EXCLUDE_MAP:
+
+            if key.endswith('exts'):
+                input_value = ensure_exts(key_value)
+            if key.endswith('patterns'):
+                input_value = ensure_patterns(key_value)
+            else:
+                input_value = _normalize_listlike(key_value, typ)
+            nu_defaults[key] = _get_default_modular(input_value, default, add, typ)
+        else:
+            value = default if key_value is None else key_value
+            if typ == list:
+                value = make_list(value)
+            elif typ == bool:
+                value = bool(value)
+            nu_defaults[key] = value
+   
+    return nu_defaults
+# -------------------------
+# Default derivation logic
+# -------------------------
+def derive_file_defaults(**kwargs):
+    kwargs = derive_all_defaults(**kwargs)
+    add = kwargs.get("add",False)
+    nu_defaults = {}
+    for key,values in DEFAULT_ALLOWED_EXCLUDE_MAP.items():
+        default = values.get("default")
+        typ = values.get("type")
+        key_value = kwargs.get(key)
+        if key.endswith('exts'):
+            input_value = ensure_exts(key_value)
+        if key.endswith('patterns'):
+            input_value = ensure_patterns(key_value)
+        else:
+            input_value = _normalize_listlike(key_value, typ)
+        nu_defaults[key] = _get_default_modular(input_value, default, add, typ)
+    return nu_defaults
+
+def define_defaults(**kwargs):
+    defaults = derive_file_defaults(**kwargs)
+    return ScanConfig(**defaults)

abstract_utilities/file_utils/src/find_collect.py

@@ -0,0 +1,200 @@
+from ..imports import *
+from .file_filters import *
+from pathlib import Path
+from typing import Optional, List, Set
+
+
+
+
+
+
+def get_find_cmd(
+    *args,
+    mindepth: Optional[int] = None,
+    maxdepth: Optional[int] = None,
+    depth: Optional[int] = None,
+    file_type: Optional[str] = None,  # 'f' or 'd'
+    name: Optional[str] = None,
+    size: Optional[str] = None,
+    mtime: Optional[str] = None,
+    perm: Optional[str] = None,
+    user: Optional[str] = None,
+    **kwargs
+) -> str:
+    """
+    Construct a Unix `find` command string that supports multiple directories.
+    Accepts filtering via ScanConfig-compatible kwargs.
+    """
+    # Normalize inputs into canonical form
+    kwargs = get_safe_canonical_kwargs(*args, **kwargs)
+    cfg = kwargs.get('cfg') or define_defaults(**kwargs)
+
+    # 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:
+        if mindepth is not None:
+            cmd.append(f"-mindepth {mindepth}")
+        if maxdepth is not None:
+            cmd.append(f"-maxdepth {maxdepth}")
+
+    # --- file type ---
+    if file_type in ("f", "d"):
+        cmd.append(f"-type {file_type}")
+
+    # --- basic attributes ---
+    if name:
+        cmd.append(f"-name {shlex.quote(name)}")
+    if size:
+        cmd.append(f"-size {shlex.quote(size)}")
+    if mtime:
+        cmd.append(f"-mtime {shlex.quote(mtime)}")
+    if perm:
+        cmd.append(f"-perm {shlex.quote(perm)}")
+    if user:
+        cmd.append(f"-user {shlex.quote(user)}")
+
+    # --- cfg-based filters ---
+    if cfg:
+        # 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} \\)")
+
+        # Excluded extensions
+        if cfg.exclude_exts:
+            for e in cfg.exclude_exts:
+                cmd.append(f"! -name '*{e}'")
+
+        # 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} \\)")
+
+        # Excluded directories
+        if cfg.exclude_dirs:
+            for d in cfg.exclude_dirs:
+                cmd.append(f"! -path '*{d}*'")
+
+        # 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} \\)")
+
+        # Excluded patterns
+        if cfg.exclude_patterns:
+            for p in cfg.exclude_patterns:
+                cmd.append(f"! -name '{p}'")
+
+        # 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
+        if cfg.exclude_types:
+            for t in cfg.exclude_types:
+                cmd.append(f"! -path '*{t}*'")
+
+    return " ".join(cmd)
+
+
+
+def collect_globs(
+    *args,
+    mindepth: Optional[int] = None,
+    maxdepth: Optional[int] = None,
+    depth: Optional[int] = None,
+    file_type: Optional[str] = None,   # "f", "d", or None
+    allowed: Optional[Callable[[str], bool]] = None,
+    **kwargs
+) -> List[str] | dict:
+    """
+    Collect file or directory paths recursively.
+
+    - If file_type is None → returns {"f": [...], "d": [...]}
+    - 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"] = 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(
+            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)
+
+def get_filename(path):
+    basename = os.path.basename(path)
+    filename,ext = os.path.splitext(basename)
+    return filename
+def find_files(filename,directory=None,add=None):
+    add = if_not_bool_default(add,default=True)
+    directory = directory or os.getcwd()
+    dirs,files = get_files_and_dirs(directory,add=add)
+    return [file for file in files if get_filename(file) == filename]

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
+