abstract-utilities 0.2.2.632__tar.gz → 0.2.2.691__tar.gz

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.632
+Version: 0.2.2.691
 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.632 → abstract_utilities-0.2.2.691}/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.632',
+    version='0.2.2.691',
     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.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/__init__.py

@@ -32,7 +32,8 @@ from .json_utils import (unified_json_loader,
                          safe_write_to_file,
                          safe_save_updated_json_data,
                          get_result_from_data,
-                         flatten_json
+                         flatten_json,
+                         to_json_safe
                          )
 
 from .directory_utils import *
@@ -45,7 +46,9 @@ from .list_utils import (get_highest_value_obj,
                          compare_lists,
                          get_symetric_difference,
                          list_set,
-                         make_list_it)
+                         make_list_it,
+                         get_single_from_list
+                         )
 from .time_utils import (get_time_stamp,
                          get_sleep,
                          sleep_count_down,
@@ -83,7 +86,8 @@ from .type_utils import (make_bool,
                          get_numbers_comp,
                          is_any_instance,
                          break_string,
-                         MIME_TYPES
+                         MIME_TYPES,
+                         get_if_None
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,

abstract_utilities-0.2.2.691/src/abstract_utilities/class_utils/abstract_classes.py

@@ -0,0 +1,144 @@
+from .imports import *
+class SingletonMeta(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+def get_inputs(cls, *args, **kwargs):
+    """
+    Dynamically construct a dataclass instance from args and kwargs,
+    filling missing values from defaults in the dataclass.
+    """
+    fields = list(cls.__annotations__.keys())
+    values = {}
+
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)  # default from dataclass
+
+    return cls(**values)
+
+
+from abstract_utilities import *
+class SingletonMeta(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+def get_inputs(cls, *args, **kwargs):
+    """
+    Dynamically construct a dataclass instance from args and kwargs,
+    filling missing values from defaults in the dataclass.
+    """
+    fields = list(cls.__annotations__.keys())
+    values = {}
+
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)  # default from dataclass
+
+    return cls(*args,**values)
+def get_input_params(func):
+    sig = inspect.signature(func)
+    return sig.parameters
+def get_args(func, *args,**kwargs):
+    parameters = get_input_params(func)
+    parameters = dict(parameters)
+    for key,value in parameters.items():
+        value = str(value)
+        if value.startswith('**'):
+            kwargs_key = key
+        elif value.startswith('*'):
+            args_key = key
+            kwargs_copy = kwargs.copy()
+            for k_key,k_value in kwargs.items():
+                if args_key == k_key and  isinstance(k_value,list or tuple or set):
+                    args = args | tuple(k_value)
+                    del kwargs[k_key]
+    return args,kwargs
+
+def prune_inputs(func, *args, **kwargs):
+    """
+    Smart argument adapter:
+    - Detects if func accepts *args or **kwargs
+    - Builds new positional arguments from kwargs when appropriate
+    - Handles explicit {"args": [...]} convention
+    """
+
+    sig = inspect.signature(func)
+    params = sig.parameters
+
+    has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params.values())
+    has_varkw   = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+    new_args = list(args)
+    new_kwargs = dict(kwargs)
+
+    # -----------------------------------------------------------
+    # 1. If user provided explicit args: {"args": [...]}
+    # -----------------------------------------------------------
+    if "args" in new_kwargs:
+        explicit_args = new_kwargs.pop("args")
+        if isinstance(explicit_args, (list, tuple)):
+            new_args.extend(explicit_args)
+        else:
+            new_args.append(explicit_args)
+
+    # -----------------------------------------------------------
+    # 2. If function has *args, infer which kwargs belong there
+    # -----------------------------------------------------------
+    if has_varargs:
+
+        # Heuristic rules for upgrading kwargs to args:
+        #   - if the function has NO named params, treat all scalar kwargs as positional
+        #   - common param names like "file_path" also qualify
+        preferred_as_args = {"path", "file", "file_path", "filename", "value"}
+
+        positional_candidates = []
+
+        for k in list(new_kwargs.keys()):
+            v = new_kwargs[k]
+
+            # candidate rules:
+            if k in preferred_as_args:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+            # scalars but not mappings/lists (optional)
+            elif isinstance(v, (str, int, float)) and len(positional_candidates) == 0:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+        new_args.extend(positional_candidates)
+
+    # -----------------------------------------------------------
+    # 3. If function does NOT accept **kwargs → strip extras
+    # -----------------------------------------------------------
+    if not has_varkw:
+        allowed = {
+            name for name, p in params.items()
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY
+            )
+        }
+        new_kwargs = {k: v for k, v in new_kwargs.items() if k in allowed}
+
+    return tuple(new_args), new_kwargs
+def run_pruned_func(func, *args, **kwargs):
+   args,kwargs = prune_inputs(func, *args, **kwargs)
+   return func(*args, **kwargs)

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/class_utils/caller_utils.py

