abstract-paths 0.0.0.14__tar.gz

abstract_paths-0.0.0.14/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: abstract_paths
+Version: 0.0.0.14
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: flask
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# Unknown Package (vUnknown Version)
+
+No description available
+
+## Installation
+
+```bash
+pip install Unknown Package
+```
+
+## Dependencies
+
+None
+
+## Modules
+
+### src/abstract_paths/abstractFileImporter.py
+
+Description of script based on prompt: You are analyzing a Python script 'abstractFileImp (mock response)
+
+### src/abstract_paths/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_paths/getnu.py
+
+Description of script based on prompt: You are analyzing a Python script 'getnu.py' locat (mock response)
+

abstract_paths-0.0.0.14/README.md

@@ -0,0 +1,28 @@
+# Unknown Package (vUnknown Version)
+
+No description available
+
+## Installation
+
+```bash
+pip install Unknown Package
+```
+
+## Dependencies
+
+None
+
+## Modules
+
+### src/abstract_paths/abstractFileImporter.py
+
+Description of script based on prompt: You are analyzing a Python script 'abstractFileImp (mock response)
+
+### src/abstract_paths/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_paths/getnu.py
+
+Description of script based on prompt: You are analyzing a Python script 'getnu.py' locat (mock response)
+

abstract_paths-0.0.0.14/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

abstract_paths-0.0.0.14/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abstract_paths-0.0.0.14/setup.py

@@ -0,0 +1,30 @@
+import setuptools
+import os
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name='abstract_paths',
+    version='0.0.0.14',
+    author='putkoff',
+    author_email='partners@abstractendeavors.com',
+    description="",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.11',
+    ],
+    install_requires=['flask'],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.6",
+    # Add this line to include wheel format in your distribution
+    setup_requires=['wheel'],
+    include_package_data=True,  # Include package data specified in MANIFEST.in
+
+)

abstract_paths-0.0.0.14/src/abstract_paths/__init__.py

@@ -0,0 +1,7 @@
+from .directory_reader import *
+from .file_handlers import *
+from .file_filtering import *
+from .content_utils import *
+from .directory_reader import *
+from .file_filtering import *
+from .AbstractFileFinderImporter import *

abstract_paths-0.0.0.14/src/abstract_paths/abstractFileImporter.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import importlib.util
+from abstract_utilities import *
+class AbstractFileFinderImporter:
+    def __init__(self, start_dir=None, preferred_dir=None):
+        start_dir = start_dir or '.'
+        self.start_dir = os.path.abspath(start_dir)
+        self.preferred_dir = os.path.abspath(preferred_dir) if preferred_dir else None
+
+    def find_paths(self, basenames):
+        """
+        Finds all paths to files with the given basename(s) starting from start_dir.
+        """
+        if isinstance(basenames, str):
+            basenames = [basenames]
+
+        matching_paths = []
+
+        for root, dirs, files in os.walk(self.start_dir):
+            found_files = set(basenames).intersection(files)
+            for basename in found_files:
+                full_path = os.path.join(root, basename)
+                matching_paths.append(full_path)
+
+        # Remove duplicates and sort paths by distance from start_dir
+        matching_paths = list(set(matching_paths))
+        matching_paths.sort(key=lambda path: self._compute_distance(path))
+
+        return matching_paths
+
+    def _compute_distance(self, path):
+        path = os.path.abspath(path)
+        if self.preferred_dir and os.path.commonpath([self.preferred_dir, path]) == self.preferred_dir:
+            return -1000 + self._path_length(path)
+
+        relative_path = os.path.relpath(path, self.start_dir)
+        distance = len(relative_path.split(os.sep))
+
+        return distance
+
+    def _path_length(self, path):
+        return len(path.split(os.sep))
+
+    def import_module_from_path(self, module_path):
+        """
+        Dynamically imports a module from a given file path, handling relative imports within the module.
+        """
+        module_name = os.path.splitext(os.path.basename(module_path))[0]
+        spec = importlib.util.spec_from_file_location(module_name, module_path)
+        module = importlib.util.module_from_spec(spec)
+
+        # Add the module's directory and any necessary subdirectories to sys.path temporarily
+        module_dir = os.path.dirname(module_path)
+        original_sys_path = list(sys.path)
+        sys.path.insert(0, module_dir)
+
+        # If `scripts` exists in the module directory, add it to sys.path
+        scripts_dir = os.path.join(module_dir, 'scripts')
+        if os.path.isdir(scripts_dir):
+            sys.path.insert(0, scripts_dir)
+
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            raise ImportError(f"Failed to import module {module_name}: {e}")
+        finally:
+            sys.path = original_sys_path  # Restore original sys.path
+
+        return module
+
+    def import_function_from_path(self, module_path, function_name):
+        """
+        Imports a specific function from a module file path.
+        """
+        module = self.import_module_from_path(module_path)
+        if not hasattr(module, function_name):
+            raise AttributeError(f"Function {function_name} not found in module {module.__name__}")
+
+        return getattr(module, function_name)
+
+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

