abstract-utilities 0.2.2.486__py3-none-any.whl → 0.2.2.540__py3-none-any.whl

abstract_utilities/file_utils (2)/src/pdf_utils.py

@@ -0,0 +1,300 @@
+from ..imports import *
+def if_none_return(obj: object, obj_2: object) -> object:
+    """
+    Return obj if obj_2 is None, otherwise return obj_2.
+    
+    Args:
+    obj (Any): Primary object to return.
+    obj_2 (Any): Secondary object to check.
+    
+    Returns:
+    Any: obj if obj_2 is None, else obj_2.
+    """
+    return obj if obj_2 is None else obj_2
+
+def write_pdf() -> PyPDF2.PdfWriter:
+    """
+    Return a new PDF writer object.
+    
+    Returns:
+    PyPDF2.PdfWriter: New PDF writer object.
+    """
+    return PyPDF2.PdfWriter()
+def read_pdf(file: str):
+    """
+    Read and return a PDF reader object from the provided file path.
+    
+    Args:
+    file (str): Path to the PDF file.
+    
+    Returns:
+    PyPDF2.PdfReader: PDF reader object.
+    """
+    return PyPDF2.PdfReader(file)
+def is_pdf_path(file: str):
+    """
+    Checks if a given file path corresponds to a PDF file.
+
+    Args:
+        file (str): A string representing the file path.
+
+    Returns:
+        bool: True if the file has a '.pdf' extension, False otherwise.
+    """
+    if is_file(file):
+        if get_ext(file) == '.pdf':
+            return True
+    return False
+
+def read_pdf(file: str):
+    """Read and return a PDF reader object from the provided file path."""
+    return PyPDF2.PdfReader(file)
+def get_pdf_obj(pdf_obj: Union[str, object]) -> object:
+    """
+    Processes and returns a PDF object. If provided with a file path to a PDF,
+    it reads and returns the PDF content as an object.
+
+    Args:
+        pdf_obj: Either a PDF file path or an existing PDF object.
+
+    Returns:
+        object: The PDF content as an object.
+    """
+    if is_str(pdf_obj):
+        if is_pdf_path(pdf_obj):
+            pdf_obj = read_pdf(pdf_obj)  # Assuming there's a function read_pdf() to read PDF content
+    return pdf_obj
+def get_separate_pages(pdf_reader, start_page:int=1, end_page:int=None):
+    """
+    Get specific pages from a PDF and return them as a new PDF object.
+
+    Args:
+        pdf_reader (object): The PDF reader object.
+        start_page (int, optional): The starting page number. Defaults to 1.
+        end_page (int, optional): The ending page number. Defaults to the last page.
+
+    Returns:
+        object: A new PDF writer object with the specified pages.
+    """
+    num_pages = get_pdf_pages(pdf_reader)
+    
+    # Handling default or out-of-bounds page values
+    if end_page is None or num_pages < end_page:
+        end_page = num_pages
+    elif num_pages < start_page:
+        return False
+    
+    pdf_writer = write_pdf()
+    
+    for page_num in range(num_pages):
+        if start_page <= page_num <= end_page:
+            pdf_writer.add_page(pdf_reader.pages[page_num])
+    return pdf_writer
+def is_pdf_path(file):
+    """
+    Check if the provided file path corresponds to a valid PDF file.
+
+    Args:
+        file (str): File path.
+
+    Returns:
+        bool: True if it's a valid PDF path, False otherwise.
+    """
+    if is_file(file) and get_ext(file).lower() == '.pdf':
+        return True
+    return False
+
+def get_pdf_pages(pdf_file):
+    """
+    Get the total number of pages in the PDF.
+
+    Args:
+        pdf_file (object/str): PDF reader object or path to a PDF file.
+
+    Returns:
+        int: Number of pages in the PDF.
+    """
+    pdf_file = get_pdf_obj(pdf_file)
+    try:
+        return len(pdf_file.pages)
+    except:
+        return False
+def save_pdf(output_file_path, pdf_writer):
+    """
+    Save a PDF writer object to a file.
+
+    Args:
+        output_file_path (str): Path to save the PDF.
+        pdf_writer (object): PDF writer object to save.
+    """
+    with open(output_file_path, 'wb') as output_file:
+        pdf_writer.write(output_file)
+def split_pdf(input_path: str, output_folder: Optional[str] = None, file_name: Optional[str] = None) -> List[str]:
+    """
+    Split a PDF file into separate files for each page.
+    
+    Args:
+        input_path (str): Path to the input PDF file.
+        output_folder (str, optional): Directory to save the split PDF files. Defaults to the directory of input_path.
+        file_name (str, optional): Base name for the output files. Defaults to the base name of input_path.
+        
+    Returns:
+        list: List of paths to the created split PDF files.
+    """
+    pdf_pages = []
+    file_name = get_file_name(input_path) if file_name is None else file_name
+    output_folder = if_none_return(get_directory(input_path), output_folder)  
+
+    print(f"Splitting PDF: {input_path}")
+    print(f"Output Folder: {output_folder}")
+    print(f"Using Filename: {file_name}")
+
+    with open(input_path, 'rb') as pdf_file:
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        num_pages = len(pdf_reader.pages)  # Replace getNumPages() with len(pdf_reader.pages)
+
+        print(f"Number of pages in PDF: {num_pages}")
+
+        for page_num in range(num_pages):
+            pdf_writer = PyPDF2.PdfWriter()
+            pdf_writer.add_page(pdf_reader.pages[page_num])  # Use the pdf_writer instance you created
+
+            output_file_path = os.path.join(output_folder, f'{file_name}_page_{page_num + 1}.pdf')
+            output_img_path = os.path.join(output_folder, f'{file_name}_page_{page_num + 1}.png')
+            print(f"Writing to: {output_file_path}")
+            pdf_pages.append(output_file_path)
+            save_pdf(output_file_path,pdf_writer)
+            
+    return pdf_pages
+def pdf_to_img_list(pdf_list: List[str], output_folder: Optional[str] = None, file_name: Optional[str] = None, 
+                    paginate: bool = False, extension: str = "png") -> List[str]:
+    """
+    Convert a list of PDF files to images.
+
+    Args:
+        pdf_list (List[str]): List of paths to PDF files.
+        output_folder (str, optional): Directory to save the images. Defaults to PDF's directory.
+        file_name (str, optional): Base name for the images. Defaults to PDF's name.
+        paginate (bool): Whether to paginate the image names. Defaults to False.
+        extension (str): Extension for the image files. Defaults to "png".
+
+    Returns:
+        List[str]: List of paths to the created image files.
+    """
+    image_list=[]
+    file_name_start = file_name
+    for i, each in enumerate(pdf_list):
+        try:
+            images = convert_from_path(each)
+        except Exception as e:
+            print("An error occurred while converting the PDF:", e)
+        
+        if output_folder is None:
+            output_folder = get_directory(each)
+        if file_name_start is None:
+            file_name = get_file_name(each)
+        if paginate:
+            file_name=f"{file_name}_Page_{i}"
+        
+        for i, image in enumerate(images):
+            image_output_path = os.path.join(output_folder, f"{file_name}.{extension}")
+            image_list.append(image_output_path)
+            save_image(image=image, image_path=image_output_path, format=extension.upper())
+    return image_list
+def img_to_txt_list(img_list: List[str], output_folder: Optional[str] = None, file_name: Optional[str] = None, 
+                    paginate: bool = False, extension: str = "txt") -> List[str]:
+    """
+    Convert a list of image files to text.
+
+    Args:
+        img_list (List[str]): List of paths to image files.
+        output_folder (str, optional): Directory to save the text files. Defaults to image's directory.
+        file_name (str, optional): Base name for the text files. Defaults to image's name.
+        paginate (bool): Whether to paginate the text filenames. Defaults to False.
+        extension (str): Extension for the text files. Defaults to "txt".
+
+    Returns:
+        List[str]: List of paths to the created text files.
+    """
+    text_list = []
+    file_name_start = file_name
+    for i, each in enumerate(img_list):
+        if output_folder is None:
+            output_folder = get_directory(each)
+        if file_name_start is None:
+            file_name = get_file_name(each)
+        if paginate:
+            file_name=f"{file_name}_Page_{i}"
+        
+        text_output = image_to_text(each)
+        text_output_path = os.path.join(output_folder, f"{get_file_name(each)}.{extension}")
+        text_list.append(text_output_path)
+        write_to_file(filepath=text_output_path, contents=text_output)
+    return text_list
+def open_pdf_file(pdf_file_path: str) -> None:
+    """
+    Open a PDF file using the default associated program.
+    
+    Args:
+        pdf_file_path (str): Path to the PDF file to open.
+    """
+    try:
+        # Open the PDF file using the default associated program
+        cmd_input("open "+pdf_file_path)
+    except FileNotFoundError:
+        print("Error: The specified file does not exist.")
+    except Exception as e:
+        print("Error:", e)
+    # use it before writing to a file
+
+
+def get_pdfs_in_directory(directory: str) -> List[str]:
+    """
+    Get a list of PDF filenames in a given directory.
+    
+    Args:
+        directory (str): Path to the directory.
+        
+    Returns:
+        list: List of PDF filenames in the directory.
+    """
+    pdfs = []
+    for filename in os.listdir(directory):
+        if is_pdf_path(filename):
+            pdfs.append(filename)
+    return pdfs
+
+def get_all_pdf_in_directory(file_directory: Optional[str] = None) -> List[str]:
+    """
+    Get a list of complete paths to PDF files in a given directory.
+    
+    Args:
+        file_directory (str, optional): Path to the directory. 
+        
+    Returns:
+        list: List of paths to PDF files in the directory.
+    """
+    pdfs=[]
+    for filename in sorted(os.listdir(file_directory)):
+        if is_pdf_path(filename):
+            pdf_path = os.path.join(file_directory, filename)
+            if is_file(pdf_path):
+                pdfs.append(pdf_path)
+    return pdfs
+
+def collate_pdfs(pdf_list: List[str], output_pdf_path: str) -> None:
+    """
+    Merge multiple PDF files into a single PDF.
+    
+    Args:
+        pdf_list (list): List of paths to PDF files to be merged.
+        output_pdf_path (str): Path to save the merged PDF.
+    """
+    pdf_writer = PyPDF2.PdfWriter()
+    for file_path in pdf_list:
+        with open(file_path, 'rb') as pdf_file:
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            for page_num in range(len(pdf_reader.pages)):
+                pdf_writer.add_page(pdf_reader.pages[page_num])
+    save_pdf(output_file_path, pdf_writer)
+

