abstract-utilities 0.2.2.481__tar.gz → 0.2.2.499__tar.gz

{abstract_utilities-0.2.2.481 → abstract_utilities-0.2.2.499}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.481
+Version: 0.2.2.499
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff

{abstract_utilities-0.2.2.481 → abstract_utilities-0.2.2.499}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_utilities',
-    version='0.2.2.481',
+    version='0.2.2.499',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description='abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.',

{abstract_utilities-0.2.2.481 → abstract_utilities-0.2.2.499}/src/abstract_utilities/__init__.py

@@ -4,7 +4,6 @@ from datetime import datetime
 from typing 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,

{abstract_utilities-0.2.2.481/src/abstract_utilities/robust_reader/imports → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils}/__init__.py

@@ -1 +1,2 @@
 from .imports import *
+from .src import *

{abstract_utilities-0.2.2.481 → abstract_utilities-0.2.2.499}/src/abstract_utilities/file_utils/imports/constants.py

@@ -4,8 +4,11 @@ from .module_imports import *
 class ScanConfig:
     allowed_exts: Set[str]
     unallowed_exts: Set[str]
+    allowed_types: Set[str]
     exclude_types: Set[str]
+    allowed_dirs: List[str] = field(default_factory=list)
     exclude_dirs: List[str] = field(default_factory=list)
+    allowed_patterns: List[str] = field(default_factory=list)
     exclude_patterns: List[str] = field(default_factory=list)
 DEFAULT_ALLOWED_EXTS: Set[str] = {
     ".py", ".pyw",                             # python
@@ -37,3 +40,6 @@ DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
 REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
 AllowedPredicate = Optional[Callable[[str], bool]]
 DEFAULT_EXCLUDE_FILE_PATTERNS=DEFAULT_EXCLUDE_PATTERNS
+DEFAULT_ALLOWED_PATTENS="*"
+DEFAULT_ALLOWED_DIRS="*"
+DEFAULT_ALLOWED_TYPES="*"

{abstract_utilities-0.2.2.481 → abstract_utilities-0.2.2.499}/src/abstract_utilities/file_utils/imports/imports.py

@@ -6,7 +6,7 @@
 # ============================================================
 
 
-import os
+import os,re
 import sys, importlib,os
 import sys, importlib, os, inspect
 from pathlib import Path

abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/imports/module_imports.py

@@ -0,0 +1,12 @@
+
+from ...string_clean import eatAll
+from ...list_utils import make_list
+from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str
+from ...ssh_utils import *
+from ...env_utils import *
+from ...read_write_utils import read_from_file,write_to_file
+from ...abstract_classes import SingletonMeta
+from ...log_utils import get_logFile
+from ...class_utils import get_caller, get_caller_path, get_caller_dir
+from ...ssh_utils import run_cmd
+from ...string_utils import get_from_kwargs

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/imports → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils}/module_imports.py

@@ -10,4 +10,3 @@ from ...log_utils import get_logFile
 from ...class_utils import get_caller, get_caller_path, get_caller_dir
 from ...ssh_utils import run_cmd
 
-__all__ = [name for name in globals() if not name.startswith("_")]

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/__init__.py

@@ -6,3 +6,5 @@ from .pdf_utils import *
 from .file_reader import *
 from .find_collect import *
 from .type_checks import *
+from .initFunctionsGen import call_for_all_tabs,get_for_all_tabs
+

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/file_filters.py

@@ -1,4 +1,4 @@
-from .imports import *
+from ..imports import *
 from .filter_params import *
 from .file_utils import *
 ##from abstract_utilities import make_list,get_media_exts, is_media_type