abstract_paths-0.0.0.14/src/abstract_paths/content_utils/__init__.py

@@ -0,0 +1 @@
+from .src import *

abstract_paths-0.0.0.14/src/abstract_paths/content_utils/imports.py

@@ -0,0 +1 @@
+from ..file_handlers.file_readers import read_any_file

abstract_paths-0.0.0.14/src/abstract_paths/content_utils/src/__init__.py

@@ -0,0 +1,6 @@
+from .file_utils import * 
+from .find_content import (
+    findContent,
+    find_file,
+    get_content,
+    stringInContents)

abstract_paths-0.0.0.14/src/abstract_paths/content_utils/src/file_utils.py

@@ -0,0 +1,233 @@
+import os
+import glob
+from typing import Optional, Union, List, Dict
+from collections import defaultdict
+
+def normalize_paths(paths: Optional[Union[bool, str]] = True) -> str:
+    """
+    Normalize the paths parameter for glob pattern.
+    
+    - If True, returns '**' for recursive search.
+    - If False or None, returns '_' (non-recursive placeholder).
+    - If str, returns the provided string.
+    
+    Args:
+        paths: The paths specification.
+    
+    Returns:
+        Normalized paths string.
+    """
+    if paths is True:
+        return '**'
+    elif paths in (False, None):
+        return '_'
+    elif isinstance(paths, str):
+        return paths
+    raise ValueError(f"Invalid paths value: {paths}")
+
+def normalize_extensions(exts: Optional[Union[bool, str, List[str]]] = True) -> str:
+    """
+    Normalize the extensions parameter for glob pattern.
+    
+    - If True, returns '*' for all files.
+    - If False or None, returns '_' (no extension filter).
+    - If str starting with '.', returns '*{exts}'.
+    - If str without '.', assumes it's the extension and adds '.'.
+    - If list of str, returns '*.' + '{ext1,ext2,...}' for multiple extensions.
+    
+    Args:
+        exts: The extensions specification.
+    
+    Returns:
+        Normalized extensions string.
+    """
+    if exts is True:
+        return '*'
+    elif exts in (False, None):
+        return '_'
+    elif isinstance(exts, str):
+        if exts.startswith('.'):
+            return f"*{exts}"
+        else:
+            return f"*.{exts}"
+    elif isinstance(exts, list):
+        if not exts:
+            return '*'
+        normalized = [e.lstrip('.') for e in exts]
+        return "*." + "{" + ",".join(normalized) + "}"
+    raise ValueError(f"Invalid exts value: {exts}")
+
+def build_glob_pattern(
+    directory: str,
+    paths: Optional[Union[bool, str]] = True,
+    exts: Optional[Union[bool, str, List[str]]] = True
+) -> str:
+    """
+    Build the full glob search pattern by joining directory, paths, and extensions.
+    
+    Args:
+        directory: The base directory to search in.
+        paths: The paths specification (see normalize_paths).
+        exts: The extensions specification (see normalize_extensions).
+    
+    Returns:
+        The complete glob pattern string.
+    """
+    norm_paths = normalize_paths(paths)
+    norm_exts = normalize_extensions(exts)
+    return os.path.join(directory, norm_paths, norm_exts)
+
+def findGlobFiles(
+    directory: str,
+    paths: Optional[Union[bool, str]] = True,
+    exts: Optional[Union[bool, str, List[str]]] = True,
+    recursive: bool = True
+) -> List[str]:
+    """
+    Find files in the directory using glob based on the provided patterns.
+    
+    This is the main entry point for file searching. It builds the glob pattern
+    and performs the search.
+    
+    Args:
+        directory: The base directory to search in.
+        paths: The paths specification (see normalize_paths).
+        exts: The extensions specification (see normalize_extensions).
+        recursive: Whether to search recursively (affects glob behavior).
+    
+    Returns:
+        List of matching file paths.
+    """
+    search_pattern = build_glob_pattern(directory, paths, exts)
+    return glob.glob(search_pattern, recursive=recursive)
+def get_e_normalized(f,exts):
+    norm_exts = normalize_extensions(exts)
+    if norm_exts == '_':
+        return True
+    norm_exts_spl = norm_exts.lstrip('*').split(',')
+    lstrip_exts = [norm_exts.lstrip('*.')]
+    brak_in_exts = '{' in norm_exts
+    def get_strip(f,e,norm_exts_spl,lstrip_exts,brak_in_exts):
+        if brak_in_exts:
+            f.endswith(e.lstrip('*.'))
+        return lstrip_exts
+    if any(get_strip(f,e,norm_exts_spl,lstrip_exts,brak_in_exts) for e in norm_exts_spl):
+         return True
+    return False
+def build_directory_tree(
+    directory: str,
+    paths: Optional[Union[bool, str]] = True,
+    exts: Optional[Union[bool, str, List[str]]] = True,
+    recursive: bool = True,
+    include_files: bool = True,
+    prefix: str = ""
+) -> str:
+    """
+    Generate a text-based tree map of the directory structure.
+    
+    This function uses os.walk to traverse the directory and builds a 
+    printable tree string that represents the hierarchy. It can filter 
+    files based on extensions if provided. The output is designed to be 
+    easily copied to the clipboard for quick inspection of the dir structure.
+    
+    Args:
+        directory: The base directory to map.
+        paths: The paths specification (influences recursion if not True).
+        exts: The extensions to include (if include_files=True).
+        recursive: Whether to traverse recursively.
+        include_files: Whether to include files in the tree (True) or just dirs (False).
+        prefix: Internal prefix for indentation in recursive calls.
+    
+    Returns:
+        A string representation of the directory tree.
+    """
+    tree_str = []
+    directory = os.path.abspath(directory)
+    base_name = os.path.basename(directory)
+    tree_str.append(f"{prefix}{base_name}/")
+    
+    if not recursive:
+        # Non-recursive: just list immediate contents
+        contents = os.listdir(directory)
+        dirs = [d for d in contents if os.path.isdir(os.path.join(directory, d))]
+        files = [f for f in contents if os.path.isfile(os.path.join(directory, f))]
+        
+        for i, d in enumerate(sorted(dirs)):
+            is_last = (i == len(dirs) - 1) and not files
+            tree_str.append(f"{prefix}{'└── ' if is_last else '├── '}{d}/")
+        
+        if include_files:
+            norm_exts = normalize_extensions(exts).lstrip('*')  # For simple filtering
+            for i, f in enumerate(sorted(files)):
+                if norm_exts != '_' and not f.endswith(tuple(norm_exts.split(',')) if '{' in norm_exts else (norm_exts,)):
+                    continue
+                is_last = (i == len(files) - 1)
+                tree_str.append(f"{prefix}{'└── ' if is_last else '├── '}{f}")
+    else:
+        # Recursive: use os.walk
+        file_list = findGlobFiles(directory, paths, exts, recursive=True) if include_files else []
+        dir_structure: Dict[str, List[str]] = defaultdict(list)
+        
+        # Build dir -> subdirs/files mapping
+        for root, dirs, files in os.walk(directory):
+            rel_root = os.path.relpath(root, directory)
+            if rel_root != '.':
+                parent = os.path.dirname(rel_root)
+                dir_structure[parent].append(os.path.basename(rel_root) + '/')
+            
+            if include_files:
+                filtered_files = [f for f in files if get_e_normalized(f,exts)]
+                dir_structure[rel_root].extend(filtered_files)
+        if normalize_extensions(exts) == '_':
+            return True
+        
+        
+        # Recursive tree builder
+        def _build_tree(current: str, prefix: str, structure: Dict[str, List[str]]) -> List[str]:
+            lines = []
+            contents = sorted(structure.get(current, []))
+            for i, item in enumerate(contents):
+                is_last = (i == len(contents) - 1)
+                new_prefix = prefix + ('    ' if is_last else '│   ')
+                connector = '└── ' if is_last else '├── '
+                
+                lines.append(f"{prefix}{connector}{item}")
+                
+                if item.endswith('/'):
+                    sub_path = os.path.join(current, item.rstrip('/')) if current != '.' else item.rstrip('/')
+                    lines.extend(_build_tree(sub_path, new_prefix, structure))
+            return lines
+        
+        tree_str.extend(_build_tree('.', prefix + '│   ', dir_structure))
+    
+    return '\n'.join(tree_str)
+
+def get_directory_map(
+    directory: str,
+    paths: Optional[Union[bool, str]] = True,
+    exts: Optional[Union[bool, str, List[str]]] = True,
+    recursive: bool = True,
+    include_files: bool = True
+) -> str:
+    """
+    Public entry point to get a copyable directory map string.
+    
+    This wraps build_directory_tree to provide a simple API for generating
+    and returning the tree string, which can be printed or copied to clipboard.
+    
+    Example usage:
+    map_str = get_directory_map('/path/to/dir')
+    print(map_str)  # Or copy to clipboard via pyperclip or similar
+    
+    Args:
+        directory: The base directory to map.
+        paths: The paths specification.
+        exts: The extensions to include.
+        recursive: Whether to map recursively.
+        include_files: Whether to include files in the map.
+    
+    Returns:
+        The directory tree as a string.
+    """
+    return build_directory_tree(directory, paths, exts, recursive, include_files)
+