abstract_utilities/hash_utils/__init__.py

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

abstract_utilities/hash_utils/hash_utils.py

@@ -0,0 +1,5 @@
+from .imports import *
+def generate_data_hash(insertName,value):
+    # Combine values to create a unique reference
+    data_string = f"{insertName}_{value}"
+    return hashlib.md5(data_string.encode()).hexdigest()

abstract_utilities/hash_utils/imports/__init__.py

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

abstract_utilities/hash_utils/imports/imports.py

@@ -0,0 +1 @@
+from ...imports import hashlib

abstract_utilities/history_utils/__init__.py

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

abstract_utilities/history_utils/history_utils.py

@@ -0,0 +1,37 @@
+class HistoryManager:
+    def __init__(self):
+        self.history_names = {}
+
+    def add_history_name(self, name, initial_data=''):
+        self.history_names[name] = {"history": [initial_data], "history_redo": []}
+        return name
+
+    def transfer_state(self, primary_data, secondary_data):
+        """
+        Transfer the latest state from primary_data to secondary_data
+        Returns the modified primary and secondary data lists
+        """
+        self.last_data = None
+        # If there's data in primary, transfer the latest to secondary
+        if primary_data:
+            self.last_data = primary_data.pop()
+            secondary_data.append(self.last_data)
+
+        return primary_data, secondary_data
+
+    def add_to_history(self, name, data):
+        # Clear the redo history when a new state is added
+        self.history_names[name]['history_redo'] = []
+        self.history_names[name]['history'].append(data)
+
+    def redo(self, name):
+        # Redo by transferring state from redo history to actual history
+        self.history_names[name]["history_redo"], self.history_names[name]["history"] = self.transfer_state(
+            self.history_names[name]["history_redo"], self.history_names[name]["history"])
+        return self.last_data
+
+    def undo(self, name):
+        # Undo by transferring state from actual history to redo history
+        self.history_names[name]["history"], self.history_names[name]["history_redo"] = self.transfer_state(
+            self.history_names[name]["history"], self.history_names[name]["history_redo"])
+        return self.last_data

