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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.481
+Version: 0.2.2.505
 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.505}/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.505',
     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.505}/src/abstract_utilities/__init__.py

@@ -1,11 +1,6 @@
-import re,threading,os,shutil,requests,asyncio,time,subprocess,json,glob,sys,logging
-from datetime import timedelta
-from datetime import datetime
-from typing import *
+from .imports 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,
                          get_key_values_from_path,
@@ -61,7 +56,7 @@ from .time_utils import (get_time_stamp,
                          parse_timestamp,
                          get_time_now_iso,
                          is_valid_time)
-from .string_clean import (eatInner,
+from .string_utils import (eatInner,
                            eatAll,
                            eatOuter,
                            url_join,
@@ -106,7 +101,7 @@ from .compare_utils import (create_new_name,
                             best_match)
 from .thread_utils import ThreadManager
 from .history_utils import HistoryManager
-from .abstract_classes import *
+
 from .parse_utils import (num_tokens_from_string,
                           chunk_source_code,
                           chunk_any_to_tokens,
@@ -116,10 +111,10 @@ from .parse_utils import (num_tokens_from_string,
 
 from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_response,initialize_call_log
 from .error_utils import try_func
+from .class_utils import *
 from .ssh_utils import *
 from .env_utils import *
 from .path_utils import *
 from .file_utils import *
-from .file_utils import call_for_all_tabs
 from .string_utils import *
-from .class_utils import alias,get_class_inputs,get_set_attr,get_caller_path,get_caller_dir
+from .import_utils import *

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/__init__.py

@@ -0,0 +1,7 @@
+from .imports import *
+from .abstract_classes import *
+from .caller_utils import *
+from .class_utils import *
+from .function_utils import *
+from .module_utils import *
+from .global_utils import *

{abstract_utilities-0.2.2.481/src/abstract_utilities → abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils}/abstract_classes.py

@@ -1,10 +1,11 @@
-import inspect
+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,

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/caller_utils.py

@@ -0,0 +1,35 @@
+from .imports import *
+def get_caller(i: Optional[int] = None) -> str:
+    """
+    Return the filename of the calling frame.
+
+    Args:
+        i: Optional stack depth offset. 
+           None = immediate caller (depth 1).
+
+    Returns:
+        Absolute path of the file for the stack frame.
+    """
+    depth = 1 if i is None else int(i)
+    stack = inspect.stack()
+    if depth >= len(stack):
+        depth = len(stack) - 1
+    return stack[depth].filename
+
+
+def get_caller_path(i: Optional[int] = None) -> str:
+    """
+    Return the absolute path of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    file_path = get_caller(depth + 1)
+    return os.path.realpath(file_path)
+
+
+def get_caller_dir(i: Optional[int] = None) -> str:
+    """
+    Return the absolute directory of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    abspath = get_caller_path(depth + 1)
+    return os.path.dirname(abspath)

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/class_utils.py

@@ -0,0 +1,109 @@
+"""
+Sheet: Class Utilities
+
+Module: class_utils.py
+Part of: abstract_utilities module
+Author: putkoff
+Date: 05/31/2023
+Version: 0.1.2
+
+This module contains utility functions tailored for handling classes, objects, and modules. It encapsulates operations like:
+1. Fetching and checking object types.
+2. Manipulating global variables.
+3. Checking object membership in a module.
+4. Inspecting function signatures and their arguments within a module.
+5. Calling functions with supplied arguments.
+6. Converting layout definitions into components.
+7. Retrieving attributes and methods of a module.
+
+Function Overview:
+------------------
+- get_type_list: Get a list of common Python types.
+- remove_key: Remove a specified key from a dictionary.
+- get_module_obj: Retrieve an object from a given module.
+- spec_type_mod: Check if an object has a specific type.
+- get_type_mod: Retrieve the type name of a given object.
+- is_module_obj: Check if an object is part of a module.
+- inspect_signature: Fetch the signature of a specified function.
+- get_parameter_defaults: Fetch the default parameter values for a function.
+- convert_layout_to_components: Convert a layout definition to its component representation.
+- get_dir: List all attributes and methods of a module.
+- get_proper_args: Call a function using either positional or keyword arguments.
+- get_fun: Parse a dictionary to retrieve a function and call it.
+- if_none_change: Replace a None object with a default value.
+- call_functions: Call a specified function or method using provided arguments.
+- process_args: Evaluate and process nested function calls in arguments.
+- has_attribute: Check if a function exists in a module.
+- mk_fun: Print a statement indicating the existence of a function in a module.
+
+Dependencies:
+-------------
+- inspect
+- json
+
+Each function is furnished with its own docstring that elaborates on its purpose, expected inputs, and outputs.
+
+"""
+from .imports import *
+
+
+def inspect_signature(instance: any, function: str):
+    """
+    Inspects the signature of a function.
+
+    Args:
+        instance (any): The instance containing the function.
+        function (str): The name of the function to inspect.
+
+    Returns:
+        inspect.Signature: The signature of the function.
+    """
+    return inspect.signature(get_module_obj(instance, function))
+
+def get_parameter_defaults(module, function):
+    """
+    Retrieves the default parameter values of a function.
+
+    Args:
+        module: The module instance.
+        function (str): The name of the function.
+
+    Returns:
+        dict: A dictionary containing the parameter names and their default values.
+    """
+    signature = inspect_signature(module, function)
+    if signature is None:
+        return {}
+    return json.dumps(remove_key({param_name: param.default if param.default != inspect.Parameter.empty else None for param_name, param in signature.parameters.items()}, 'icon'))
+
+def convert_layout_to_components(instance: any = None, component: str = 'function', js: dict = {}):
+    """
+    Converts a layout to components.
+
+    Args:
+        instance (any, optional): The instance containing the components. Defaults to None.
+        component (str, optional): The name of the component. Defaults to 'function'.
+        js (dict, optional): The dictionary of component properties. Defaults to an empty dictionary.
+
+    Returns:
+        any: The result of the component conversion.
+    """
+    jsN = json.loads(get_parameter_defaults(instance, component))
+    keys = list(js.keys())
+    for key in jsN:
+        if key in js:
+            jsN[key] = js[key]
+    return call_functions_hard(instance, component, **jsN)
+def get_class_inputs(cls, *args, **kwargs):
+    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)
+    return cls(**values)
+

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/function_utils.py

@@ -0,0 +1,153 @@
+from .imports import *
+def get_proper_args(function,args:(dict or list)={}):
+    """Call a function with either positional or keyword arguments based on the provided args type."""
+    return function(*args) if isinstance(args, list) else function(**args)
+def process_args(args):
+    """
+    Processes the arguments for a function, replacing nested function calls with their results.
+
+    Args:
+        args (dict): A dictionary of arguments. 
+
+    Returns:
+        dict: A dictionary of processed arguments.
+    """
+    for key, value in args.items():
+        # check if value is a dict and has a 'type' key with value 'get'
+        if isinstance(value, dict) and value.get('type') == 'get':
+            function_name = value.get('name',None)
+            function_args = value.get('args', {})
+            instance = value.get('instance',None)
+            glob = value.get('global',globals())
+            # call the function and replace the arg with its result
+            args[key] = call_functions(function_name, function_args, instance, glob)
+    return args
+def get_fun(js):
+    """
+    Retrieves and calls a function with the given parameters.
+
+    Args:
+        js (dict): A dictionary that contains function details, including name, arguments, instance (optional), and global scope (optional).
+
+    Returns:
+        any: The result of the function call.
+    """
+    # Get function details
+    function_name = js.get('name',None)
+    if function_name is None:
+        return None
+    function_args = js.get('args', {})
+    instance = js.get('instance',None)
+    glob = js.get('global',globals())
+    # Process arguments
+    function_args = process_args(function_args)
+    # If instance is not None, get the function from the instance, else get from globals
+    if instance is not None:
+        function = getattr(instance, function_name)
+    else:
+        function = glob[function_name]
+    # Get function's valid parameter keys
+    sig = inspect.signature(function)
+    valid_keys = sig.parameters.keys()
+    # Filter arguments to only those accepted by the function
+    filtered_args = {k: v for k, v in function_args.items() if k in valid_keys}
+    return call_functions(function_name, filtered_args, instance, glob)
+def call_functions(function_name: str, args: dict = {}, instance=None, glob:(dict or bool)=globals()):
+    """
+    Calls a function or a method with the given arguments.
+
+    Args:
+        function_name (str): The name of the function.
+        args (dict, optional): A dictionary of arguments to pass to the function. Defaults to None.
+        instance (optional): The instance on which to call the method. Defaults to None.
+        glob (optional): The global scope from which to retrieve the function. Defaults to globals().
+
+    Returns:
+        any: The result of the function or method call.
+    """
+    glob = if_none_change(glob,globals())
+    args = if_none_change(args,{})
+    if instance is not None:
+        # Calls method on instance
+        method = getattr(instance, function_name)
+        return get_proper_args(method,args)
+    else:
+        # Calls function from globals
+        return get_proper_args(glob[function_name],args)
+def get_all_functions_for_instance(instance):
+    """
+    Retrieves all callable methods/functions of an object instance.
+
+    Args:
+        instance: The object instance for which to retrieve methods/functions.
+
+    Returns:
+        list: A list of method/function names that are callable on the given instance.
+    """
+    return [method for method in dir(instance) if callable(getattr(instance, method))]
+def get_all_params(instance, function_name):
+    """
+    Retrieves information about the parameters of a callable method/function of an instance.
+
+    Args:
+        instance: The object instance containing the method.
+        function_name (str): The name of the method/function to inspect.
+
+    Returns:
+        dict: A dictionary containing parameter information, including names, defaults, kinds, and required parameters.
+    """
+    # Use getattr() to get the method by name
+    method = getattr(instance, function_name, None)
+    
+    if callable(method):
+        # Now you have the method, and you can inspect it
+        func_signature = inspect.signature(method)
+        parameters = func_signature.parameters
+        
+        params = {"names": [], "defaults": [], "kinds": [], "required": []}
+        
+        for param_name, param in parameters.items():
+            params["names"].append(param_name)
+            params["defaults"].append(param.default)
+            params["kinds"].append(param.kind)
+            
+            if param.default == inspect._empty:
+                params["required"].append(param_name)
+        
+        return params
+    else:
+        print(f"{function_name} is not a callable method of the instance.")
+        return None 
+def mk_fun(module,function):
+    """
+    Checks if a function exists in a given module.
+
+    Args:
+        module: The module in which to look for the function.
+        function: The function to check.
+
+    Prints a statement indicating whether the function exists.
+    """
+    if has_attribute(module,function):
+      print(f"The function {function} exists.")
+    else:
+      print(f"The function {function} does not exist.")
+def alias(*aliases):
+    """
+    Decorator to create multiple names for a function.
+    
+    Args:
+        *aliases: Names to assign to the function.
+    
+    Returns:
+        callable: Decorated function.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        # Assign aliases in the module's globals
+        for name in aliases:
+            globals()[name] = func
+        return wrapper
+    return decorator

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/imports/imports.py

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

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/imports/utils.py

@@ -0,0 +1,40 @@
+from .imports import *
+def remove_key(js: dict, key: any) -> dict:
+    """Remove a key from a dictionary. If the key is not present,
+    no action is taken."""
+    js.pop(key, None)
+    return js
+def if_none_change(obj, default):
+    """Return a default value if the provided object is None."""
+    if obj == None:
+        obj = default
+    return obj
+def has_attribute(module, function):
+    """Check if a specific function exists in a given module."""
+    try:
+        bool_it = hasattr(module, function)
+    except:
+        bool_it =None
+    return bool_it
+def get_type_list() -> list:
+    """Get a list of common Python types."""
+    return ['None','str','int','float','bool','list','tuple','set','dict','frozenset','bytearray','bytes','memoryview','range','enumerate','zip','filter','map','property','slice','super','type','Exception','object']
+def get_set_attr(parent,attr_name,value=None,valueFunc=None,default=False,*args,**kwargs):
+    attr_value = getattr(parent,attr_name,default)
+    if attr_value == False:
+        if value is None and valueFunc is not None:
+            value = valueFunc(*args,**kwargs)
+        setattr(parent,attr_name,value)
+        attr_value = getattr(parent,attr_name,default)
+    return attr_value
+def get_dir(mod):
+    """
+    Retrieves the directory of a module.
+
+    Args:
+        mod: The module.
+
+    Returns:
+        list: The list of attributes and methods in the module.
+    """
+    return dir(mod)

abstract_utilities-0.2.2.505/src/abstract_utilities/class_utils/module_utils.py

@@ -0,0 +1,63 @@
+from .imports import *
+def get_module_obj(instance: any, obj: any):
+    """
+    Retrieves an object from a module.
+
+    Args:
+        instance (any): The module instance.
+        obj (any): The object to retrieve.
+
+    Returns:
+        any: The retrieved object.
+    """
+    return getattr(instance, obj)
+
+def spec_type_mod(obj: any, st: str) -> bool:
+    """
+    Checks if an object has a specific type.
+
+    Args:
+        obj (any): The object to check.
+        st (str): The specific type to check.
+
+    Returns:
+        bool: True if the object has the specified type, False otherwise.
+    """
+    if obj.__class__.__name__ == st:
+        return True
+    return False
+
+def get_type_mod(obj: any) -> str:
+    """
+    Retrieves the type of an object.
+
+    Args:
+        obj (any): The object to get the type of.
+
+    Returns:
+        str: The type of the object.
+    """
+    type_ls = get_types_list()
+    for k in range(len(type_ls)):
+        typ = str(type_ls[k])
+        if spec_type_mod(obj, typ):
+            return typ
+    return "NoneType"
+
+def is_module_obj(instance: any, obj: str) -> bool:
+    """
+    Checks if an object is part of a module.
+
+    Args:
+        instance (any): The module instance.
+        obj (str): The name of the object to check.
+
+    Returns:
+        bool: True if the object is part of the module, False otherwise.
+    """
+    try:
+        if get_type_mod(getattr(instance, obj)) in [None, 'NoneType']:
+            return False
+        return True
+    except:
+        return False

abstract_utilities-0.2.2.505/src/abstract_utilities/env_utils/imports/__init__.py

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

{abstract_utilities-0.2.2.481 → abstract_utilities-0.2.2.505}/src/abstract_utilities/env_utils/imports/imports.py

@@ -1,6 +1,7 @@
-import os
+from ...imports import os
 from dotenv import load_dotenv
-from ...string_clean import eatAll,eatInner,eatOuter,safe_split
+from ...string_utils import eatAll,eatInner,eatOuter
+from ...safe_utils import safe_split
 from ...compare_utils import line_contains
 from ...type_utils import is_list,is_bool
 from ...path_utils import get_slash,path_join,if_not_last_child_join,get_home_folder,simple_path_join,is_file

abstract_utilities-0.2.2.505/src/abstract_utilities/error_utils/__init__.py

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

{abstract_utilities-0.2.2.481/src/abstract_utilities → abstract_utilities-0.2.2.505/src/abstract_utilities/error_utils}/error_utils.py

@@ -1,4 +1,4 @@
-from .log_utils import get_logger_callable
+from .imports import *
 def try_func(func, *args, logger=None, level='error', **kwargs):
     """
     Execute a function with try-except and log exceptions.

abstract_utilities-0.2.2.505/src/abstract_utilities/error_utils/imports/__init__.py

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

abstract_utilities-0.2.2.505/src/abstract_utilities/error_utils/imports/imports.py

@@ -0,0 +1 @@
+

abstract_utilities-0.2.2.505/src/abstract_utilities/error_utils/imports/module_imports.py

@@ -0,0 +1 @@
+from ...log_utils import get_logger_callable

{abstract_utilities-0.2.2.481/src/abstract_utilities/robust_reader/imports → abstract_utilities-0.2.2.505/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.505}/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/src/abstract_utilities/file_utils → abstract_utilities-0.2.2.505/src/abstract_utilities}/file_utils/imports/imports.py

@@ -4,10 +4,27 @@
 # automatically available to any module that does:
 #     from ..imports import *
 # ============================================================
-# ---- Core standard library modules -------------------------
-import os, sys, re, shlex, glob, platform, textwrap, subprocess, inspect, json, time
-import tempfile, shutil, logging, pathlib, fnmatch, importlib, importlib.util, types
+
+
+from ...imports import *
 from pathlib import Path
+
+
+
+
+from typing import *
+
+from typing import *
+from types import MethodType
+
+from datetime import datetime
+
+from typing import *
+from werkzeug.utils import secure_filename
+from werkzeug.datastructures import FileStorage
+from pdf2image import convert_from_path   # only used for OCR fallback
+# ---- Core standard library modules -------------------------
+
 from datetime import datetime
 from types import ModuleType
 
@@ -19,21 +36,15 @@ from typing import (
 )
 
 # ---- Common 3rd-party dependencies --------------------------
-import pandas as pd
-import geopandas as gpd
-import pytesseract
-import pdfplumber
-import PyPDF2
-import ezodf
 from pdf2image import convert_from_path
 from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
 
 # ---- Helpers ------------------------------------------------
-import textwrap as tw
 from pprint import pprint
 
 # ============================================================
 # AUTO-EXPORT ALL NON-PRIVATE NAMES
 # ============================================================
 __all__ = [name for name in globals() if not name.startswith("_")]
+

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

@@ -1,13 +1,9 @@
-from .imports import *
-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 *
-from ...abstract_classes import SingletonMeta
+from ...read_write_utils import read_from_file,write_to_file
 from ...log_utils import get_logFile
-from ...class_utils import get_caller, get_caller_path, get_caller_dir
+from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
 from ...ssh_utils import run_cmd
-
-__all__ = [name for name in globals() if not name.startswith("_")]
+from ...string_utils import get_from_kwargs,eatAll

{abstract_utilities-0.2.2.481/src/abstract_utilities/file_utils/file_utils → abstract_utilities-0.2.2.505/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
+