abstract-utilities 0.2.2.448__py3-none-any.whl → 0.2.2.449__py3-none-any.whl

abstract_utilities/read_write_utils.py

@@ -1,38 +1,115 @@
 """
 read_write_utils.py
--------------------
-Unified read/write utility for safe file operations.
-Supports:
-- Writing content to a file
-- Reading content from a file
-- Creating and reading if missing
-- Detecting file/content params via positional args or kwargs
+
+This module, 'read_write_utils.py', provides utility functions for reading and writing to files.
+These include functions to:
 
 Usage:
-    from abstract_utilities.read_write_utils import *
-"""
+    import abstract_utilities.read_write_utils as read_write_utils
+
+1. Write content to a file.
+2. Read content from a file.
+3. Check if a string has a file extension.
+4. Read from or write to a file depending on the number of arguments.
+5. Create a file if it does not exist, then read from it.
 
+Each function includes a docstring to further explain its purpose, input parameters, and return values.
 import os
-from .ssh_utils.utils import run_cmd
-from .abstract_classes import run_pruned_func
-_FILE_PATH_KEYS = ['file', 'filepath', 'file_path', 'path', 'directory', 'f', 'dst', 'dest']
-_CONTENTS_KEYS = ['cont', 'content', 'contents', 'data', 'datas', 'dat', 'src', 'source']
 
+# File and Directory Operations
+os.rename(src, dst)            # Rename a file or directory
+os.remove(path)               # Remove a file
+os.unlink(path)               # Alias for os.remove()
+os.rmdir(path)                # Remove an empty directory
+os.makedirs(path)             # Create directories recursively
+os.makedirs(path, exist_ok=True)  # Create directories, ignore if exists
+os.mkdir(path)                # Create a single directory
+os.listdir(path)              # List files and directories in a path
+os.chdir(path)                # Change current working directory
+os.getcwd()                   # Get current working directory
+os.stat(path)                 # Get file/directory information
+os.lstat(path)                # Get symbolic link information
+os.symlink(src, dst)          # Create a symbolic link
+os.readlink(path)             # Read the target of a symbolic link
+os.getcwd()                   # Get current working directory
+os.chdir(path)                # Change current working directory
+
+# File and Directory Information
+os.path.exists(path)          # Check if a path exists
+os.path.isfile(path)          # Check if a path points to a file
+os.path.isdir(path)           # Check if a path points to a directory
+os.path.islink(path)          # Check if a path points to a symbolic link
+os.path.abspath(path)         # Get the absolute path of a file/directory
+os.path.basename(path)        # Get the base name of a path
+os.path.dirname(path)         # Get the directory name of a path
+os.path.join(path1, path2, ...)  # Join path components into a single path
+
+# File Permissions
+os.chmod(path, mode)          # Change file permissions
+os.access(path, mode)         # Check if a file is accessible with given mode
+
+# File Times
+os.path.getatime(path)        # Get last access time of a file
+os.path.getmtime(path)        # Get last modification time of a file
+os.path.getctime(path)        # Get creation time of a file
+os.utime(path, times)         # Set access and modification times
+
+# Working with Paths
+os.path.split(path)           # Split a path into (head, tail)
+os.path.splitext(path)        # Split a path into (root, ext)
+os.path.normpath(path)        # Normalize a path (e.g., convert slashes)
+
+# Other
+os.path.samefile(path1, path2)  # Check if two paths refer to the same file
+
+# Directory Traversal
+for root, dirs, files in os.walk(top, topdown=True):
+    # Traverse a directory tree, yielding root, dirs, and files lists
+
+# Temporary Files and Directories
+import tempfile
+tempfile.mkstemp()            # Create a temporary file
+tempfile.mkdtemp()            # Create a temporary directory
+tempfile.TemporaryFile()      # Create a temporary file object
+
+# Environment Variables
+os.environ                    # Dictionary of environment variables
+os.environ['VAR_NAME']        # Access an environment variable
+os.environ.get('VAR_NAME')    # Access an environment variable (with default)
+
+# Path Manipulation
+os.path.abspath(path)         # Convert relative path to absolute path
+os.path.join(path1, path2, ...)  # Join paths together
+os.path.split(path)           # Split a path into directory and filename
+os.path.dirname(path)         # Get the directory part of a path
+os.path.basename(path)        # Get the filename part of a path
+os.path.exists(path)          # Check if a path exists
+os.path.isfile(path)          # Check if a path points to a file
+os.path.isdir(path)           # Check if a path points to a directory
+
+# File Permissions
+os.chmod(path, mode)          # Change file permissions
+
+# Miscellaneous
+os.getpid()                   # Get the current process ID
+os.getlogin()                 # Get the name of the logged-in user
 