abstract_utilities/history_utils/imports/__init__.py

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

abstract_utilities/history_utils/imports/imports.py

@@ -0,0 +1 @@
+

abstract_utilities/import_utils/__init__.py

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

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/import_utils/imports/constants.py

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

abstract_utilities/import_utils/imports/imports.py

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

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_utils 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/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/import_utils/src/__init__.py

@@ -0,0 +1,7 @@
+from .clean_imports import *
+from .dot_utils import *
+from .extract_utils import *
+from .import_utils import *
+from .import_functions import *
+from .pkg_utils import *
+from .sysroot_utils import *

abstract_utilities/import_utils/src/clean_imports.py

@@ -0,0 +1,147 @@
+from ..imports import *
+from .pkg_utils import *
+
+def get_text_or_read(text=None,file_path=None):
+    text = text or ''
+    imports_js = {}
+    if not text and file_path and os.path.isfile(file_path):
+        text=read_from_file(file_path)
+    return text
+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_all_imports(text=None,file_path=None,import_pkg_js=None):
+    if text and os.path.isfile(text):
+        file_path = text
+        text = read_from_file(text)    
+    text = get_text_or_read(text=text,file_path=file_path)
+    lines = text.split('\n')
+    cleaned_import_list=[]
+    nu_lines = []
+    is_from_group = False
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
+    for line in lines:
+        if line.startswith(IMPORT_TAG) and ' from ' not in line:
+            cleaned_import_list = get_cleaned_import_list(line)
+            import_pkg_js = add_imports_to_import_pkg_js("import",cleaned_import_list,import_pkg_js=import_pkg_js)
+        else:
+            if is_from_group:
+                import_pkg=is_from_group
+                line = clean_line(line)
+                if line.endswith(')'):
+                   is_from_group=False
+                   line=line[:-1]
+                imports_from_import_pkg = clean_imports(line)
+                import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports_from_import_pkg,import_pkg_js=import_pkg_js)
+                
+            else:
+                import_pkg_js=update_import_pkg_js(line,import_pkg_js=import_pkg_js)
+            if is_from_line_group(line) and is_from_group == False:
+                is_from_group=get_import_pkg(line)
+    return import_pkg_js
+
+def clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    if text and os.path.isfile(text):
+        file_path = text
+        text = read_from_file(text)    
+    if not import_pkg_js:
+        import_pkg_js = get_all_imports(text=text,file_path=file_path)
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js,file_path=file_path)
+    nu_lines = import_pkg_js["context"]["nulines"]
+    for pkg,values in import_pkg_js.items():
+        comments = []
+        if pkg not in ["context"]: 
+            
+            imports = values.get('imports')
+            for i,imp in enumerate(imports):
+                if '#' in imp:
+                    imp_spl = imp.split('#')
+                    comments.append(imp_spl[-1])
+                    imports[i] = clean_line(imp_spl[0])
+            imports = list(set(imports))   
+            if '*' in imports:
+                imports="*"
+            else:
+                imports=','.join(imports)
+                if comments:
+                    comments=','.join(comments)
+                    imports+=f" #{comments}"
+            import_pkg_js[pkg]["imports"]=imports
+            if fill_nulines:
+                line = values.get('line')
+                if len(nu_lines) >= line:
+                    nu_lines[line] += imports
+    return import_pkg_js
+def clean_all_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    clean_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js,fill_nulines=import_pkg_js)
+    import_pkg_js["context"]["nulines"]=nu_lines
+    return import_pkg_js
+def get_clean_import_string(import_pkg_js,fill_nulines=False,get_locals=False):
+    import_pkg_js = clean_imports(import_pkg_js=import_pkg_js,fill_nulines=fill_nulines)
+    import_ls = []
+    for key,values in import_pkg_js.items():
+        if key not in ['context','nulines']:
+            imports = None
+            imp_values= values.get('imports')
+            if key == 'import':
+                imports = f'import {imp_values}'
+            elif get_locals or not key.startswith('.'):
+                imports = f'from {key} import {imp_values}'
+            if imports:
+                import_ls.append(imports)
+    return '\n'.join(import_ls)
+def get_clean_imports_from_files(files):
+    import_pkg_js={}
+    for file in files:
+        import_pkg_js = get_all_imports(file,import_pkg_js=import_pkg_js)
+    return get_clean_import_string(import_pkg_js)
+def get_dot_fro_line(line,dirname):
+    from_line = line.split(FROM_TAG)[-1]
+    dot_fro = ""
+    for char in from_line:
+        if  char != '.':
+            line = f"from {dot_fro}{eatAll(from_line,'.')}"
+            break
+        dirname = os.path.dirname(dirname)
+        dirbase = os.path.basename(dirname)
+        dot_fro = f"{dirbase}.{dot_fro}"
+    return line
+def get_dot_fro_lines(lines,file_path,all_imps):
+    for line in lines:
+        if line.startswith(FROM_TAG):
+            line = get_dot_fro_line(line,file_path)
+            if line in all_imps:
+                line = ""
+        if line:
+            all_imps.append(line)
+    return all_imps
+def get_all_real_imps(text=None,file_path=None,all_imps=None):
+    if text and os.path.isfile(text):
+        file_path = text
+        text = read_from_file(text)    
+    all_imps = all_imps or []
+    contents = get_text_or_read(text=text,file_path=file_path)
+    lines = contents.split('\n')
+    all_imps = get_dot_fro_lines(lines,file_path,all_imps)
+    return '\n'.join(all_imps)
+def save_cleaned_imports(text=None,file_path=None,write=False,import_pkg_js=None):
+    import_pkg_js=get_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    import_pkg_js = clean_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    contents = '\n'.join(import_pkg_js["context"]["nulines"])
+    if file_path and write:
+        write_to_file(contents=contents,file_path=file_path)
+    return contents

