Excel Vba Modifier

"""
Excel Trust Center Checker

Validates that Excel Trust Center allows programmatic VBA access.
"""

import sys


def check_trust_center_windows():
    """
    Check if Excel Trust Center allows VBA access on Windows.

    Returns:
        (bool, str, str): (allowed, message, solution)
    """
    if sys.platform != 'win32':
        return None, "Not Windows", "VBA access requires Windows OS"

    try:
        import xlwings as xw
    except ImportError:
        return None, "xlwings not installed", "Install with: conda run -n excel pip install xlwings"

    try:
        app = xw.App(visible=False)
        try:
            # Try to access VBA project
            for book in app.books:
                try:
                    vba = book.xl_workbook.VBProject
                    # If we can access VBProject, Trust Center is OK
                    return True, "VBA access allowed", None
                except:
                    pass
            return False, "Trust Center blocks VBA access", trust_center_solution()
        finally:
            app.quit()
    except Exception as e:
        return False, f"Excel access failed: {str(e)}", trust_center_solution()


def trust_center_solution():
    """Return instructions to enable Trust Center."""
    return """
Solution: Enable VBA access in Excel Trust Center
1. Open Excel
2. File > Options > Trust Center > Trust Center Settings
3. Macro Settings: Select "Enable all macros"
   OR
4. Macro Settings > Select "Disable all macros with notification"
   (will show notification button to enable)
5. Trust Center tab > Check "Trust access to VBA project object model"
6. Click OK and restart Excel
"""


def display_result(allowed, message, solution):
    """Display check result."""
    if allowed is True:
        print("✓ Trust Center check PASSED")
        print(f"  {message}")
        return 0
    elif allowed is False:
        print("✗ Trust Center check FAILED")
        print(f"  {message}")
        if solution:
            print(f"\n{solution}")
        return 1
    else:
        print("? Trust Center check INCONCLUSIVE")
        print(f"  {message}")
        if solution:
            print(f"  {solution}")
        return 2


if __name__ == '__main__':
    allowed, msg, sol = check_trust_center_windows()
    exit_code = display_result(allowed, msg, sol)
    sys.exit(exit_code)

"""
Excel VBA Modifier

Safely modify VBA modules in Excel files using xlwings.
"""

import sys
import subprocess
from pathlib import Path


def check_trust_center():
    """
    Check if Trust Center allows VBA access.

    Returns:
        (bool, str): (success, message)
    """
    if sys.platform != 'win32':
        return False, "VBA access requires Windows"

    try:
        import xlwings as xw
        # Try to access VBProject
        app = xw.App(visible=False)
        try:
            # This will fail if Trust Center blocks it
            app.books
            return True, "Trust Center allows VBA access"
        finally:
            app.quit()
    except ImportError:
        return False, "xlwings not installed"
    except Exception as e:
        return False, f"Trust Center blocked: {str(e)}"


def read_vba_module(excel_file: str, module_name: str) -> str:
    """
    Read VBA module code from Excel file.

    Args:
        excel_file: Path to .xlsm file
        module_name: Name of VBA module (e.g., 'Module2', 'ThisWorkbook')

    Returns:
        VBA code as string

    Example:
        code = read_vba_module('file.xlsm', 'Module2')
        print(code)  # [VBA code...]
    """
    if sys.platform != 'win32':
        raise RuntimeError("VBA access requires Windows")

    try:
        import xlwings as xw
    except ImportError:
        raise ImportError("xlwings required: conda run -n excel pip install xlwings")

    excel_path = Path(excel_file)
    if not excel_path.exists():
        raise FileNotFoundError(f"Excel file not found: {excel_file}")

    app = xw.App(visible=False)
    try:
        wb = app.books.open(str(excel_path.absolute()))

        try:
            vba_project = wb.xl_workbook.VBProject

            # Find module
            for module in vba_project.VBComponents:
                if module.Name == module_name:
                    code = module.CodeModule.Read()
                    return code

            raise ValueError(f"Module not found: {module_name}")

        finally:
            wb.close()
    finally:
        app.quit()


def write_vba_module(excel_file: str, module_name: str, code: str) -> bool:
    """
    Write/replace VBA module code in Excel file.

    Args:
        excel_file: Path to .xlsm file
        module_name: Name of VBA module to replace
        code: New VBA code

    Returns:
        bool: True if successful

    Example:
        with open('new_code.vba', 'r') as f:
            new_code = f.read()
        write_vba_module('file.xlsm', 'Module2', new_code)
    """
    if sys.platform != 'win32':
        raise RuntimeError("VBA access requires Windows")

    try:
        import xlwings as xw
    except ImportError:
        raise ImportError("xlwings required: conda run -n excel pip install xlwings")

    excel_path = Path(excel_file)
    if not excel_path.exists():
        raise FileNotFoundError(f"Excel file not found: {excel_file}")

    app = xw.App(visible=False)
    try:
        wb = app.books.open(str(excel_path.absolute()))

        try:
            vba_project = wb.xl_workbook.VBProject

            # Find and replace module
            for module in vba_project.VBComponents:
                if module.Name == module_name:
                    code_module = module.CodeModule
                    # Clear and write new code
                    code_module.DeleteLines(1, code_module.CountOfLines)
                    code_module.AddFromString(code)
                    wb.save()
                    return True

            raise ValueError(f"Module not found: {module_name}")

        finally:
            wb.close()
    finally:
        app.quit()


def run_macro(excel_file: str, macro_name: str, *args) -> bool:
    """
    Run a VBA macro.

    Args:
        excel_file: Path to .xlsm file
        macro_name: Macro name (e.g., 'BuildMetaSummary')
        *args: Arguments to pass to macro (optional)

    Returns:
        bool: True if successful

    Example:
        run_macro('file.xlsm', 'BuildMetaSummary')
    """
    if sys.platform != 'win32':
        raise RuntimeError("Macro execution requires Windows")

    try:
        import xlwings as xw
    except ImportError:
        raise ImportError("xlwings required: conda run -n excel pip install xlwings")

    excel_path = Path(excel_file)
    if not excel_path.exists():
        raise FileNotFoundError(f"Excel file not found: {excel_file}")

    app = xw.App(visible=False)
    try:
        wb = app.books.open(str(excel_path.absolute()))

        try:
            macro = wb.macro(macro_name)
            if args:
                macro(*args)
            else:
                macro()
            return True

        finally:
            wb.close()
    finally:
        app.quit()


if __name__ == '__main__':
    # Test
    import sys

    if len(sys.argv) > 1:
        # Test Trust Center
        success, msg = check_trust_center()
        print(f"Trust Center: {msg}")