-# --- Helper utilities --------------------------------------------------------
-def string_in_keys(strings, kwargs):
-    """Find a matching keyword in kwargs that contains any of the given substrings."""
-    for key in kwargs:
-        for s in strings:
-            if s.lower() in key.lower():
-                return key
-    return None
+"""
+import os
+def break_down_find_existing(path):
+    test_path = ''
+    for part in path.split(os.sep):
+        test_path = os.path.join(test_path, part)
+        if not os.path.exists(test_path):
+            return test_path if test_path else None
+    return test_path
 
+def string_in_keys(strings, kwargs):
+    return next((key for key in kwargs if any(s.lower() in key.lower() for s in strings)), None)
 
 def get_path(paths):
-    """Return the first valid path among given paths."""
     for path in paths:
-        if isinstance(path, str):
+        if isinstance(path,str):
             if os.path.isfile(path):
                 return path
             dirname = os.path.dirname(path)
@@ -40,103 +117,83 @@ def get_path(paths):
                 return path
     return None
 
-
-def break_down_find_existing(path):
-    """Return the first non-existent subpath within a path chain."""
-    test_path = ''
-    for part in path.split(os.sep):
-        test_path = os.path.join(test_path, part)
-        if not os.path.exists(test_path):
-            return test_path if test_path else None
-    return test_path
-
-
-# --- Parameter parsing --------------------------------------------------------
 def check_read_write_params(*args, **kwargs):
-    """
-    Determine file_path and contents from arguments.
-    Returns a tuple: (file_path, contents)
-    """
-    file_key = string_in_keys(_FILE_PATH_KEYS, kwargs)
-    content_key = string_in_keys(_CONTENTS_KEYS, kwargs)
-
-    file_path = kwargs.get(file_key) if file_key else None
-    contents = kwargs.get(content_key) if content_key else None
+    file_path = kwargs.get('file_path', None)
+    contents = kwargs.get('contents', None)
+    if contents is None:
+        contents = kwargs.get('data', None)
 
-    # Handle positional args (fallback)
+    # Handle positional arguments
     if file_path is None and len(args) > 0:
         file_path = args[0]
     if contents is None and len(args) > 1:
         contents = args[1]
+    elif contents is None and len(args) > 0 and file_path != args[0]:
+        contents = args[0]
 
-    if file_path is None:
-        raise ValueError("Missing file_path argument.")
-    return file_path, contents
+    if file_path is None or contents is None:
+        raise ValueError("Both 'file_path' and 'contents' (or 'data') are required.")
 
+    return file_path, contents
 
-# --- Core functionality -------------------------------------------------------
-def write_to_file(*args, **kwargs):
+def write_to_file(file_path=None, contents=None,*args,  **kwargs):
+    """
+    Write contents to a file. If the file does not exist, it is created.
+
+    Args:
+        file_path: The path of the file to write to.
+        contents: The content to write to the file.
+        
+    Returns:
+        The contents that were written to the file.
     """
-    Write contents to a file (create if missing).
+    params = check_read_write_params(file_path=file_path, contents=contents,*args,  **kwargs)
+    if params:
+        with open(params[0], 'w', encoding='UTF-8') as f:
+            f.write(params[1])
+        return contents
+
 
-    Returns the file_path written.
+def read_from_file(file_path) -> str:
     """