abstract_utilities/import_utils/src/dot_utils.py

@@ -0,0 +1,69 @@
+from ..imports import *
+def get_Path(path):
+    if isinstance(path,str):
+        path = Path(str(path))
+    return path
+def get_dot_range(filepath=None,list_obj=None):
+    imports = make_list(list_obj) or extract_imports(filepath)
+    highest=0
+    dots = [get_imp(fro) for fro in imports if fro]
+
+    if dots:
+        dots.sort()
+        highest = dots[0]
+    return highest
+def dotted_from(file: Path, sysroot: Path) -> str:
+    """
+    Build dotted name from sysroot (directory *above* top package)
+    e.g.  /repo/abstract_ide/consoles/launcherWindowTab/functions/core_utils.py
+        sysroot=/repo  -> abstract_ide.consoles.launcherWindowTab.functions.core_utils
+    """
+    file = get_Path(file)
+    sysroot = get_Path(sysroot)
+    file = file.resolve()
+    stem = file.with_suffix("")  # drop .py
+    return ".".join(stem.relative_to(sysroot).parts)
+def to_dotted_name(file_path: Path, top_package: str) -> str:
+    """
+    Convert .../abstract_ide/consoles/launcherWindowTab/functions/core_utils.py
+    -> abstract_ide.consoles.launcherWindowTab.functions.core_utils
+    """
+    # find the index of the top_package in the path parts
+    file_path = get_Path(file_path)
+    top_package = get_Path(top_package)
+    parts = file_path.resolve().parts
+    i = None
+    if is_number(top_package):
+        i= int(top_package)
+    if i is None:
+        try:
+            i = parts.index(top_package)
+        except ValueError:
+            raise RuntimeError(f"Cannot locate package '{top_package}' in {file_path}")
+    rel_parts = parts[i:]  # from top_package onward
+    if rel_parts[-1].endswith(".py"):
+        rel_parts = list(rel_parts)
+        rel_parts[-1] = rel_parts[-1][:-3]  # strip .py
+    return ".".join(rel_parts)
+def compute_dotted_and_sysroot(file_path: Path) -> Tuple[str, Path]:
+    """
+    If inside packages, build dotted name from the top package down.
+    sysroot will be the directory *above* the top package.
+    If not a package, we fall back to a repo-ish root guess (2 parents up).
+    """
+    file_path = get_Path(file_path)
+    file_path = file_path.resolve()
+    stem = file_path.with_suffix("")  # drop .py
+
+    top_pkg_dir = find_top_package_dir(file_path)
+    if top_pkg_dir:
+        sysroot = top_pkg_dir.parent
+        dotted = ".".join(stem.relative_to(sysroot).parts)
+        return dotted, sysroot
+
+    # Fallback: not in a package tree — guess a root a couple levels up
+    sysroot = file_path.parents[2]
+    dotted = ".".join(stem.relative_to(sysroot).parts)
+    return dotted, sysroot
+
+