@@ -8,21 +8,27 @@ def collect_filepaths(
     cfg: 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,
     add=False,
     allowed: Optional[Callable[[str], bool]] = None,
     **kwargs
     ) -> List[str]:
     cfg = cfg or define_defaults(
-                                allowed_exts=allowed_exts,
-                                unallowed_exts=unallowed_exts,
-                                exclude_types=exclude_types,
-                                exclude_dirs=exclude_dirs,
-                                exclude_patterns=exclude_patterns,
-                                add = add
-                                )
+            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)
     directories = make_list(directory)
     roots = [r for r in directories if r]

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/file_reader.py

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

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/file_utils.py

@@ -1,7 +1,6 @@
 
 from .filter_params import *
-from .imports import *
-
+from ..imports import *
 ##from abstract_utilities import make_list,get_media_exts, is_media_type
 def get_allowed_predicate(allowed=None):
     if allowed != False:
@@ -58,8 +57,11 @@ def get_files_and_dirs(
     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,
     add = False,
     recursive: bool = True,
@@ -67,11 +69,14 @@ def get_files_and_dirs(
     **kwargs
     ):
     cfg = cfg or define_defaults(
-        allowed_exts=allowed_exts,
-        unallowed_exts=unallowed_exts,
-        exclude_types=exclude_types,
-        exclude_dirs=exclude_dirs,
-        exclude_patterns=exclude_patterns,
+            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 = make_allowed_predicate(cfg)
@@ -88,48 +93,109 @@ def get_files_and_dirs(
         files = get_allowed_files(items,allowed=allowed)
     return dirs,files
 def make_allowed_predicate(cfg: ScanConfig) -> Callable[[str], bool]:
+    """
+    Build a predicate that returns True if a given path is considered allowed
+    under the given ScanConfig. Applies allowed_* and exclude_* logic symmetrically.
+    """
     def allowed(path: str) -> bool:
         p = Path(path)
         name = p.name.lower()
         path_str = str(p).lower()
-        # A) directories
+
+        # --------------------
+        # A) directory filters
+        # --------------------
         if cfg.exclude_dirs:
             for dpat in cfg.exclude_dirs:
-                if dpat in path_str or fnmatch.fnmatch(name, dpat.lower()):
-                    if p.is_dir() or dpat in path_str:
+                dpat_l = dpat.lower()
+                if dpat_l in path_str or fnmatch.fnmatch(name, dpat_l):
+                    if p.is_dir() or dpat_l in path_str:
                         return False
 
+        if cfg.allowed_dirs and cfg.allowed_dirs != ["*"]:
+            # must be in at least one allowed dir
+            if not any(
+                fnmatch.fnmatch(path_str, f"*{dpat.lower()}*") for dpat in cfg.allowed_dirs
+            ):
+                return False
+
+        # --------------------
+        # B) pattern filters
+        # --------------------
+        if cfg.allowed_patterns and cfg.allowed_patterns != ["*"]:
+            if not any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.allowed_patterns):
+                return False
+
         if cfg.exclude_patterns:
-            # B) filename patterns
             for pat in cfg.exclude_patterns:
                 if fnmatch.fnmatch(name, pat.lower()):
                     return False
 
-        # C) extension gates
+        # --------------------
+        # C) extension filters
+        # --------------------
         if p.is_file():
             ext = p.suffix.lower()
-            if (cfg.allowed_exts and ext not in cfg.allowed_exts) or (cfg.unallowed_exts and ext in cfg.unallowed_exts):
+            if cfg.allowed_exts and ext not in cfg.allowed_exts:
+                return False
+            if cfg.unallowed_exts and ext in cfg.unallowed_exts:
+                return False
+
+        # --------------------
+        # D) type filters (optional)
+        # --------------------
+        if cfg.allowed_types and cfg.allowed_types != {"*"}:
+            if not any(t in path_str for t in cfg.allowed_types):
                 return False
+        if cfg.exclude_types and cfg.exclude_types != {"*"}:
+            if any(t in path_str for t in cfg.exclude_types):
+                return False
+
         return True
+
     return allowed
+def correct_kwargs(**kwargs):
+    for key,values in kwargs.items():
+        if key.startswith('excluded'):
+            post_fix = key.split('_')[-1]
+            correct_key = f'exclude_{post_fix}'
+            correct_vals = kwargs.get(correct_key)
+            kwargs[correct_key]=combine_params(correct_vals,values)
+            del kwargs[key]
+    
 def collect_filepaths(
     directory: List[str],
     cfg: 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,
     add=False,
     allowed: Optional[Callable[[str], bool]] = None,
     **kwargs
     ) -> List[str]:
+    kwargs = correct_kwargs(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,
+        **kwargs)
     cfg = cfg or define_defaults(
-                                allowed_exts=allowed_exts,
-                                unallowed_exts=unallowed_exts,
-                                exclude_types=exclude_types,
-                                exclude_dirs=exclude_dirs,
-                                exclude_patterns=exclude_patterns,
+            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)

abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src/filter_params.py

@@ -0,0 +1,155 @@
+
+from ..imports import *
+import re
+def combine_params(*values,typ=None):
+    nu_values = None
+    for value in values:
+        if value is not None:
+            if nu_values is None:
+                typ = typ or type(value)
+                nu_values = typ()
+            else:
+                if val_type is set:
+                    nu_values = nu_values | typ(value)
+                if val_type is list:
+                    nu_values += typ(value)
+    return nu_values
+# -------------------------
+# Default sets
+# -------------------------
+
+DEFAULT_ALLOWED_EXTS: Set[str] = {
+    ".py", ".pyw", ".js", ".jsx", ".ts", ".tsx", ".mjs",
+    ".html", ".htm", ".xml", ".css", ".scss", ".sass", ".less",
+    ".json", ".yaml", ".yml", ".toml", ".ini", ".cfg",
+    ".md", ".markdown", ".rst", ".sh", ".bash", ".env", ".txt"
+}
+
+DEFAULT_EXCLUDE_TYPES: Set[str] = {
+    "image", "video", "audio", "presentation",
+    "spreadsheet", "archive", "executable"
+}
+
+_unallowed = set(get_media_exts(DEFAULT_EXCLUDE_TYPES)) | {
+    ".bak", ".shp", ".cpg", ".dbf", ".shx", ".geojson",
+    ".pyc", ".prj", ".sbn", ".sbx"
+}
+DEFAULT_UNALLOWED_EXTS = {e for e in _unallowed if e not in DEFAULT_ALLOWED_EXTS}
+
+DEFAULT_EXCLUDE_DIRS: List[str] = [
+    "node_modules", "__pycache__", "backups", "backup",
+    "trash", "deprecated", "old", "__init__"
+]
+
+DEFAULT_EXCLUDE_PATTERNS: List[str] = [
+    "__init__*", "*.tmp", "*.log", "*.lock", "*.zip", "*~"
+]
+
+DEFAULT_ALLOWED_PATTERNS: List[str] = ["*"]
+DEFAULT_ALLOWED_DIRS: List[str] = ["*"]
+DEFAULT_ALLOWED_TYPES: List[str] = ["*"]
+
+REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
+AllowedPredicate = Optional[Callable[[str], bool]]
+
+# -------------------------
+# Config dataclass
+# -------------------------
+
+@dataclass
+class ScanConfig:
+    allowed_exts: Set[str]
+    unallowed_exts: Set[str]
+    allowed_types: Set[str]
+    exclude_types: Set[str]
+    allowed_dirs: List[str] = field(default_factory=list)
+    exclude_dirs: List[str] = field(default_factory=list)
+    allowed_patterns: List[str] = field(default_factory=list)
+    exclude_patterns: List[str] = field(default_factory=list)
+
+# -------------------------
+# 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 in [True, None]:
+        return default
+    if value is False:
+        return typ()
+    if add:
+        return combine_params(value,default,typ=None)
+
+    return typ(value)
+
+# -------------------------
+# Default derivation logic
+# -------------------------
+
+def derive_file_defaults(
+    allowed_exts=False, unallowed_exts=False,
+    allowed_types=False, exclude_types=False,
+    allowed_dirs=False, exclude_dirs=False,
+    allowed_patterns=False, exclude_patterns=False,
+    add=False
+):
+    allowed_exts = _get_default_modular(_ensure_exts(allowed_exts), DEFAULT_ALLOWED_EXTS, add, set)
+    unallowed_exts = _get_default_modular(_ensure_exts(unallowed_exts), DEFAULT_UNALLOWED_EXTS, add, set)
+    allowed_types = _get_default_modular(_normalize_listlike(allowed_types, set), DEFAULT_ALLOWED_TYPES, add, set)
+    exclude_types = _get_default_modular(_normalize_listlike(exclude_types, set), DEFAULT_EXCLUDE_TYPES, add, set)
+    allowed_dirs = _get_default_modular(_normalize_listlike(allowed_dirs, list), DEFAULT_ALLOWED_DIRS, add, list)
+    exclude_dirs = _get_default_modular(_normalize_listlike(exclude_dirs, list), DEFAULT_EXCLUDE_DIRS, add, list)
+    allowed_patterns = _get_default_modular(_ensure_patterns(allowed_patterns), DEFAULT_ALLOWED_PATTERNS, add, list)
+    exclude_patterns = _get_default_modular(_ensure_patterns(exclude_patterns), DEFAULT_EXCLUDE_PATTERNS, add, list)
+
+    return {
+        "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,
+    }
+
+def define_defaults(**kwargs):
+    defaults = derive_file_defaults(**kwargs)
+    return ScanConfig(**defaults)

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/find_collect.py

@@ -1,4 +1,4 @@
-from .imports import *
+from ..imports import *
 from .filter_params import *
 from .file_filters import enumerate_source_files
 

abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/req.py → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src/initFunctionsGen.py

@@ -2,7 +2,7 @@
 # attach_dynamic.py
 from __future__ import annotations
 from .file_utils import define_defaults,get_files_and_dirs
-from .imports import *
+from ..imports import *
 ABSPATH = os.path.abspath(__file__)
 ABSROOT = os.path.dirname(ABSPATH)
 def caller_path():
@@ -103,47 +103,6 @@ def _discover_functions(base_pkg: str, *, hot_reload: bool) -> List[Tuple[str, C
             results.append((name, fn, module_basename))
     return results
 
-def attach_functionss(
-    self,
-    *,
-    base_pkg: Optional[str] = None,
-    hot_reload: bool = False,
-    prefix_with_module: bool = False,
-    on_collision: str = "last_wins",  # or "error" or "skip"
-):
-    """
-    Attach discovered functions from '<base_pkg>.functions' onto `self`.
-
-    - base_pkg: package containing either functions.py or functions/ (defaults to the class' package)
-    - hot_reload: reload modules each call (handy during development)
-    - prefix_with_module: if True, attach as '<module>_<funcname>' to avoid name clashes
-    - on_collision: how to handle duplicate names: 'last_wins' | 'error' | 'skip'
-    """
-    if base_pkg is None:
-        # Infer from the class' module: e.g., "myapp.tabs.users.widgets" -> "myapp.tabs.users"
-        cls_mod = self.__class__.__module__
-        base_pkg = cls_mod.rsplit(".", 1)[0] if "." in cls_mod else cls_mod
-
-    discovered = _discover_functions(base_pkg, hot_reload=hot_reload)
-    seen: Dict[str, str] = {}
-
-    for name, fn, mod_base in discovered:
-        attr_name = f"{mod_base}_{name}" if prefix_with_module else name
-
-        if hasattr(self, attr_name):
-            if on_collision == "skip":
-                continue
-            if on_collision == "error":
-                raise RuntimeError(f"attach_functions collision on '{attr_name}' from module '{mod_base}'")
-            # last_wins: fall through
-
-        setattr(self, attr_name, fn)
-        seen[attr_name] = mod_base
-
-    # breadcrumb for debugging
-    setattr(self, "_attached_functions", sorted(seen.keys()))
-    return self
-
 def attach_functions(
     obj_or_cls,
     base_pkg: str | None = None,
@@ -216,9 +175,7 @@ def attach_functions(
 
 
 
-def clean_imports():
-    alls = str(list(set("""os,re,subprocess,sys,re,traceback,pydot, enum, inspect, sys, traceback, threading,json,traceback,logging,requests""".replace('\n','').replace(' ','').replace('\t','').split(','))))[1:-1].replace('"','').replace("'",'')
-    input(alls)
+
 def isTab(item):
     item_lower =  item.lower()
     for key in ['console','tab']:

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/map_utils.py

@@ -1,4 +1,4 @@
-from .imports import MIME_TYPES,make_list,os
+from ..imports import MIME_TYPES,make_list,os
 from .file_filters import get_globs
 def get_file_type(file_path,types=None,default=None):
     mime_types = {}

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/pdf_utils.py

@@ -1,4 +1,4 @@
-from .imports import *
+from ..imports import *
 def if_none_return(obj: object, obj_2: object) -> object:
     """
     Return obj if obj_2 is None, otherwise return obj_2.

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/file_utils/src}/type_checks.py

@@ -1,8 +1,9 @@
-from .imports import *
+from ..imports import *
 
 def get_user_pass_host_key(**kwargs):
     args = ['password','user_at_host','host','key','user']
-    values,kwargs = get_from_kwargs(*args,**kwargs,del_kwarg=False)
+    kwargs['del_kwarg']=kwargs.get('del_kwarg',False)
+    values,kwargs = get_from_kwargs(*args,**kwargs)
     return values
 
 # --- Base remote checker -----------------------------------------------------

abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/__init__.py

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

abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/imports/__init__.py

@@ -0,0 +1,4 @@
+from .imports import *
+from .module_imports import *
+from .constants import *
+from .utils import *

abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/imports/constants.py

@@ -0,0 +1,2 @@
+IMPORT_TAG = 'import '
+FROM_TAG = 'from '

abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/imports/imports.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+from typing import *
+from types import MethodType
+import os, sys, importlib, os, inspect, re, importlib.util, hashlib

abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/imports/module_imports.py

@@ -0,0 +1,6 @@
+from ...read_write_utils import read_from_file,write_to_file,get_text_or_read
+from ...string_clean import eatAll,eatInner,eatElse,clean_line
+from ...class_utils import get_caller_path
+from ...list_utils import make_list
+from ...path_utils import get_file_parts
+from ...type_utils  import is_number,make_list

abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/imports/utils.py

@@ -0,0 +1,30 @@
+import os
+from .constants import *
+
+def is_line_import(line):
+    if line and (line.startswith(FROM_TAG) or line.startswith(IMPORT_TAG)):
+        return True
+    return False
+def is_line_group_import(line):
+    if line and (line.startswith(FROM_TAG) and IMPORT_TAG in line):
+        return True
+    return False
+
+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 get_unique_name(string,list_obj):
+    if isinstance(list_obj,dict):
+        list_obj = list(list_obj.keys())
+    if string in list_obj:
+        nustring = f"{string}"
+        for i in range(len(list_obj)):
+            nustring = f"{string}_{i}"
+            if nustring not in list_obj:
+                break
+        string = nustring
+    return string

{abstract_utilities-0.2.2.481/src/abstract_utilities/robust_readers/import_utils → abstract_utilities-0.2.2.499/src/abstract_utilities/import_utils/src}/__init__.py

@@ -1,7 +1,7 @@
+from .clean_imports import *
 from .dot_utils import *
-from .function_utils import *
+from .extract_utils import *
 from .import_utils import *
+from .import_functions import *
+from .package_utils import *
 from .sysroot_utils import *
-from .utils import *
-from .safe_import_utils import *
-from .clean_imports import *