-    file_path, contents = check_read_write_params(*args, **kwargs)
-    if contents is None:
-        raise ValueError("Missing contents to write.")
-
-    os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(str(contents))
-    return file_path
-
-
-def read_from_file(file_path,**kwargs):
-    user_at_host = kwargs.get("user_at_host")
-    if user_at_host:
-        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
-        basename = os.path.basename(file_path)
-        kwargs["cmd"] = f'cat {basename}'
-        return run_pruned_func(run_cmd,**kwargs)
-    """Read text content from a file."""
-    with open(file_path, "r", encoding="utf-8") as f:
+    Read the contents of a file.
+    
+    Args:
+        file_path: The path of the file to read from.
+        
+    Returns:
+        The contents of the file.
+    """
+    with open(file_path, 'r', encoding='UTF-8') as f:
         return f.read()
 
-
-def create_and_read_file(*args, **kwargs):
+def create_and_read_file(file_path=None, contents:str='',*args,  **kwargs) -> str:
     """
-    Create the file (if missing) and read contents from it.
+    Create a file if it does not exist, then read from it.
+    
+    Args:
+        file_path: The path of the file to create and read from.
+        contents: The content to write to the file if it does not exist.
+        
+    Returns:
+        The contents of the file.
     """
-    file_path, contents = check_read_write_params(*args, **kwargs)
     if not os.path.isfile(file_path):
-        write_to_file(file_path, contents or "")
+        write_to_file(contents, file_path)
     return read_from_file(file_path)
-
-
 def is_file_extension(obj: str) -> bool:
-    """Return True if obj looks like a filename with extension."""
-    if not isinstance(obj, str):
-        return False
-    root, ext = os.path.splitext(obj)
-    return bool(root and ext)
-
+    """
+    Check if a string has a file extension.
+    
+    Args:
+        obj: The string to check.
+        
+    Returns:
+        True if the string has a file extension, False otherwise.
+    """
+    return len(obj) >= 4 and '.' in obj[-4:-3]
 
 def delete_file(file_path: str):
-    """Safely delete a file if it exists."""
     if os.path.isfile(file_path):
         os.remove(file_path)
-        return True
-    return False
-
 
-def get_content_lines(*args, **kwargs):
-    """Return a list of lines from string or file path."""
-    file_path, contents = check_read_write_params(*args, **kwargs)
-    if os.path.isfile(file_path):
-        contents = read_from_file(filepath)
-
-    if isinstance(contents, str):
-        return contents.splitlines()
-    elif isinstance(contents, list):
-        return contents
-    return []

abstract_utilities/robust_reader/__init__.py

@@ -1,2 +1,2 @@
-from ..file_utils import *
+from .file_reader import *
 

abstract_utilities/{file_utils/file_utils → robust_reader}/file_reader.py

@@ -1,15 +1,29 @@
 # file_reader.py
-from .imports import *
-# -------- Public API drop-ins that mirror your originals --------
-from .filter_params import *
-from .file_filters import *
-from .file_utils import *
+import os,tempfile,shutil,logging,ezodf,fnmatch
+from typing import Union
+import pandas as pd
+import geopandas as gpd
+from abstract_utilities import * 
+from datetime import datetime
+from werkzeug.utils import secure_filename
+from werkzeug.datastructures import FileStorage
+from datetime import datetime
+from typing import Dict, Union, List
 from .pdf_utils import *
+import pdfplumber
+from pdf2image import convert_from_path   # only used for OCR fallback
+import pytesseract
+from pathlib import Path
 # ---------------------------------------------------------------------------
 # NOTE: The following helper functions must be provided elsewhere:
 #   - convert_date_string(s: str) -> datetime
 #   - read_from_file(path: str) -> pd.DataFrame
 # ---------------------------------------------------------------------------
+DEFAULT_EXCLUDE_DIRS = {"node_modules", "__pycache__","backups","backup"}
+DEFAULT_EXCLUDE_FILE_PATTERNS = {"__init__*", "*.tmp", "*.log"}
+DEFAULT_EXCLUDE_TYPES = {"image","video","audio","presentation"}
+def get_ext(item):
+    return item.split('.')[-1]
 def _should_skip_dir(dir_name: str, exclude_dirs: set[str]) -> bool:
     """
     Return True if dir_name match=self.exclude_types)es one of the excluded directory names exactly.