@@ -52,3 +52,41 @@ def get_caller_dir(i: Optional[int] = None) -> str:
     depth = 1 if i is None else int(i)
     abspath = get_caller_path(depth + 1)
     return os.path.dirname(abspath)
+
+
+def get_original_caller_dir(levels_up: int = None) -> Path:
+    """
+    Return the directory of the *original* caller in the call stack.
+
+    levels_up:
+        - None → automatically goes to the bottom-most user-level caller.
+        - N    → manually walk up N frames for custom behavior.
+    
+    Returns:
+        Path object pointing to caller's directory.
+    """
+
+    stack = inspect.stack()
+
+    # If the user specifies an exact depth
+    if levels_up is not None:
+        target = min(levels_up + 1, len(stack) - 1)
+        frame = stack[target]
+        return Path(frame.filename).resolve().parent
+
+    # Otherwise, auto-detect the FIRST file that isn't inside site-packages or abstract_* utilities
+    for frameinfo in reversed(stack):
+        file_path = Path(frameinfo.filename).resolve()
+
+        # Skip internal interpreter/frame files
+        if "site-packages" in str(file_path):
+            continue
+        if "abstract_" in file_path.name:
+            continue
+        if file_path.name.startswith("<"):
+            continue
+
+        return file_path.parent
+
+    # Fallback: last entry in the stack
+    return Path(stack[-1].filename).resolve().parent

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/class_utils/imports/imports.py

@@ -1,2 +1,2 @@
-from ...imports import inspect,os,json,functools,inspect,glob,sys
+from ...imports import inspect,os,json,functools,inspect,glob,sys,Path
 from typing import *

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/file_utils/imports/classes.py