abstract_paths-0.0.0.14/src/abstract_paths/content_utils/src/find_content.py

@@ -0,0 +1,69 @@
+from .file_utils import findGlobFiles
+from ..imports import *
+def stringInContent(
+            content,
+            strings,
+            total_strings=False
+        ):
+    found = [string for string in strings if string in content]
+    if found:
+        if total_strings:
+            if len(strings) == len(found):
+                return True
+            return False
+        return True
+    return 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 content or []
+def find_file(content,spec_line,strings,total_strings=False):
+   lines = content.split('\n')
+   if len(lines) >= spec_line:
+       return stringInContent(
+            lines[spec_line],
+            strings,
+            total_strings=total_strings
+            )
+   return False   
+def findContent(directory: str,
+                paths: Optional[Union[bool, str]] = True,
+                exts: Optional[Union[bool, str, List[str]]] = True,
+                recursive: bool = True,
+                strings: list=[]
+                total_strings=False,
+                parse_lines=False,
+                spec_lines=False
+                ):
+    found_paths = []
+    globFiles = findGlobFiles(directory,paths,exts,recursive)
+    for file_path in globFiles:
+        if file_path:
+            og_content or read_any_file(full_path)
+            contents = get_contents(
+                    full_path,
+                    parse_lines=parse_lines,
+                    content = og_content
+                    )
+            found = False
+            for content in contents:
+                if stringInContent(content, strings,total_strings):
+                    found = True
+                    if spec_line != False and isinstance(spec_line,int):
+                        found = find_file(og_content,
+                                          spec_line,
+                                          strings,
+                                          total_strings=total_strings)
+                    if found:  
+                        found_paths.append(file_path)
+                        break
+                
+    return found_paths