abstract_utilities/{file_utils/file_utils → robust_reader}/pdf_utils.py

@@ -1,4 +1,12 @@
-from .imports import *
+import PyPDF2
+from typing import *
+from pdf2image import convert_from_path
+from abstract_utilities.path_utils import (is_file, mkdirs, get_directory, 
+                                           get_base_name, split_text, 
+                                           get_ext, get_file_name)
+from abstract_utilities.type_utils import is_str
+from abstract_utilities.cmd_utils import cmd_input
+from abstract_utilities.read_write_utils import write_to_file
 def if_none_return(obj: object, obj_2: object) -> object:
     """
     Return obj if obj_2 is None, otherwise return obj_2.

abstract_utilities/robust_readers/__init__.py

@@ -1,2 +1,3 @@
+from .file_filters import *
 from .initFuncGen import *
 from .import_utils import *

abstract_utilities/{file_utils/file_utils/file_utils.py → robust_readers/file_filters.py}

@@ -15,8 +15,7 @@ def get_allowed_predicate(allowed=None):
     return allowed
 def get_globs(items,recursive: bool = True,allowed=None):
     glob_paths = []
-    items = [item for item in make_list(items) if item]
-    for item in items:
+    for item in make_list(items):
         pattern = os.path.join(item, "**/*")  # include all files recursively\n
         nuItems = glob.glob(pattern, recursive=recursive)
         if allowed:

abstract_utilities/{file_utils/file_utils → robust_readers}/filter_params.py

@@ -1,4 +1,41 @@
-from .imports import *
+from typing import *
+from ..type_utils import make_list,get_media_exts, is_media_type
+from ..string_clean import eatAll
+from dataclasses import dataclass, field
+@dataclass
+class ScanConfig:
+    allowed_exts: Set[str]
+    unallowed_exts: Set[str]
+    exclude_types: Set[str]
+    exclude_dirs: List[str] = field(default_factory=list)
+    exclude_patterns: List[str] = field(default_factory=list)
+DEFAULT_ALLOWED_EXTS: Set[str] = {
+    ".py", ".pyw",                             # python
+    ".js", ".jsx", ".ts", ".tsx", ".mjs",      # JS/TS
+    ".html", ".htm", ".xml",                   # markup
+    ".css", ".scss", ".sass", ".less",         # styles
+    ".json", ".yaml", ".yml", ".toml", ".ini",  # configs
+    ".cfg", ".md", ".markdown", ".rst",        # docs
+    ".sh", ".bash", ".env",                    # scripts/env
+    ".txt"                                     # plain text
+}
+
+DEFAULT_EXCLUDE_TYPES: Set[str] = {
+    "image", "video", "audio", "presentation",
+    "spreadsheet", "archive", "executable"
+}
+
+# never want these—even if they sneak into ALLOWED
+_unallowed = set(get_media_exts(DEFAULT_EXCLUDE_TYPES)) | {'.bak', '.shp', '.cpg', '.dbf', '.shx','.geojson',".pyc",'.shx','.geojson','.prj','.sbn','.sbx'}
+DEFAULT_UNALLOWED_EXTS = {e for e in _unallowed if e not in DEFAULT_ALLOWED_EXTS}
+
+DEFAULT_EXCLUDE_DIRS: Set[str] = {
+    "node_modules", "__pycache__", "backups", "backup", "backs", "trash", "depriciated", "old", "__init__"
+}
+
+DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
+    "__init__*", "*.tmp", "*.log", "*.lock", "*.zip","*~"
+}
 def get_default_modular(obj,default=None,add=False,typ=set):
     if obj in [False,True,None]:
         if obj in [True,None]:

abstract_utilities/robust_readers/initFuncGen.py

@@ -1,11 +1,30 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-from .imports import *
-def call_for_all_tabs(root = None,tab_control=True):
-    root = root or get_caller_dir()
-    get_for_all_tabs(root,tab_control=tab_control)
+from types import ModuleType
+from typing import Iterable
+from .file_filters import define_defaults,get_files_and_dirs
 
+import inspect
+from ..read_write_utils import *
+import textwrap, pkgutil, os, re, textwrap, sys, types, importlib, importlib.util, inspect
+from typing import *
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)
+def get_caller_path():
+    frame = inspect.stack()[1]
+    return os.path.abspath(frame.filename)
+def get_caller_dir():
+    frame = inspect.stack()[1]
+    abspath = os.path.abspath(frame.filename)
+    return os.path.dirname(abspath)
+def call_for_all_tabs():
+
+    root = get_caller_dir()
+    get_for_all_tabs(root)
+
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)
 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)
@@ -38,17 +57,11 @@ def ifFunctionsInFile(root):
             return item
         
 
-def get_for_all_tabs(root = None,tab_control=True):
+def get_for_all_tabs(root = None):
     root = root or caller_path()
     if os.path.isfile(root):
         root = os.path.dirname(root)
-    if tab_control:
-        all_tabs = get_dirs(root = root)
-    else:
-        dirname = root
-        if root and os.path.isfile(root):
-            dirname = os.path.dirname(root)
-        all_tabs = [dirname]
+    all_tabs = get_dirs(root = root)
     for ROOT in all_tabs:
         FUNCS_DIR = ifFunctionsInFile(ROOT)
         if FUNCS_DIR == None:
@@ -58,38 +71,52 @@ def get_for_all_tabs(root = None,tab_control=True):
             apply_inits(ROOT)
             
 
-def write_init_functions(import_lines,functions_dir):
-    functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
-    init_file_path = os.path.join(functions_dir, "__init__.py")
-    write_to_file(contents=functions_init, file_path=init_file_path)
-    return {"functions_init":functions_init,"init_file_path":init_file_path}
-def extract_funcs(filepaths):
-    funcs = []
-    for line in read_from_file(path).splitlines():
-        m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
-        if m:
-            funcs.append(m.group(1))
-    return funcs
-def get_all_funcs(
-    filepaths,
-    all_funcs=None,
-    import_lines=None
-    ):
-    import_lines = import_lines or []
-    all_funcs = all_funcs or []
-    for fp in filepaths:
-        basename = os.path.basename(fp)
-        module = os.path.splitext(basename)[0]
-        funcs = extract_funcs(fp)
-        if funcs:
-            import_lines.append(f"from .{module} import ({', '.join(funcs)})")
-            all_funcs.extend(funcs)
-    uniq_funcs = sorted(set(all_funcs))
-    func_tuple=", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
-    all_funcs_js = {"import_lines":import_lines,"all_funcs":all_funcs,"uniq_funcs":uniq_funcs,"func_tuple":func_tuple}
-    return all_funcs_js
-def get_init_funcs_str(func_tuple):
-        init_funcs_str = textwrap.dedent(f"""\
+def apply_inits(ROOT):
+    FUNCS_DIR = ifFunctionsInFile(ROOT)
+
+    
+    if_fun_dir = isDir(FUNCS_DIR)
+    if if_fun_dir != None:
+        
+        if if_fun_dir:
+            CFG = define_defaults(allowed_exts='.py',
+                unallowed_exts = True,
+                exclude_types = True,
+                exclude_dirs = True,
+                exclude_patterns = True)
+            _,filepaths = get_files_and_dirs(FUNCS_DIR,cfg=CFG)
+            
+        else:
+            filepaths = [FUNCS_DIR]
+        
+        # Parse top-level def names
+        def extract_funcs(path: str):
+            funcs = []
+            for line in read_from_file(path).splitlines():
+                m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
+                if m:
+                    funcs.append(m.group(1))
+            return funcs
+
+        # Build functions/__init__.py that re-exports all discovered functions
+        import_lines = []
+        all_funcs = []
+        for fp in filepaths:
+            module = os.path.splitext(os.path.basename(fp))[0]
+            funcs = extract_funcs(fp)
+            if funcs:
+                import_lines.append(f"from .{module} import ({', '.join(funcs)})")
+                all_funcs.extend(funcs)
+        if if_fun_dir:
+            functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
+            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
+
+        # Prepare the tuple literal of function names for import + loop
+        uniq_funcs = sorted(set(all_funcs))
+        func_tuple = ", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
+        
+        # Generate apiConsole/initFuncs.py using the safer setattr-loop
+        init_funcs_src = textwrap.dedent(f"""\
             
 
             from .functions import ({func_tuple})
@@ -102,42 +129,7 @@ def get_init_funcs_str(func_tuple):
                     logger.info(f"{{e}}")
                 return self
         """)