@@ -50,19 +50,20 @@ def is_file(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.isfile(path)
-    cmd = get_item_check_cmd(path,file=True)
-    return run_cmd(cmd=cmd,
-            user_at_host=user_at_host,
-            password=password,
-            key=key,
-            env_path=env_path,
-            **kwargs
-            )
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.isfile(path)
+        cmd = get_item_check_cmd(path,file=True)
+        return run_cmd(cmd=cmd,
+                user_at_host=user_at_host,
+                password=password,
+                key=key,
+                env_path=env_path,
+                **kwargs
+                )
 def is_dir(
     path,
     user_at_host=None,
@@ -71,34 +72,13 @@ def is_dir(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.isdir(path)
-    cmd = get_item_check_cmd(path,file=False,directory=True)
-    return run_cmd(cmd=cmd,
-            user_at_host=user_at_host,
-            password=password,
-            key=key,
-            env_path=env_path,
-            **kwargs
-            )
-def is_exists(
-    path,
-    user_at_host=None,
-    password=None,
-    key=None,
-    env_path=None,
-    **kwargs
-    ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.exists(path)
-    if is_potential == True:
-        cmd = get_item_check_cmd(path,exists=True)
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.isdir(path)
+        cmd = get_item_check_cmd(path,file=False,directory=True)
         return run_cmd(cmd=cmd,
                 user_at_host=user_at_host,
                 password=password,
@@ -106,7 +86,7 @@ def is_exists(
                 env_path=env_path,
                 **kwargs
                 )
-def is_any(
+def is_exists(
     path,
     user_at_host=None,
     password=None,
@@ -114,25 +94,49 @@ def is_any(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.exists(path)
-    if is_potential == True:
-        out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
-        for typ,cmd in out_js.items():
-            response = run_cmd(cmd=cmd,
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.exists(path)
+        if is_potential == True:
+            cmd = get_item_check_cmd(path,exists=True)
+            return run_cmd(cmd=cmd,
                     user_at_host=user_at_host,
                     password=password,
                     key=key,
                     env_path=env_path,
                     **kwargs
                     )
-            result = "__OK__" in (response or "")
-            if result:
-                return typ
-    return None
+def is_any(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.exists(path)
+        if is_potential == True:
+            out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
+            for typ,cmd in out_js.items():
+                response = run_cmd(cmd=cmd,
+                        user_at_host=user_at_host,
+                        password=password,
+                        key=key,
+                        env_path=env_path,
+                        **kwargs
+                        )
+                result = "__OK__" in (response or "")
+                if result:
+                    return typ
+
 class PathBackend(Protocol):
     def join(self, *parts: str) -> str: ...
     def isfile(self, path: str) -> bool: ...

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/file_utils/imports/module_imports.py

@@ -1,5 +1,5 @@
 from ...list_utils import make_list
-from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str
+from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str,if_not_bool_default
 from ...ssh_utils import *
 from ...env_utils import *
 from ...read_write_utils import read_from_file,write_to_file

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/file_utils/src/file_filters/ensure_utils.py

@@ -119,14 +119,17 @@ def ensure_directories(*args,**kwargs):
         
         if run_pruned_func(is_dir,arg_str,**kwargs):
             directories.append(arg_str)
+            
         elif run_pruned_func(is_file,arg_str,**kwargs):
             dirname = os.path.dirname(arg_str)
             directories.append(dirname)
-    safe_directories = get_dir_filter_kwargs(**kwargs)
-    safe_dirs = safe_directories.get('directories')
-    safe_dirs = if_none_change(safe_dirs or None,get_initial_caller_dir())
-    directories+= make_list(safe_dirs)
+    if not directories:    
+        safe_directories = get_dir_filter_kwargs(**kwargs)
+        safe_dirs = safe_directories.get('directories')
+        safe_dirs = if_none_change(safe_dirs or None,get_initial_caller_dir())
+        directories+= make_list(safe_dirs)
     return list(set([r for r in directories if r]))
+
 def get_proper_type_str(string):
     if not string:
         return None
@@ -337,32 +340,35 @@ def _get_default_modular(value, default, add=None, typ=set):
     if add:
         return combine_params(value,default,typ=None)
     return typ(value)
-def make_allowed_predicate(cfg: ScanConfig=None,**kwargs) -> Callable[[str], bool]:
+def make_allowed_predicate(cfg: ScanConfig = None, **kwargs) -> 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.
+    Build and return a function `allowed(path)` that evaluates the given ScanConfig.
+    Unlike substring-based matching, this version avoids accidental matches inside
+    unrelated names (e.g., 'abstract' matching 'archive').
     """
-    cfg=cfg or define_defaults(**kwargs)
-    def allowed(path: str=None,p=None) -> bool:
-        p = p or Path(path)
+
+    cfg = cfg or define_defaults(**kwargs)
+
+    def allowed(path: str) -> bool:
+        p = Path(path)
         name = p.name.lower()
         path_str = str(p).lower()
 
         # --------------------
         # A) directory filters
         # --------------------
+        # Excluded dirs: reject if any directory in the path matches exactly
         if cfg.exclude_dirs:
-            for dpat in cfg.exclude_dirs:
-                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
+            parts = path_str.split("/")
+            if any(d.lower() in parts for d in cfg.exclude_dirs):
+                print(f"[exclude_dirs] → {path}")
+                return False
 
+        # Allowed dirs: require at least one match (unless "*")
         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
-            ):
+            parts = path_str.split("/")
+            if not any(d.lower() in parts for d in cfg.allowed_dirs):
+                print(f"[allowed_dirs] → {path}")
                 return False
 
         # --------------------
@@ -370,37 +376,61 @@ def make_allowed_predicate(cfg: ScanConfig=None,**kwargs) -> Callable[[str], boo
         # --------------------
         if cfg.allowed_patterns and cfg.allowed_patterns != ["*"]:
             if not any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.allowed_patterns):
+                print(f"[allowed_patterns] → {path}")
                 return False
 
         if cfg.exclude_patterns:
-            for pat in cfg.exclude_patterns:
-                if fnmatch.fnmatch(name, pat.lower()):
-                    return False
+            if any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.exclude_patterns):
+                print(f"[exclude_patterns] → {path}")
+                return False
 
         # --------------------
         # C) extension filters
         # --------------------
         if p.is_file():
             ext = p.suffix.lower()
+
             if cfg.allowed_exts and ext not in cfg.allowed_exts:
+                print(f"[allowed_exts] → {path}")
                 return False
+
             if cfg.exclude_exts and ext in cfg.exclude_exts:
+                print(f"[exclude_exts] → {path}")
                 return False
 
         # --------------------
-        # D) type filters (optional)
+        # D) type filters (SAFE SEMANTIC MATCHING)
         # --------------------
-        if cfg.allowed_types and cfg.allowed_types != {"*"}:
-            if not any(t in path_str for t in cfg.allowed_types):
+        if cfg.allowed_types and "*" not in cfg.allowed_types:
+            if not any(t.lower() in path_str.split("/") for t in cfg.allowed_types):
+                print(f"[allowed_types] → {path}")
                 return False
-        if cfg.exclude_types and cfg.exclude_types != {"*"}:
-            if any(t in path_str for t in cfg.exclude_types):
+
+        if cfg.exclude_types:
+            if any(t.lower() in path_str.split("/") for t in cfg.exclude_types):
+                print(f"[exclude_types] → {path}")
                 return False
 
         return True
 
+    # Preserve real name for debugging and repr
+    allowed.__name__ = "allowed"
     return allowed
 
+def filter_allowed_items(items, cfg=None, **kwargs):
+    """
+    Apply ScanConfig allow/exclude rules to a flat list of file or directory paths.
+    No recursion. No globs. No shell calls.
+    Just pure deterministic filtering.
+    """
+    allowed_items = []
+    allowed = make_allowed_predicate(cfg=cfg, **kwargs)
+    for item in items:
+        if allowed(item):    
+            allowed_items.append(item)
+
+    return allowed_items
+
 def derive_all_defaults(**kwargs):
     kwargs = get_safe_canonical_kwargs(**kwargs)
     add = kwargs.get("add",False)

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/file_utils/src/find_collect.py

@@ -188,3 +188,13 @@ def collect_filepaths(
     ) -> 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-0.2.2.691/src/abstract_utilities/import_utils/imports/__init__.py

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

abstract_utilities-0.2.2.691/src/abstract_utilities/import_utils/imports/init_imports.py

@@ -0,0 +1,3 @@
+from ...imports import *
+
+

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/import_utils/imports/module_imports.py

@@ -6,3 +6,4 @@ from ...path_utils import get_file_parts
 from ...type_utils  import is_number,make_list
 from ...file_utils  import collect_filepaths,collect_globs
 from ...directory_utils import get_shortest_path,get_common_root
+from ...log_utils import get_logFile

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/import_utils/imports/utils.py

@@ -1,4 +1,4 @@
-import os
+from .init_imports import *
 from .constants import *
 
 def is_line_import(line):

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/import_utils/src/__init__.py

@@ -5,3 +5,4 @@ from .import_utils import *
 from .import_functions import *
 from .pkg_utils import *
 from .sysroot_utils import *
+from .layze_import_utils import *

{abstract_utilities-0.2.2.632 → abstract_utilities-0.2.2.691}/src/abstract_utilities/import_utils/src/import_utils.py

@@ -297,3 +297,64 @@ def attach_self_functions(
                 attached[out_name] = bound
 
     return attached
+def initFuncs(self, mode=None):
+    """
+    Load functions in either dev (dynamic) or prod (static) mode.
+    Absence of functions folder is a NO-OP.
+    """
+    mode = mode or "dev"
+    logger = get_logFile(__name__)
+
+    base_pkg = self.__class__.__module__.rsplit(".", 1)[0]
+
+    # ------------------
+    # PROD MODE (STATIC)
+    # ------------------
+    if mode == "prod":
+        try:
+            imports_mod = importlib.import_module(f"{base_pkg}.imports.funcs_imports")
+            for name in getattr(imports_mod, "__all__", []):
+                try:
+                    func = getattr(imports_mod, name)
+                    setattr(self, name, func.__get__(self))
+                except Exception as e:
+                    logger.info(f"initFuncs(prod) attach error: {e}")
+        except Exception as e:
+            logger.info(f"initFuncs(prod) skipped: {e}")
+        return self   # 🔒 HARD STOP
+
+    # ------------------
+    # DEV MODE (DYNAMIC)
+    # ------------------
+    import inspect
+    import pkgutil
+
+    try:
+        # resolve filesystem path FIRST
+        pkg_root = Path(importlib.import_module(base_pkg).__file__).parent
+        functions_dir = pkg_root / "functions"
+
+        # 🚫 no functions folder → silent no-op
+        if not functions_dir.exists() or not functions_dir.is_dir():
+            return self
+
+        # 🚫 not a package → no-op
+        if not (functions_dir / "__init__.py").exists():
+            return self
+
+        pkg = importlib.import_module(f"{base_pkg}.functions")
+        existing = set(dir(self))
+
+        for _, module_name, _ in pkgutil.iter_modules(pkg.__path__):
+            try:
+                mod = importlib.import_module(f"{pkg.__name__}.{module_name}")
+                for name, obj in inspect.getmembers(mod, inspect.isfunction):
+                    if name not in existing:
+                        setattr(self, name, obj.__get__(self))
+            except Exception as e:
+                logger.info(f"initFuncs(dev) module skipped: {e}")
+
+    except Exception as e:
+        logger.info(f"initFuncs(dev) skipped entirely: {e}")
+
+    return self

abstract_utilities-0.2.2.691/src/abstract_utilities/import_utils/src/layze_import_utils/__init__.py

@@ -0,0 +1,2 @@
+from .nullProxy import *
+from .lazy_utils import *