abstract_paths-0.0.0.14/src/abstract_paths/directory_reader/__init__.py

@@ -0,0 +1 @@
+from .directory_reader import *

abstract_paths-0.0.0.14/src/abstract_paths/directory_reader/directory_reader.py

@@ -0,0 +1,67 @@
+import os
+from typing import *
+from ..file_filtering import *
+from ..file_handlers import *
+# ─── Example walker ──────────────────────────────────────────────────────────
+_logger = get_logFile(__name__)
+
+def read_files(files=None,allowed=None):
+    allowed = allowed or make_allowed_predicate()
+    files = get_all_files(make_list(files or []),allowed)
+    collected = {}
+    for full_path in files:
+        ext = Path(full_path).suffix.lower()
+
+        # ——— 1) Pure-text quick reads —————————————
+        if ext in {'.txt', '.md', '.csv', '.tsv', '.log'}:
+            try:
+                with open(full_path, 'r', encoding='utf-8', errors='replace') as f:
+                    collected[full_path] = f.read()
+            except Exception as e:
+                _logger.warning(f"Failed to read {full_path} as text: {e}")
+            continue
+
+        # ——— 2) Try your DataFrame loader ——————————
+        try:
+            df_or_map = get_df(full_path)
+            if isinstance(df_or_map, (pd.DataFrame, gpd.GeoDataFrame)):
+                collected[full_path] = df_or_map
+                #_logger.info(f"Loaded DataFrame: {full_path}")
+                continue
+
+            if isinstance(df_or_map, dict):
+                for sheet, df in df_or_map.items():
+                    key = f"{full_path}::[{sheet}]"
+                    collected[key] = df
+                    #_logger.info(f"Loaded sheet DataFrame: {key}")
+                continue
+        except Exception as e:
+            _logger.debug(f"get_df failed for {full_path}: {e}")
+
+        # ——— 3) Fallback to generic text extractor ————
+        try:
+            parts = read_file_as_text(full_path)  # List[str]
+            combined = "\n\n".join(parts)
+            collected[full_path] = combined
+            #_logger.info(f"Read fallback text for: {full_path}")
+        except Exception as e:
+            _logger.warning(f"Could not read {full_path} at all: {e}")
+
+    return collected
+def read_directory(
+    root_path: str,
+    *,
+    allowed_exts:     Set[str] = DEFAULT_ALLOWED_EXTS,
+    unallowed_exts:   Set[str] = DEFAULT_UNALLOWED_EXTS,
+    exclude_types:    Set[str] = DEFAULT_EXCLUDE_TYPES,
+    exclude_dirs:     List[str] = DEFAULT_EXCLUDE_DIRS,
+    exclude_patterns: List[str] = DEFAULT_EXCLUDE_PATTERNS,
+) -> Dict[str, Union[pd.DataFrame, str]]:
+    allowed = make_allowed_predicate(
+        allowed_exts   = allowed_exts,
+        unallowed_exts = unallowed_exts,
+        exclude_types  = exclude_types,
+        extra_dirs     = exclude_dirs,
+        extra_patterns = exclude_patterns,
+    )
+    return read_files(files=root_path,allowed=allowed)

abstract_paths-0.0.0.14/src/abstract_paths/file_filtering/__init__.py

@@ -0,0 +1 @@
+from .file_filters import *