-        return init_funcs_str
-def get_function_file_paths(functions_dir):
-    filepaths=[]
-    if_fun_dir = isDir(functions_dir)
-    if if_fun_dir != None:
-        input(if_fun_dir)
-        if if_fun_dir:
-            CFG = define_defaults(allowed_exts='.py',
-                unallowed_exts = True,
-                exclude_types = True,
-                exclude_dirs = True,
-                exclude_patterns = True)
-            input(CFG)
-            _,filepaths = get_files_and_dirs(functions_dir,cfg=CFG)
-        else:
-            filepaths = [FUNCS_DIR]
-    input(filepaths)
-    return filepaths
-def apply_inits(root=None,tab_control=True):
-    root = root or get_caller_dir()
-    FUNCS_DIR = ifFunctionsInFile(root)
-    if_fun_dir = isDir(FUNCS_DIR)
-    if if_fun_dir != None:  
-        file_paths = get_function_file_paths(FUNCS_DIR)
- 
-        all_funcs_js = get_all_funcs(
-            filepaths=file_paths
-            )
-        if if_fun_dir:
-            init_func_js = write_init_functions(import_lines=all_funcs_js.get('import_lines'),functions_dir=FUNCS_DIR)
-            all_funcs_js.update(init_func_js)
-        func_tuple = all_funcs_js.get("func_tuple")
-        init_funcs_str = get_init_funcs_str(func_tuple)
-        init_funcs_file_path = os.path.join(root, "initFuncs.py")
-        all_funcs_js["funcs_str"]=init_funcs_str
-        all_funcs_js["funcs_file_path"]=init_funcs_file_path
-        write_to_file(contents=init_funcs_str, file_path=init_funcs_file_path)
-        return all_funcs_js
+
+        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
+
 

abstract_utilities/type_utils.py

@@ -59,6 +59,7 @@ Version: 0.1.2
 import os
 from pathlib import Path
 from typing import Union
+from .path_utils import get_all_item_paths,get_files
 from .list_utils import make_list
 # A big, but by no means exhaustive, map of extensions to mime‐types by category:
 MIME_TYPES = {

{abstract_utilities-0.2.2.448.dist-info → abstract_utilities-0.2.2.449.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: abstract_utilities
-Version: 0.2.2.448
+Version: 0.2.2.449
 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
@@ -10,21 +10,10 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.11
+Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: pathlib>=1.0.1
-Requires-Dist: abstract_security>=0.0.1
-Requires-Dist: yt_dlp>=2023.10.13
 Requires-Dist: pexpect>=4.8.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
+Requires-Dist: abstract-security>=0.0.1
 
 
  # Abstract Utilities