Merge branch 'main' of https://huggingface.co/spaces/Zenaight/planify

app/CurrencyMapping/__init__.py

@@ -1,17 +0,0 @@
-# Currency Mapping Package
-
-import os
-import sys
-
-# Add the current directory to sys.path to handle the space in folder name
-current_dir = os.path.dirname(__file__)
-if current_dir not in sys.path:
-    sys.path.insert(0, current_dir)
-
-# Import the main function for easy access
-from currency_mapping import convert_currency_symbols_to_iso, canonical_currency_map
-
-__all__ = [
-    'convert_currency_symbols_to_iso',
-    'canonical_currency_map'
-]

app/CurrencyMapping/currency_mapping.py

@@ -1,538 +0,0 @@
-# Currency Mapping Module
-# Contains canonical_currency_map dictionary and convert_currency_symbols_to_iso() function
-
-# Canonical currency map for symbol resolution (matches TypeScript version)
-canonical_currency_map = {
-    # Standard currency symbols
-    "$": "USD",
-    "£": "GBP", 
-    "€": "EUR",
-    "¥": "JPY",
-    "₹": "INR",
-    "₽": "RUB",
-    "₩": "KRW",
-    "₪": "ILS",
-    "₺": "TRY",
-    "₴": "UAH",
-    "₼": "AZN",
-    "₸": "KZT",
-    "₾": "GEL",
-    "֏": "AMD",
-    "₲": "PYG",
-    "₡": "CRC",
-    "₣": "XPF",
-    "₦": "NGN",
-    "₵": "GHS",
-    "₨": "PKR",
-    "₱": "PHP",
-    "₫": "VND",
-    "₭": "LAK",
-    "៛": "KHR",
-    "৳": "BDT",
-    "؋": "AFN",
-    "﷼": "IRR",
-    
-    # Custom symbols
-    "‡": "CUSTOM_DAGGER",
-    "†": "CUSTOM_DAGGER_SINGLE",
-    
-    # Letter-based currencies
-    "R": "ZAR",  # South African Rand
-    "C$": "CAD",  # Canadian Dollar
-    "A$": "AUD",  # Australian Dollar
-    "R$": "BRL",  # Brazilian Real
-    "S/": "PEN",  # Peruvian Sol
-    "Bs": "BOB",  # Bolivian Boliviano
-    "Q": "GTQ",  # Guatemalan Quetzal
-    "L": "HNL",  # Honduran Lempira
-    "ƒ": "AWG",  # Aruban Florin
-    "Vt": "VUV",  # Vanuatu Vatu
-    "T$": "TOP",  # Tongan Pa'anga
-    "T": "WST",  # Samoan Tala
-    "лв": "BGN",  # Bulgarian Lev
-    "Kč": "CZK",  # Czech Koruna
-    "kr": "DKK",  # Danish Krone
-    "Ft": "HUF",  # Hungarian Forint
-    "zł": "PLN",  # Polish Zloty
-    "lei": "RON",  # Romanian Leu
-    "CHF": "CHF",  # Swiss Franc
-    "KM": "BAM",  # Bosnian Marka
-    "ден": "MKD",  # North Macedonian Denar
-    "дин": "RSD",  # Serbian Dinar
-    "so'm": "UZS",  # Uzbekistani Som
-    "NT$": "TWD",  # Taiwan Dollar
-    "HK$": "HKD",  # Hong Kong Dollar
-    "S$": "SGD",  # Singapore Dollar
-    "RM": "MYR",  # Malaysian Ringgit
-    "฿": "THB",  # Thai Baht
-    "Rp": "IDR",  # Indonesian Rupiah
-    "K": "MMK",  # Myanmar Kyat
-    "Rs": "LKR",  # Sri Lankan Rupee
-    "Nu": "BTN",  # Bhutanese Ngultrum
-    "MVR": "MVR",  # Maldivian Rufiyaa
-    
-    # Middle Eastern currencies
-    "ع.د": "IQD",  # Iraqi Dinar
-    "ل.ل": "LBP",  # Lebanese Pound
-    "د.ا": "JOD",  # Jordanian Dinar
-    "ر.س": "SAR",  # Saudi Riyal
-    "د.إ": "AED",  # UAE Dirham
-    "ر.ق": "QAR",  # Qatari Riyal
-    "د.ك": "KWD",  # Kuwaiti Dinar
-    "د.ب": "BHD",  # Bahraini Dinar
-    "ر.ع.": "OMR",  # Omani Rial
-    "ر.ي": "YER",  # Yemeni Rial
-    "ج.م": "EGP",  # Egyptian Pound
-    "ل.د": "LYD",  # Libyan Dinar
-    "د.ت": "TND",  # Tunisian Dinar
-    "د.ج": "DZD",  # Algerian Dinar
-    "د.م.": "MAD",  # Moroccan Dirham
-    "ج.س.": "SDG",  # Sudanese Pound
-    "SSP": "SSP",  # South Sudanese Pound
-    
-    # African currencies
-    "KSh": "KES",  # Kenyan Shilling
-    "USh": "UGX",  # Ugandan Shilling
-    "TSh": "TZS",  # Tanzanian Shilling
-    "FRw": "RWF",  # Rwandan Franc
-    "FBu": "BIF",  # Burundian Franc
-    "MT": "MZN",  # Mozambican Metical
-    "P": "BWP",  # Botswanan Pula
-    "N$": "NAD",  # Namibian Dollar
-    "Ar": "MGA",  # Malagasy Ariary
-    "CF": "KMF",  # Comorian Franc
-    "MK": "MWK",  # Malawian Kwacha
-    "ZK": "ZMW",  # Zambian Kwacha
-    "Kz": "AOA",  # Angolan Kwanza
-    "FC": "CDF",  # Congolese Franc
-    "FCFA": "XAF",  # Central African Franc
-    "Db": "STD",  # Sao Tomean Dobra
-    "D": "GMD",  # Gambian Dalasi
-    "FG": "GNF",  # Guinean Franc
-    "CFA": "XOF",  # West African Franc
-    "Le": "SLL",  # Sierra Leonean Leone
-    "L$": "LRD",  # Liberian Dollar
-    "Br": "ETB",  # Ethiopian Birr
-    "Nfk": "ERN",  # Eritrean Nakfa
-    "Fdj": "DJF",  # Djiboutian Franc
-    "S": "SOS",  # Somali Shilling
-    
-    # Caribbean & Central American currencies
-    "J$": "JMD",  # Jamaican Dollar
-    "BZ$": "BZD",  # Belize Dollar
-    "TT$": "TTD",  # Trinidad and Tobago Dollar
-    "Bds$": "BBD",  # Barbadian Dollar
-    "EC$": "XCD",  # East Caribbean Dollar
-    "GY$": "GYD",  # Guyanese Dollar
-    "SRD": "SRD",  # Surinamese Dollar
-    "RD$": "DOP",  # Dominican Peso
-    
-    # Pacific Island currencies
-    "FJ$": "FJD",  # Fijian Dollar
-    "PGK": "PGK",  # Papua New Guinean Kina
-    "SI$": "SBD",  # Solomon Islands Dollar
-    "WS$": "WST",  # Samoan Tala
-    "VT": "VUV",  # Vanuatu Vatu
-    
-    # European currencies
-    "ISK": "ISK",  # Icelandic Krona
-    "Lt": "LTL",  # Lithuanian Litas
-    "Ls": "LVL",  # Latvian Lats
-    "EEK": "EEK",  # Estonian Kroon
-    "NOK": "NOK",  # Norwegian Krone
-    "SEK": "SEK",  # Swedish Krona
-    "ALL": "ALL",  # Albanian Lek
-    
-    # South American currencies
-    "Gs": "PYG",  # Paraguayan Guarani
-    "Bs.S": "VES",  # Venezuelan Bolívar Soberano
-    "Bs": "VEF",  # Venezuelan Bolívar
-    "$U": "UYU",  # Uruguayan Peso
-    "$a": "ARS",  # Argentine Peso
-    "$b": "BOB",  # Bolivian Boliviano
-    "CLP": "CLP",  # Chilean Peso
-    "COP": "COP",  # Colombian Peso
-    "MXN": "MXN",  # Mexican Peso
-    
-    # Small Island Nations
-    "BMD": "BMD",  # Bermudian Dollar
-    "BSD": "BSD",  # Bahamian Dollar
-    "KYD": "KYD",  # Cayman Islands Dollar
-    "TVD": "TVD",  # Tuvaluan Dollar
-    "ZWL": "ZWL",  # Zimbabwean Dollar
-    
-    # Additional African currencies
-    "LSL": "LSL",  # Lesotho Loti
-    "SZL": "SZL",  # Swazi Lilangeni
-    "CVE": "CVE",  # Cape Verdean Escudo
-    "MRO": "MRO",  # Mauritanian Ouguiya
-    "MRU": "MRU",  # Mauritanian Ouguiya
-    "SCR": "SCR",  # Seychellois Rupee
-    "SHP": "SHP",  # Saint Helena Pound
-    
-    # Additional Asian currencies
-    "BND": "BND",  # Brunei Dollar
-    "MOP": "MOP",  # Macanese Pataca
-    "NPR": "NPR",  # Nepalese Rupee
-    
-    # Additional Pacific currencies
-    "NZD": "NZD",  # New Zealand Dollar
-    
-    # Alternative $ symbols for countries (context-dependent)
-    "$BMD": "BMD",  # Bermudian Dollar
-    "$BSD": "BSD",  # Bahamian Dollar
-    "$BZD": "BZD",  # Belize Dollar
-    "$KYD": "KYD",  # Cayman Islands Dollar
-    "$FJD": "FJD",  # Fijian Dollar
-    "$GYD": "GYD",  # Guyanese Dollar
-    "$JMD": "JMD",  # Jamaican Dollar
-    "$LRD": "LRD",  # Liberian Dollar
-    "$NAD": "NAD",  # Namibian Dollar
-    "$SBD": "SBD",  # Solomon Islands Dollar
-    "$SRD": "SRD",  # Surinamese Dollar
-    "$TTD": "TTD",  # Trinidad and Tobago Dollar
-    "$TVD": "TVD",  # Tuvaluan Dollar
-    "$VUV": "VUV",  # Vanuatu Vatu
-    "$WST": "WST",  # Samoan Tala
-    "$XCD": "XCD",  # East Caribbean Dollar
-    "$ZWL": "ZWL",  # Zimbabwean Dollar
-    "$BWP": "BWP",  # Botswanan Pula
-    "$LSL": "LSL",  # Lesotho Loti
-    "$SZL": "SZL",  # Swazi Lilangeni
-    "$ZAR": "ZAR",  # South African Rand
-    "$HKD": "HKD",  # Hong Kong Dollar
-    "$SGD": "SGD",  # Singapore Dollar
-    "$TWD": "TWD",  # Taiwan Dollar
-    "$CHF": "CHF",  # Swiss Franc
-    "$DKK": "DKK",  # Danish Krone
-    "$NOK": "NOK",  # Norwegian Krone
-    "$SEK": "SEK",  # Swedish Krona
-    "$ARS": "ARS",  # Argentine Peso
-    "$BOB": "BOB",  # Bolivian Boliviano
-    "$CLP": "CLP",  # Chilean Peso
-    "$COP": "COP",  # Colombian Peso
-    "$MXN": "MXN",  # Mexican Peso
-    "$PEN": "PEN",  # Peruvian Sol
-    "$UYU": "UYU",  # Uruguayan Peso
-    "$VES": "VES",  # Venezuelan Bolívar Soberano
-    
-    # Cryptocurrencies (for modern business plans)
-    "₿": "BTC",  # Bitcoin
-    "Ξ": "ETH",  # Ethereum
-    "Ł": "LTC",  # Litecoin
-    
-    # Special Drawing Rights
-    "XDR": "XDR",  # Special Drawing Rights
-    
-    # Precious Metals
-    "XAU": "XAU",  # Gold (troy ounce)
-    "XAG": "XAG",  # Silver (troy ounce)
-    "XPT": "XPT",  # Platinum (troy ounce)
-    "XPD": "XPD",  # Palladium (troy ounce)
-    
-    # Other
-    "XTS": "XTS",  # Testing Currency Code
-    "XXX": "XXX",  # No Currency
-    
-    # Missing currencies from canonical_currency_map.py
-    "ADP": "ADP",  # Andorran Peseta
-    "AFA": "AFA",  # Afghan Afghani (1927–2002)
-    "ALK": "ALK",  # Albanian Lek (1946–1965)
-    "ANG": "ANG",  # Netherlands Antillean Guilder
-    "AOK": "AOK",  # Angolan Kwanza (1977–1991)
-    "AON": "AON",  # Angolan New Kwanza (1990–2000)
-    "AOR": "AOR",  # Angolan Readjusted Kwanza (1995–1999)
-    "ARA": "ARA",  # Argentine Austral
-    "ARL": "ARL",  # Argentine Peso Ley (1970–1983)
-    "ARM": "ARM",  # Argentine Peso (1881–1970)
-    "ARP": "ARP",  # Argentine Peso (1983–1985)
-    "ATS": "ATS",  # Austrian Schilling
-    "AZM": "AZM",  # Azerbaijani Manat (1993–2006)
-    "BAD": "BAD",  # Bosnia-Herzegovina Dinar (1992–1994)
-    "BAN": "BAN",  # Bosnia-Herzegovina New Dinar (1994–1997)
-    "BEC": "BEC",  # Belgian Franc (convertible)
-    "BEF": "BEF",  # Belgian Franc
-    "BEL": "BEL",  # Belgian Franc (financial)
-    "BGL": "BGL",  # Bulgarian Hard Lev
-    "BGM": "BGM",  # Bulgarian Socialist Lev
-    "BGO": "BGO",  # Bulgarian Lev (1879–1952)
-    "BOL": "BOL",  # Bolivian Boliviano (1863–1963)
-    "BOP": "BOP",  # Bolivian Peso
-    "BOV": "BOV",  # Bolivian Mvdol
-    "BRB": "BRB",  # Brazilian New Cruzeiro (1967–1986)
-    "BRC": "BRC",  # Brazilian Cruzado (1986–1989)
-    "BRE": "BRE",  # Brazilian Cruzeiro (1990–1993)
-    "BRN": "BRN",  # Brazilian New Cruzado (1989–1990)
-    "BRR": "BRR",  # Brazilian Cruzeiro (1993–1994)
-    "BRZ": "BRZ",  # Brazilian Cruzeiro (1942–1967)
-    "BUK": "BUK",  # Burmese Kyat
-    "BYB": "BYB",  # Belarusian Ruble (1994–1999)
-    "BYN": "BYN",  # Belarusian Ruble
-    "BYR": "BYR",  # Belarusian Ruble (2000–2016)
-    "CA$": "CAD",  # Canadian Dollar
-    "CHE": "CHE",  # WIR Euro
-    "CHW": "CHW",  # WIR Franc
-    "CLE": "CLE",  # Chilean Escudo
-    "CLF": "CLF",  # Chilean Unit of Account (UF)
-    "CNH": "CNH",  # Chinese Yuan (offshore)
-    "CNX": "CNX",  # Chinese People's Bank Dollar
-    "CN¥": "CNY",  # Chinese Yuan
-    "COU": "COU",  # Colombian Real Value Unit
-    "CSD": "CSD",  # Serbian Dinar (2002–2006)
-    "CSK": "CSK",  # Czechoslovak Hard Koruna
-    "CUC": "CUC",  # Cuban Convertible Peso
-    "CUP": "CUP",  # Cuban Peso
-    "CYP": "CYP",  # Cypriot Pound
-    "DDM": "DDM",  # East German Mark
-    "DEM": "DEM",  # German Mark
-    "ECS": "ECS",  # Ecuadorian Sucre
-    "ECV": "ECV",  # Ecuadorian Unit of Constant Value
-    "ESA": "ESA",  # Spanish Peseta (A account)
-    "ESB": "ESB",  # Spanish Peseta (convertible account)
-    "ESP": "ESP",  # Spanish Peseta
-    "FIM": "FIM",  # Finnish Markka
-    "FKP": "FKP",  # Falkland Islands Pound
-    "FRF": "FRF",  # French Franc
-    "GEK": "GEK",  # Georgian Kupon Larit
-    "GHC": "GHC",  # Ghanaian Cedi (1979–2007)
-    "GIP": "GIP",  # Gibraltar Pound
-    "GNS": "GNS",  # Guinean Syli
-    "GQE": "GQE",  # Equatorial Guinean Ekwele
-    "GRD": "GRD",  # Greek Drachma
-    "GWE": "GWE",  # Portuguese Guinea Escudo
-    "GWP": "GWP",  # Guinea-Bissau Peso
-    "HRD": "HRD",  # Croatian Dinar
-    "HRK": "HRK",  # Croatian Kuna
-    "HTG": "HTG",  # Haitian Gourde
-    "IEP": "IEP",  # Irish Pound
-    "ILP": "ILP",  # Israeli Pound
-    "ILR": "ILR",  # Israeli Shekel (1980–1985)
-    "ISJ": "ISJ",  # Icelandic Króna (1918–1981)
-    "ITL": "ITL",  # Italian Lira
-    "KGS": "KGS",  # Kyrgystani Som
-    "KPW": "KPW",  # North Korean Won
-    "KRH": "KRH",  # South Korean Hwan (1953–1962)
-    "KRO": "KRO",  # South Korean Won (1945–1953)
-    "LTT": "LTT",  # Lithuanian Talonas
-    "LUC": "LUC",  # Luxembourgian Convertible Franc
-    "LUF": "LUF",  # Luxembourgian Franc
-    "LUL": "LUL",  # Luxembourg Financial Franc
-    "LVR": "LVR",  # Latvian Ruble
-    "MAF": "MAF",  # Moroccan Franc
-    "MCF": "MCF",  # Monegasque Franc
-    "MDC": "MDC",  # Moldovan Cupon
-    "MDL": "MDL",  # Moldovan Leu
-    "MGF": "MGF",  # Malagasy Franc
-    "MKN": "MKN",  # Macedonian Denar (1992–1993)
-    "MLF": "MLF",  # Malian Franc
-    "MNT": "MNT",  # Mongolian Tugrik
-    "MTL": "MTL",  # Maltese Lira
-    "MTP": "MTP",  # Maltese Pound
-    "MUR": "MUR",  # Mauritian Rupee
-    "MVP": "MVP",  # Maldivian Rupee (1947–1981)
-    "MX$": "MXN",  # Mexican Peso
-    "MXP": "MXP",  # Mexican Silver Peso (1861–1992)
-    "MXV": "MXV",  # Mexican Investment Unit
-    "MZE": "MZE",  # Mozambican Escudo
-    "MZM": "MZM",  # Mozambican Metical (1980–2006)
-    "NIC": "NIC",  # Nicaraguan Córdoba (1988–1991)
-    "NIO": "NIO",  # Nicaraguan Córdoba
-    "NLG": "NLG",  # Dutch Guilder
-    "NZ$": "NZD",  # New Zealand Dollar
-    "PAB": "PAB",  # Panamanian Balboa
-    "PEI": "PEI",  # Peruvian Inti
-    "PES": "PES",  # Peruvian Sol (1863–1965)
-    "PLZ": "PLZ",  # Polish Zloty (1950–1995)
-    "PTE": "PTE",  # Portuguese Escudo
-    "RHD": "RHD",  # Rhodesian Dollar
-    "ROL": "ROL",  # Romanian Leu (1952–2006)
-    "RUR": "RUR",  # Russian Ruble (1991–1998)
-    "SDD": "SDD",  # Sudanese Dinar (1992–2007)
-    "SDP": "SDP",  # Sudanese Pound (1957–1998)
-    "SIT": "SIT",  # Slovenian Tolar
-    "SKK": "SKK",  # Slovak Koruna
-    "SLE": "SLE",  # Sierra Leonean Leone
-    "SRG": "SRG",  # Surinamese Guilder
-    "STN": "STN",  # São Tomé & Príncipe Dobra
-    "SUR": "SUR",  # Soviet Rouble
-    "SVC": "SVC",  # Salvadoran Colón
-    "SYP": "SYP",  # Syrian Pound
-    "TJR": "TJR",  # Tajikistani Ruble
-    "TJS": "TJS",  # Tajikistani Somoni
-    "TMM": "TMM",  # Turkmenistani Manat (1993–2009)
-    "TMT": "TMT",  # Turkmenistani Manat
-    "TPE": "TPE",  # Timorese Escudo
-    "TRL": "TRL",  # Turkish Lira (1922–2005)
-    "UAK": "UAK",  # Ukrainian Karbovanets
-    "UGS": "UGS",  # Ugandan Shilling (1966–1987)
-    "USN": "USN",  # US Dollar (Next day)
-    "USS": "USS",  # US Dollar (Same day)
-    "UYI": "UYI",  # Uruguayan Peso (Indexed Units)
-    "UYP": "UYP",  # Uruguayan Peso (1975–1993)
-    "UYW": "UYW",  # Uruguayan Nominal Wage Index Unit
-    "VEB": "VEB",  # Venezuelan Bolívar (1871–2008)
-    "VED": "VED",  # Bolívar Soberano
-    "VNN": "VNN",  # Vietnamese Dong (1978–1985)
-    "XBA": "XBA",  # European Composite Unit
-    "XBB": "XBB",  # European Monetary Unit
-    "XBC": "XBC",  # European Unit of Account (XBC)
-    "XBD": "XBD",  # European Unit of Account (XBD)
-    "Cg.": "XCG",  # Caribbean guilder
-    "XEU": "XEU",  # European Currency Unit
-    "XFO": "XFO",  # French Gold Franc
-    "XFU": "XFU",  # French UIC-Franc
-    "F CFA": "XOF",  # West African CFA Franc
-    "XRE": "XRE",  # RINET Funds
-    "XSU": "XSU",  # Sucre
-    "XUA": "XUA",  # ADB Unit of Account
-    "¤": "XXX",  # Unknown Currency
-    "YDD": "YDD",  # Yemeni Dinar
-    "YUD": "YUD",  # Yugoslavian Hard Dinar (1966–1990)
-    "YUM": "YUM",  # Yugoslavian New Dinar (1994–2002)
-    "YUN": "YUN",  # Yugoslavian Convertible Dinar (1990–1992)
-    "YUR": "YUR",  # Yugoslavian Reformed Dinar (1992–1993)
-    "ZAL": "ZAL",  # South African Rand (financial)
-    "ZMK": "ZMK",  # Zambian Kwacha (1968–2012)
-    "ZRN": "ZRN",  # Zairean New Zaire (1993–1998)
-    "ZRZ": "ZRZ",  # Zairean Zaire (1971–1993)
-    "ZWD": "ZWD",  # Zimbabwean Dollar (1980–2008)
-    "ZWG": "ZWG",  # Zimbabwean Gold
-    "ZWR": "ZWR",  # Zimbabwean Dollar (2008)
-    "US$": "USD",  # US Dollar
-    "C$": "NIO",  # Nicaraguan Córdoba
-    "TT$": "TTD",  # Trinidad & Tobago Dollar
-    "BD$": "BBD",  # Barbadian Dollar
-    "B$": "BND",  # Brunei Dollar
-    "SI$": "SBD",  # Solomon Islands Dollar
-    "G$": "GYD",  # Guyanaese Dollar
-    "SR$": "SRD",  # Surinamese Dollar
-    "CLP$": "CLP",  # Chilean Peso
-    "Bs.": "VES",  # Venezuelan Bolívar
-    "Rf": "MVR",  # Maldivian Rufiyaa
-    "SSh": "SOS",  # Somali Shilling
-    "GH₵": "GHS",  # Ghanaian Cedi
-    "Br": "BYN",  # Belarusian Ruble
-    "CFA F": "XOF",  # West African CFA Franc
-    "CFAF": "XAF",  # Central African CFA Franc
-    "JP¥": "JPY",  # Japanese Yen
-    "元": "TWD",  # New Taiwan Dollar
-    "TL": "TRY",  # Turkish Lira
-    "лв.": "BGN",  # Bulgarian Lev
-    "₮": "MNT",  # Mongolian Tugrik
-    "﷼": "SAR",  # Saudi Riyal
-    ".د.ب": "BHD",  # Bahraini Dinar
-    "ل.س": "SYP",  # Syrian Pound
-    "﷼‎": "IRR",  # Iranian Rial
-    "ש״ח": "ILS",  # Israeli New Shekel
-    "Fr": "CHF",  # Swiss Franc
-    "CFP": "XPF",  # CFP Franc
-    "E": "SZL",  # Swazi Lilangeni
-    "Rf.": "MVR",  # Maldivian Rufiyaa
-    "QR": "QAR",  # Qatari Riyal
-    "SR": "SAR",  # Saudi Riyal
-    "BD": "BHD",  # Bahraini Dinar
-    "KD": "KWD",  # Kuwaiti Dinar
-    "₯": "GRD",  # Greek Drachma
-    "ЅМ": "TJS",  # Tajikistani Somoni
-    "Br (BYN)": "BYN",  # Belarusian Ruble
-    "B/.": "PAB",  # Panamanian Balboa
-    "Gs.": "PYG",  # Paraguayan Guarani
-    "Afl.": "AWG",  # Aruban Florin
-    "NAƒ": "ANG",  # Netherlands Antillean Guilder
-    "lei (MDL)": "MDL",  # Moldovan Leu
-    "KM (BAM)": "BAM",  # Bosnia-Herzegovina Convertible Mark
-    "ден (MKD)": "MKD",  # Macedonian Denar
-    "kn": "HRK",  # Croatian Kuna
-    "Z$": "ZWL",  # Zimbabwean Dollar (2009–2024)
-    "RTGS$": "ZWL",  # Zimbabwean Dollar (2009–2024)
-    "Skr": "SEK",  # Swedish Krona
-    "Nkr": "NOK",  # Norwegian Krone
-    "Dkr": "DKK",  # Danish Krone
-    "Íkr": "ISK",  # Icelandic Króna
-    "AU$": "AUD",  # Australian Dollar
-    "SG$": "SGD",  # Singapore Dollar
-    "BB$": "BBD",  # Barbadian Dollar
-    "BS$": "BSD",  # Bahamian Dollar
-    "KY$": "KYD",  # Cayman Islands Dollar
-    "BM$": "BMD",  # Bermudan Dollar
-    "JM$": "JMD",  # Jamaican Dollar
-}
-
-def convert_currency_symbols_to_iso(text: str) -> str:
-    """
-    Convert currency symbols to ISO codes for PDF compatibility
-    Matches the TypeScript canonicalCurrencyMap logic
-    """
-    import re  # Import at function level to avoid scope issues
-    processed_text = text
-    
-    # Track all conversions for detailed logging
-    conversions_made = []
-    total_conversions = 0
-    
-    # Process each currency symbol in the canonical map
-    for symbol, iso_code in canonical_currency_map.items():
-        if symbol in processed_text:
-            # Check if it's a single character
-            is_single_character = len(symbol) == 1
-            is_unicode_currency = is_single_character and ord(symbol) > 127  # Non-ASCII
-            is_latin_single_letter = is_single_character and symbol.isalpha() and ord(symbol) < 128
-            
-            # Handle multi-character symbols (like "Le", "KSh", etc.)
-            is_multi_char_symbol = len(symbol) > 1
-            
-            # Skip plain Latin single letters (to avoid converting words like "A", "R", etc.)
-            # but DO convert single-character Unicode currency symbols like €, £, ¥, ؋, etc.
-            if not is_unicode_currency and is_latin_single_letter:
-                # Only convert if it's followed by a number (currency context)
-                # Pattern: R500, R 500, R500,000 etc.
-                pattern = rf'\b{re.escape(symbol)}\s*(\d{{1,3}}(?:,?\d{{3}})*(?:\.\d{{2}})?)\b'
-                matches = re.findall(pattern, processed_text)
-                
-                if matches:
-                    old_text = processed_text
-                    processed_text = re.sub(pattern, rf'{iso_code} \1', processed_text)
-                    
-                    if old_text != processed_text:
-                        conversions_made.append(f"{symbol} → {iso_code} (context: {matches})")
-                        total_conversions += len(matches)
-                continue
-            
-            # For multi-character symbols like "Ar", "Le", etc., be very careful
-            # Only convert if they appear as standalone words or in currency contexts
-            if is_multi_char_symbol and len(symbol) == 2 and symbol.isalpha():
-                # Only convert if it's a standalone word or followed by a number
-                # Pattern: \bAr\b or \bAr\s*\d or \bLe\b or \bLe\s*\d
-                standalone_pattern = rf'\b{re.escape(symbol)}\b'
-                currency_pattern = rf'\b{re.escape(symbol)}\s*(\d{{1,3}}(?:,?\d{{3}})*(?:\.\d{{2}})?)'
-                
-                # Check for standalone occurrences first
-                standalone_matches = re.findall(standalone_pattern, processed_text)
-                currency_matches = re.findall(currency_pattern, processed_text)
-                
-                if standalone_matches or currency_matches:
-                    old_text = processed_text
-                    # Replace standalone occurrences
-                    processed_text = re.sub(standalone_pattern, iso_code, processed_text)
-                    # Replace currency context occurrences
-                    processed_text = re.sub(currency_pattern, rf'{iso_code} \1', processed_text)
-                    
-                    if old_text != processed_text:
-                        conversions_made.append(f"{symbol} → {iso_code} (standalone/currency context)")
-                        total_conversions += len(standalone_matches) + len(currency_matches)
-                continue
-            
-            # For all other symbols (Unicode currency symbols, multi-character symbols)
-            # Count occurrences before replacement
-            old_count = processed_text.count(symbol)
-            
-            # Replace all occurrences
-            old_text = processed_text
-            processed_text = processed_text.replace(symbol, iso_code)
-            
-            # Check if replacement actually happened
-            if old_text != processed_text:
-                conversions_made.append(f"{symbol} → {iso_code} ({old_count} instances)")
-                total_conversions += old_count
-    
-    return processed_text

app/DocumentGeneration/__init__.py

@@ -1,56 +0,0 @@
-# Document Generation Package
-
-import os
-import sys
-
-# Add the current directory to sys.path to handle the space in folder name
-current_dir = os.path.dirname(__file__)
-if current_dir not in sys.path:
-    sys.path.insert(0, current_dir)
-
-# Import all the main functions for easy access
-from pdf_generator import create_pdf_document
-from word_generator import create_word_document
-from chart_generator import parse_embedded_chart_data, create_chart_from_data
-from table_of_content import generate_table_of_contents_after_content, add_table_of_contents_page
-from document_helpers import (
-    extract_business_name_from_content,
-    filter_empty_sections,
-    extract_subheadings,
-    remove_duplicate_headings
-)
-from grouped import (
-    parse_content_into_groups,
-    extract_key_phrases,
-    get_content_groups_info
-)
-from markdown_renderer import (
-    clean_text_for_pdf,
-    render_markdown_to_pdf,
-    render_markdown_to_pdf_grouped,
-    render_markdown_to_docx,
-    render_markdown_to_docx_grouped,
-    clean_text_for_docx
-)
-
-__all__ = [
-    'create_pdf_document',
-    'create_word_document',
-    'parse_embedded_chart_data',
-    'create_chart_from_data',
-    'generate_table_of_contents_after_content',
-    'add_table_of_contents_page',
-    'extract_business_name_from_content',
-    'filter_empty_sections',
-    'extract_subheadings',
-    'parse_content_into_groups',
-    'extract_key_phrases',
-    'get_content_groups_info',
-    'remove_duplicate_headings',
-    'clean_text_for_pdf',
-    'render_markdown_to_pdf',
-    'render_markdown_to_pdf_grouped',
-    'render_markdown_to_docx',
-    'render_markdown_to_docx_grouped',
-    'clean_text_for_docx'
-]

app/DocumentGeneration/chart_generator.py

@@ -1,384 +0,0 @@
-# Chart Generator Module
-# Contains parse_embedded_chart_data() and create_chart_from_data() functions
-
-import re
-import io
-import os
-import sys
-import base64
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-from typing import List, Dict, Any, Optional
-
-# Add the parent directory to sys.path to import from models.py
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
-from models import ExportSection
-
-def parse_embedded_chart_data(sections: List[ExportSection]) -> List[Dict[str, Any]]:
-    """Parse chart data embedded in section content using CHARTDATA markers"""
-    charts = []
-    
-    for section in sections:
-        if section.content:
-            # Look for chart data markers - handle both formats
-            chart_matches = re.findall(r'<!--CHART_DATA_START-->(.*?)<!--CHART_DATA_END-->', section.content, re.DOTALL)
-            
-            # Also check for alternative markers as fallback
-            alt_chart_matches = re.findall(r'<!--CHARTDATASTART-->(.*?)<!--CHARTDATAEND-->', section.content, re.DOTALL)
-            chart_matches.extend(alt_chart_matches)
-            
-            # logging.info(f"Section '{section.title}': Found {len(chart_matches)} chart data markers")
-            
-            for chart_data in chart_matches:
-                try:
-                    # Parse the chart data array
-                    chart_array = eval(chart_data.strip())
-                    # logging.info(f"Parsed chart array with {len(chart_array)} items")
-                    # logging.info(f"Chart array type: {type(chart_array)}")
-                    
-                    # Each chart is an array with: [Section, ChartType, Title, Period, Data]
-                    for chart_item in chart_array:
-                        if len(chart_item) >= 5:
-                            section_name = chart_item[0]
-                            chart_type = chart_item[1]  # DC=Doughnut, BG=Bar Graph, etc.
-                            chart_title = chart_item[2]
-                            period = chart_item[3]
-                            data = chart_item[4]
-                            
-                            chart_info = {
-                                "section": section_name,
-                                "type": chart_type,
-                                "title": chart_title,
-                                "period": period,
-                                "data": data,
-                                "source_section": section.title
-                            }
-                            
-                            charts.append(chart_info)
-                            # logging.info(f"Added chart: {chart_type} - {chart_title} for section {section_name}")
-                        else:
-                            # logging.warning(f"Chart item has insufficient data: {len(chart_item)} items, expected 5")
-                            pass
-                
-                except Exception as e:
-                    # logging.error(f"Failed to parse chart data for section '{section.title}': {str(e)}")
-                    continue
-            
-            # Additional debugging: Check for any chart-related content
-            if not chart_matches:
-                # Look for any chart-related markers or text
-                chart_indicators = re.findall(r'<!--.*?CHART.*?-->', section.content, re.DOTALL)
-                if chart_indicators:
-                    # logging.info(f"Section '{section.title}': Found chart indicators: {chart_indicators}")
-                    pass
-                
-                # Check for general chart text
-                if 'CHART' in section.content.upper() or 'chart' in section.content.lower():
-                    # logging.info(f"Section '{section.title}': Contains chart-related text")
-                    pass
-    
-    # logging.info(f"Total charts parsed: {len(charts)}")
-    return charts
-
-def create_enhanced_chart_style(chart_type, data, title, business_idea):
-    """Create charts with enhanced professional styling"""
-    # Set modern style
-    plt.style.use('default')
-    
-    # Design palette from image
-    colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
-    
-    if chart_type == "DC":  # Doughnut Chart
-        fig, ax = plt.subplots(figsize=(14, 10))
-        
-        # Extract labels and values from data
-        labels = [item[0] for item in data]
-        values = [item[1] for item in data]
-        
-        # Create doughnut chart with enhanced styling
-        wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
-                                         autopct='%1.1f%%', startangle=90,
-                                         wedgeprops=dict(width=0.6, edgecolor='white', linewidth=2),
-                                         textprops={'fontsize': 18})
-        
-        # Enhanced title styling
-        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
-        
-        # Add legend with enhanced styling
-        legend = ax.legend(wedges, labels, title="Categories", 
-                          loc="center left", bbox_to_anchor=(1, 0, 0.5, 1),
-                          fontsize=16, title_fontsize=18)
-        legend.get_title().set_color('#FF6B6B')
-        
-        # Add business name watermark
-        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
-                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
-        
-        plt.tight_layout()
-        return fig
-        
-    elif chart_type == "BG":  # Bar Graph
-        fig, ax = plt.subplots(figsize=(16, 10))
-        
-        # Extract labels and values
-        labels = [item[0] for item in data]
-        values = [item[1] for item in data]
-        
-        # Create bar chart with enhanced styling
-        bars = ax.bar(labels, values, color=colors[:len(values)], 
-                     edgecolor='white', linewidth=1, alpha=0.8)
-        
-        # Add value labels on bars
-        for bar, value in zip(bars, values):
-            height = bar.get_height()
-            ax.text(bar.get_x() + bar.get_width()/2., height + max(values)*0.01,
-                   f'{value}', ha='center', va='bottom', fontweight='bold', fontsize=18)
-        
-        # Enhanced styling
-        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
-        ax.set_xlabel('Categories', fontsize=18, color='#6B7280')
-        ax.set_ylabel('Values', fontsize=18, color='#6B7280')
-        
-        # Rotate x-axis labels for better readability
-        plt.setp(ax.get_xticklabels(), rotation=45, ha='right', fontsize=16)
-        plt.setp(ax.get_yticklabels(), fontsize=16)
-        
-        # Add grid for better readability
-        ax.yaxis.grid(True, alpha=0.3)
-        ax.set_axisbelow(True)
-        
-        # Add business name watermark
-        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
-                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
-        
-        plt.tight_layout()
-        return fig
-        
-    elif chart_type == "LG":  # Line Graph
-        fig, ax = plt.subplots(figsize=(16, 10))
-        
-        # Extract data
-        x_values = [item[0] for item in data]
-        y_values = [item[1] for item in data]
-        
-        # Create line chart with enhanced styling
-        ax.plot(x_values, y_values, color='#FF6B6B', linewidth=3, marker='o', 
-               markersize=8, markerfacecolor='white', markeredgecolor='#FF6B6B')
-        
-        # Fill area under line
-        ax.fill_between(x_values, y_values, alpha=0.3, color='#4ECDC4')
-        
-        # Enhanced styling
-        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
-        ax.set_xlabel('Time Period', fontsize=18, color='#6B7280')
-        ax.set_ylabel('Values', fontsize=18, color='#6B7280')
-        
-        # Add grid
-        ax.grid(True, alpha=0.3)
-        ax.set_axisbelow(True)
-        
-        # Increase tick label font sizes
-        plt.setp(ax.get_xticklabels(), fontsize=16)
-        plt.setp(ax.get_yticklabels(), fontsize=16)
-        
-        # Add business name watermark
-        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
-                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
-        
-        plt.tight_layout()
-        return fig
-        
-    elif chart_type == "PG":  # Pie Graph
-        fig, ax = plt.subplots(figsize=(14, 10))
-        
-        # Extract labels and values
-        labels = [item[0] for item in data]
-        values = [item[1] for item in data]
-        
-        # Create pie chart with enhanced styling
-        wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
-                                         autopct='%1.1f%%', startangle=90,
-                                         wedgeprops=dict(edgecolor='white', linewidth=2),
-                                         textprops={'fontsize': 18})
-        
-        # Enhanced title styling
-        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
-        
-        # Add business name watermark
-        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
-                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
-        
-        plt.tight_layout()
-        return fig
-    
-    return None
-
-def create_chart_from_data(chart_info: Dict[str, Any], business_idea: str) -> bytes:
-    """Create a matplotlib chart from parsed chart data with enhanced styling"""
-    try:
-        chart_type = chart_info["type"]
-        chart_title = chart_info["title"]
-        data = chart_info["data"]
-        
-        # logging.info(f"Creating chart: {chart_type} - {chart_title} with {len(data)} data points")
-        
-        # Use enhanced styling function
-        fig = create_enhanced_chart_style(chart_type, data, chart_title, business_idea)
-        
-        if fig is None:
-            # Fallback to original method if enhanced styling fails
-            if chart_type == "DC":  # Doughnut Chart
-                fig, ax = plt.subplots(figsize=(14, 10))  # Larger size for better visibility
-                
-                # Extract labels and values from data
-                labels = [item[0] for item in data]
-                values = [item[1] for item in data]
-                
-                # High contrast color scheme
-                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
-                
-                # Create doughnut chart
-                wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
-                                                 autopct='%1.1f%%', startangle=90,
-                                                 wedgeprops=dict(width=0.6, edgecolor='white', linewidth=2),
-                                                 textprops={'fontsize': 18})
-                
-                # Enhanced title
-                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
-                
-                # Add legend
-                ax.legend(wedges, labels, title="Categories", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1), fontsize=16)
-                
-                plt.tight_layout()
-            elif chart_type == "BG":  # Bar Graph
-                fig, ax = plt.subplots(figsize=(16, 10))
-                
-                # Extract labels and values
-                labels = [item[0] for item in data]
-                values = [item[1] for item in data]
-                
-                # High contrast color scheme
-                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
-                
-                # Create bar chart
-                bars = ax.bar(labels, values, color=colors[:len(values)], 
-                             edgecolor='white', linewidth=1, alpha=0.8)
-                
-                # Add value labels on bars
-                for bar, value in zip(bars, values):
-                    height = bar.get_height()
-                    ax.text(bar.get_x() + bar.get_width()/2., height + max(values)*0.01,
-                           f'{value}', ha='center', va='bottom', fontweight='bold', fontsize=18)
-                
-                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
-                ax.set_xlabel('Categories', fontsize=18, color='#6B7280')
-                ax.set_ylabel('Values', fontsize=18, color='#6B7280')
-                
-                # Rotate x-axis labels
-                plt.setp(ax.get_xticklabels(), rotation=45, ha='right', fontsize=16)
-                plt.setp(ax.get_yticklabels(), fontsize=16)
-                
-                # Add grid
-                ax.yaxis.grid(True, alpha=0.3)
-                ax.set_axisbelow(True)
-                
-                plt.tight_layout()
-            elif chart_type == "LG":  # Line Graph
-                fig, ax = plt.subplots(figsize=(16, 10))
-                
-                # Extract data
-                x_values = [item[0] for item in data]
-                y_values = [item[1] for item in data]
-                
-                # Create line chart
-                ax.plot(x_values, y_values, color='#FF6B6B', linewidth=3, marker='o', 
-                       markersize=8, markerfacecolor='white', markeredgecolor='#FF6B6B')
-                
-                # Fill area under line
-                ax.fill_between(x_values, y_values, alpha=0.3, color='#4ECDC4')
-                
-                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
-                ax.set_xlabel('Time Period', fontsize=18, color='#6B7280')
-                ax.set_ylabel('Values', fontsize=18, color='#6B7280')
-                
-                # Add grid
-                ax.grid(True, alpha=0.3)
-                ax.set_axisbelow(True)
-                
-                # Increase tick label font sizes
-                plt.setp(ax.get_xticklabels(), fontsize=16)
-                plt.setp(ax.get_yticklabels(), fontsize=16)
-                
-                plt.tight_layout()
-            elif chart_type == "PG":  # Pie Graph
-                fig, ax = plt.subplots(figsize=(14, 10))
-                
-                # Extract labels and values
-                labels = [item[0] for item in data]
-                values = [item[1] for item in data]
-                
-                # High contrast color scheme
-                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
-                
-                # Create pie chart
-                wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
-                                                 autopct='%1.1f%%', startangle=90,
-                                                 wedgeprops=dict(edgecolor='white', linewidth=2),
-                                                 textprops={'fontsize': 18})
-                
-                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
-                
-                plt.tight_layout()
-            else:
-                # logging.warning(f"Unknown chart type: {chart_type}")
-                return None
-        
-        # Save to bytes
-        buffer = io.BytesIO()
-        fig.savefig(buffer, format='png', dpi=300, bbox_inches='tight', 
-                   facecolor='white', edgecolor='none')
-        buffer.seek(0)
-        chart_bytes = buffer.getvalue()
-        buffer.close()
-        
-        # Close the figure to free memory
-        plt.close(fig)
-        
-        return chart_bytes
-        
-    except Exception as e:
-        # logging.error(f"Failed to create chart: {str(e)}")
-        return None
-
-def fix_base64_padding(base64_string: str) -> str:
-    """Fix common base64 padding issues"""
-    # Remove any whitespace or newlines
-    base64_string = base64_string.strip()
-    
-    # Add padding if needed
-    missing_padding = len(base64_string) % 4
-    if missing_padding:
-        base64_string += '=' * (4 - missing_padding)
-    
-    return base64_string
-
-def robust_base64_decode(base64_string: str) -> Optional[bytes]:
-    """Robustly decode base64 string with error handling and padding correction"""
-    try:
-        # First try direct decoding
-        return base64.b64decode(base64_string)
-    except Exception as e1:
-        try:
-            # Try with padding correction
-            fixed_string = fix_base64_padding(base64_string)
-            return base64.b64decode(fixed_string)
-        except Exception as e2:
-            try:
-                # Try with URL-safe base64
-                return base64.urlsafe_b64decode(fix_base64_padding(base64_string))
-            except Exception as e3:
-                try:
-                    # Try with standard base64 ignoring padding
-                    return base64.b64decode(base64_string + '==', validate=False)
-                except Exception as e4:
-                    return None

app/DocumentGeneration/document_helpers.py

@@ -1,159 +0,0 @@
-# Document Helper Functions
-# Contains helper functions like filter_empty_sections(), extract_business_name_from_content(), etc.
-
-import re
-import os
-import sys
-from typing import List, Dict, Any
-
-# Add the parent directory to sys.path to import from models.py
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
-from models import ExportSection
-
-def extract_business_name_from_content(sections: List[ExportSection]) -> str:
-    """Extract business name from markdown content"""
-    for section in sections:
-        if section.content:
-            lines = section.content.split('\n')
-            for i, line in enumerate(lines):
-                line = line.strip()
-                # Look for "Business Name:" pattern
-                if '**Business Name:**' in line or 'Business Name:' in line:
-                    # Extract the business name from the line
-                    if '**Business Name:**' in line:
-                        business_name = line.split('**Business Name:**')[1].strip()
-                    else:
-                        business_name = line.split('Business Name:')[1].strip()
-                    
-                    # Keep markdown formatting - don't strip ** symbols
-                    # business_name = re.sub(r'[*_`~]', '', business_name)
-                    business_name = business_name.strip()
-                    
-                    if business_name:
-                        return business_name
-                    
-                    # If not found on same line, check next line
-                    if i + 1 < len(lines):
-                        next_line = lines[i + 1].strip()
-                        business_name = next_line  # Keep ** symbols
-                        business_name = business_name.strip()
-                        if business_name:
-                            return business_name
-    
-    return None
-
-def extract_subheadings(content: str) -> List[str]:
-    """Extract subheadings from markdown content"""
-    subheadings = []
-    lines = content.split('\n')
-    
-    for line in lines:
-        line = line.strip()
-        # Look for various markdown header patterns
-        if (line.startswith('##') and not line.startswith('###')) or \
-           line.startswith('**') and line.endswith('**') and len(line) > 4:
-            # Remove markdown formatting and clean up
-            if line.startswith('##'):
-                subheading = re.sub(r'^##+\s*', '', line)
-            else:
-                # Handle bold text that might be headings - keep ** symbols
-                subheading = line  # Keep ** symbols instead of stripping them
-            
-            # subheading = re.sub(r'[*_`~]', '', subheading)  # Commented out to preserve ** symbols
-            if subheading.strip() and len(subheading.strip()) > 3:  # Avoid very short headings
-                subheadings.append(subheading.strip())
-    
-    return subheadings
-
-
-
-
-
-
-
-
-
-
-
-def filter_empty_sections(sections: List[ExportSection]) -> List[ExportSection]:
-    """Filter out sections with no content to prevent empty pages"""
-    filtered_sections = []
-    
-    for section in sections:
-        if section.content and section.content.strip():
-            # Clean the content to check if it's actually meaningful
-            cleaned_content = section.content # No clean_text_for_pdf import, so use raw content
-            if cleaned_content and len(cleaned_content.strip()) > 10:  # At least 10 characters
-                filtered_sections.append(section)
-                # logging.info(f"Section '{section.title}' passed filtering with {len(cleaned_content)} characters")
-            else:
-                # logging.info(f"Section '{section.title}' filtered out - content too short: {len(cleaned_content) if cleaned_content else 0} chars")
-                pass
-        else:
-            # logging.info(f"Section '{section.title}' filtered out - no content")
-            pass
-    
-    # logging.info(f"Filtered sections: {len(filtered_sections)} out of {len(sections)} total")
-    return filtered_sections
-
-
-def remove_duplicate_headings(content: str) -> str:
-    """Remove duplicate headings from content"""
-    if not content:
-        return content
-    
-    lines = content.split('\n')
-    cleaned_lines = []
-    seen_headings = set()
-    
-    for line in lines:
-        line = line.strip()
-        if not line:
-            cleaned_lines.append('')
-            continue
-        
-        # Check if this is any type of heading
-        is_heading = False
-        heading_text = ""
-        
-        # Markdown headings (# ## ### etc.)
-        if line.startswith('#'):
-            heading_text = re.sub(r'^#+\s*', '', line).strip()
-            is_heading = True
-        
-        # Bold headings (**text**)
-        elif line.startswith('**') and line.endswith('**') and len(line) > 4:
-            heading_text = line[2:-2].strip()  # Remove ** symbols
-            is_heading = True
-        
-        # Check for numbered headings (e.g., "8.1 Management Team")
-        elif re.match(r'^\d+\.?\d*\s+', line):
-            heading_text = re.sub(r'^\d+\.?\d*\s+', '', line).strip()
-            is_heading = True
-        
-        if is_heading and heading_text:
-            # Normalize the heading text for comparison
-            normalized_text = heading_text.lower().strip()
-            
-            # Also check for variations with "and" vs "&"
-            variations = [
-                normalized_text,
-                normalized_text.replace(' & ', ' and '),
-                normalized_text.replace(' and ', ' & '),
-                normalized_text.replace('&', 'and'),
-                normalized_text.replace('and', '&')
-            ]
-            
-            # Check if any variation has been seen before
-            is_duplicate = any(var in seen_headings for var in variations)
-            
-            if not is_duplicate:
-                # Add all variations to seen set
-                for var in variations:
-                    seen_headings.add(var)
-                cleaned_lines.append(line)
-            # Skip duplicate headings
-        else:
-            cleaned_lines.append(line)
-    
-    return '\n'.join(cleaned_lines)

app/DocumentGeneration/grouped.py

@@ -1,304 +0,0 @@
-import re
-from typing import List, Dict, Any
-
-def calculate_group_height(pdf, group: Dict[str, Any]) -> int:
-    """Calculate the estimated height needed for a complete group"""
-    subheading_type = group['subheading_type']
-    content_lines = group['content'].split('\n') if group['content'] else []
-    
-    # Base height for subheading
-    if subheading_type == 'h1':
-        subheading_height = 25  # 20pt font + spacing
-    elif subheading_type == 'h2':
-        subheading_height = 20  # 16pt font + underline + spacing
-    elif subheading_type == 'h3':
-        subheading_height = 16  # 14pt font + spacing
-    elif subheading_type == 'h4':
-        subheading_height = 14  # 12pt font + spacing
-    elif subheading_type == 'bold':
-        subheading_height = 20  # 16pt font + spacing
-    elif subheading_type == 'numbered':
-        subheading_height = 20  # 16pt font + spacing
-    else:
-        subheading_height = 16
-    
-    # Calculate content height more accurately
-    content_height = 0
-    for line in content_lines:
-        if line.strip():
-            # More accurate line height calculation
-            words = line.split()
-            if len(words) > 0:
-                # Estimate characters per line (roughly 80-90 chars per line)
-                chars_per_line = 85
-                estimated_lines = max(1, len(line) // chars_per_line + 1)
-                line_height = estimated_lines * 8  # 8pt per line
-                content_height += line_height
-            else:
-                content_height += 8  # Empty line
-        else:
-            content_height += 3  # Empty line spacing
-    
-    # Add spacing between groups
-    group_spacing = 8
-    
-    total_height = subheading_height + content_height + group_spacing
-    
-    print(f"DEBUG: Group '{group.get('subheading_clean', 'Unknown')[:30]}...' height calculation:")
-    print(f"  Subheading height: {subheading_height}")
-    print(f"  Content height: {content_height}")
-    print(f"  Group spacing: {group_spacing}")
-    print(f"  Total height: {total_height}")
-    
-    return total_height
-
-def should_break_page_for_group(pdf, group: Dict[str, Any], current_y: int, page_height: int = 280) -> bool:
-    """Determine if we should break to a new page for this group"""
-    estimated_height = calculate_group_height(pdf, group)
-    
-    print(f"DEBUG: should_break_page_for_group called")
-    print(f"DEBUG:   Subheading: '{group.get('subheading_clean', 'Unknown')[:30]}...'")
-    print(f"DEBUG:   Current Y: {current_y}")
-    print(f"DEBUG:   Estimated height: {estimated_height}")
-    print(f"DEBUG:   Page height: {page_height}")
-    print(f"DEBUG:   Available space: {page_height - current_y}")
-    print(f"DEBUG:   Will fit? {current_y + estimated_height <= page_height}")
-    
-    # CRITICAL FIX: Only break if the group absolutely won't fit
-    # This prevents splitting subheadings from their content
-    
-    # If the group won't fit on current page, break
-    if current_y + estimated_height > page_height:
-        print(f"DEBUG:   -> BREAKING: Group won't fit ({current_y} + {estimated_height} > {page_height})")
-        return True
-    
-    # If we're very close to the end of the page (less than 50mm remaining) and group is significant, break
-    if current_y > page_height - 50 and estimated_height > 30:
-        print(f"DEBUG:   -> BREAKING: Very close to end of page ({current_y} > {page_height - 50}) and group significant ({estimated_height} > 30)")
-        return True
-    
-    print(f"DEBUG:   -> NO BREAK: Group will fit on current page")
-    return False
-
-def clean_markdown_from_line(line: str) -> str:
-    """Clean markdown formatting from a single line"""
-    if not line:
-        return ""
-    
-    cleaned = line
-    
-    # Remove bold, italic formatting
-    cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold
-    cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic
-    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
-    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
-    
-    # Remove emphasis markers
-    cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores
-    cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks
-    
-    # Remove links (keep text)
-    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
-    
-    # Remove any remaining HTML-like tags
-    cleaned = re.sub(r'<[^>]+>', '', cleaned)
-    
-    # CRITICAL FIX: Replace multiple spaces with single space to prevent double spaces
-    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
-    
-    return cleaned.strip()
-
-def parse_content_into_groups(content: str) -> List[Dict[str, Any]]:
-    """Parse markdown content into subheading-content groups"""
-    if not content:
-        return []
-    
-    print(f"DEBUG: parse_content_into_groups called with content length: {len(content)}")
-    
-    lines = content.split('\n')
-    groups = []
-    current_group = None
-    
-    for i, line in enumerate(lines):
-        line = line.strip()
-        if not line:
-            if current_group:
-                current_group['content_lines'].append('')  # Preserve empty lines
-            continue
-        
-        # Check if this is a heading (H1, H2, H3, H4, or numbered)
-        is_heading = (
-            line.startswith('# ') or  # H1
-            (line.startswith('## ') and not line.startswith('### ')) or  # H2
-            (line.startswith('### ') and not line.startswith('#### ')) or  # H3
-            (line.startswith('#### ') and not line.startswith('##### ')) or  # H4
-            re.match(r'^\d+\.\d+\s+', line)  # Numbered subheadings like "3.6 SWOT Analysis"
-        )
-        
-        # Check if this is bold text
-        is_bold_text = (
-            (line.startswith('**') and line.endswith('**') and len(line) > 4) or  # Bold headings
-            (re.match(r'^\*\*.*?\*\*:', line) and len(line) > 4)  # Bold text before colon as heading
-        )
-
-        # Check if this is a bold list item (e.g., "- **Item**")
-        is_bold_list_item = re.match(r'^[-*]\s*\*\*(.*?)\*\*$', line)
-        
-        # Special handling for bold text following numbered subheadings
-        should_create_new_group = False
-        
-        if is_heading:
-            # Always create new group for regular headings
-            should_create_new_group = True
-            print(f"DEBUG: Line {i+1} '{line[:50]}...' - Regular heading, creating new group")
-        elif is_bold_text:
-            # Check if we should treat this bold text as content for a numbered subheading
-            if groups and groups[-1].get('subheading_type') == 'h3':
-                # Check if the previous group's subheading looks like a numbered subheading
-                previous_subheading = groups[-1].get('subheading', '')
-                if re.match(r'^\d+\.\d+\s+', previous_subheading):
-                    # This is content for a numbered subheading, add to previous group
-                    groups[-1]['content_lines'].append(line)
-                    print(f"DEBUG: Line {i+1} '{line[:50]}...' - Adding to previous numbered subheading '{previous_subheading[:30]}...'")
-                    continue  # Skip creating new group
-                else:
-                    # Not a numbered subheading, treat as new heading
-                    should_create_new_group = True
-                    print(f"DEBUG: Line {i+1} '{line[:50]}...' - Treating as NEW HEADING (not numbered subheading)")
-            else:
-                # No previous group or not a numbered subheading, treat as new heading
-                should_create_new_group = True
-                print(f"DEBUG: Line {i+1} '{line[:50]}...' - Treating as NEW HEADING (no numbered subheading)")
-        elif is_bold_list_item:
-            # If it's a bold list item, treat it as a new heading
-            should_create_new_group = True
-            print(f"DEBUG: Line {i+1} '{line[:50]}...' - Bold list item, creating new group")
-        
-        if should_create_new_group:
-            # Save previous group if it exists
-            if current_group:
-                current_group['content'] = '\n'.join(current_group['content_lines'])
-                groups.append(current_group)
-                print(f"DEBUG: Saved group '{current_group.get('subheading_clean', 'Unknown')[:30]}...' with {len(current_group['content_lines'])} content lines")
-            
-            # Clean markdown symbols BEFORE determining type and storing
-            clean_text = line
-            heading_type = 'text'
-            
-            if line.startswith('# '):
-                clean_text = line[2:].strip()  # Remove "# "
-                heading_type = 'h1'
-            elif line.startswith('## '):
-                clean_text = line[3:].strip()  # Remove "## "
-                heading_type = 'h2'
-            elif line.startswith('### '):
-                clean_text = line[4:].strip()  # Remove "### "
-                heading_type = 'h3'
-            elif line.startswith('#### '):
-                clean_text = line[5:].strip()  # Remove "#### "
-                heading_type = 'h4'
-            elif re.match(r'^\d+\.\d+\s+', line):
-                clean_text = line.strip()  # Keep numbered headings as-is
-                heading_type = 'numbered'
-            elif is_bold_text:
-                # Remove ** markers from bold text
-                clean_text = clean_markdown_from_line(line.strip())
-                heading_type = 'bold'
-            elif is_bold_list_item:
-                # Extract the bold text from list item and treat as H3 subheading
-                # Remove the list marker and ** markers
-                clean_text = re.sub(r'^[-*]\s*\*\*(.*?)\*\*', r'\1', line.strip())
-                heading_type = 'h3'  # Treat as H3 subheading
-            
-            print(f"DEBUG: Creating new group '{clean_text[:30]}...' (type: {heading_type})")
-            
-            # Start new group with cleaned text
-            current_group = {
-                'subheading': line,  # Keep original for reference
-                'content_lines': [],
-                'content': '',
-                'subheading_clean': clean_text,  # Pre-cleaned text
-                'subheading_type': heading_type
-            }
-        else:
-            # Add to current group's content - clean the line
-            if current_group:
-                cleaned_line = clean_markdown_from_line(line)
-                current_group['content_lines'].append(cleaned_line)
-                if i < 5:  # Log first few content lines
-                    print(f"DEBUG: Added content line to group '{current_group.get('subheading_clean', 'Unknown')[:30]}...': '{cleaned_line[:50]}...'")
-            else:
-                # Content before any subheading - create a default group
-                if not groups or groups[-1].get('subheading') != '## Introduction':
-                    cleaned_line = clean_markdown_from_line(line)
-                    current_group = {
-                        'subheading': '## Introduction',
-                        'content_lines': [cleaned_line],
-                        'content': '',
-                        'subheading_clean': 'Introduction',
-                        'subheading_type': 'h2'
-                    }
-    
-    # Don't forget the last group
-    if current_group:
-        current_group['content'] = '\n'.join(current_group['content_lines'])
-        groups.append(current_group)
-        print(f"DEBUG: Saved final group '{current_group.get('subheading_clean', 'Unknown')[:30]}...' with {len(current_group['content_lines'])} content lines")
-    
-    # Add metadata to each group
-    for i, group in enumerate(groups):
-        group['group_id'] = f"group_{i}"
-        group['content_length'] = len(group['content'])
-        group['word_count'] = len(group['content'].split()) if group['content'] else 0
-        group['has_charts'] = 'CHART' in group['content'].upper() if group['content'] else False
-        group['line_count'] = len([line for line in group['content'].split('\n') if line.strip()])
-    
-    print(f"DEBUG: Created {len(groups)} groups total")
-    return groups
-
-def extract_key_phrases(content: str) -> List[tuple]:
-    """Extract key phrases from content for grouping metadata"""
-    if not content:
-        return []
-    
-    # Simple key phrase extraction
-    words = re.findall(r'\b\w+\b', content.lower())
-    word_freq = {}
-    
-    for word in words:
-        if len(word) > 3:  # Only words longer than 3 characters
-            word_freq[word] = word_freq.get(word, 0) + 1
-    
-    # Return top 5 most frequent words
-    return sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
-
-def get_content_groups_info(content: str) -> Dict[str, Any]:
-    """Get detailed information about content groups for analysis and debugging"""
-    if not content:
-        return {"groups": [], "summary": {"total_groups": 0, "total_content_length": 0}}
-    
-    groups = parse_content_into_groups(content)
-    
-    # Add key phrases to each group
-    for group in groups:
-        group['key_phrases'] = extract_key_phrases(group['content'])
-    
-    # Calculate summary statistics
-    total_content_length = sum(group['content_length'] for group in groups)
-    total_word_count = sum(group['word_count'] for group in groups)
-    groups_with_charts = sum(1 for group in groups if group['has_charts'])
-    
-    summary = {
-        "total_groups": len(groups),
-        "total_content_length": total_content_length,
-        "total_word_count": total_word_count,
-        "groups_with_charts": groups_with_charts,
-        "average_group_size": total_content_length / len(groups) if groups else 0,
-        "largest_group": max(groups, key=lambda g: g['content_length'])['subheading_clean'] if groups else None,
-        "smallest_group": min(groups, key=lambda g: g['content_length'])['subheading_clean'] if groups else None
-    }
-    
-    return {
-        "groups": groups,
-        "summary": summary
-    }

app/DocumentGeneration/live_pdf_generator.py

@@ -1,126 +0,0 @@
-# Live PDF Generator Module
-# Enables real-time PDF updates as content changes
-
-import asyncio
-import io
-import tempfile
-import os
-from typing import Dict, Any, Optional, AsyncGenerator
-from fpdf import FPDF
-import base64
-
-import sys
-import os
-sys.path.append(os.path.dirname(__file__))
-from pdf_generator import create_pdf_document
-from models import ExportRequest
-
-class LivePDFGenerator:
-    """Generates and streams PDF updates in real-time"""
-    
-    def __init__(self):
-        self.active_sessions: Dict[str, 'PDFSession'] = {}
-    
-    async def create_live_session(self, business_plan_id: str, initial_request: ExportRequest) -> str:
-        """Create a new live PDF session"""
-        session_id = f"pdf_session_{business_plan_id}_{int(asyncio.get_event_loop().time())}"
-        
-        session = PDFSession(session_id, business_plan_id, initial_request)
-        self.active_sessions[session_id] = session
-        
-        # Generate initial PDF
-        await session.update_pdf(initial_request)
-        
-        return session_id
-    
-    async def update_session(self, session_id: str, updated_request: ExportRequest) -> bool:
-        """Update an existing PDF session with new content"""
-        if session_id not in self.active_sessions:
-            return False
-        
-        session = self.active_sessions[session_id]
-        await session.update_pdf(updated_request)
-        return True
-    
-    async def stream_pdf_updates(self, session_id: str) -> AsyncGenerator[bytes, None]:
-        """Stream PDF updates as they occur"""
-        if session_id not in self.active_sessions:
-            return
-        
-        session = self.active_sessions[session_id]
-        async for pdf_chunk in session.stream_updates():
-            yield pdf_chunk
-    
-    def close_session(self, session_id: str):
-        """Close and cleanup a PDF session"""
-        if session_id in self.active_sessions:
-            del self.active_sessions[session_id]
-
-class PDFSession:
-    """Individual PDF session that manages real-time updates"""
-    
-    def __init__(self, session_id: str, business_plan_id: str, initial_request: ExportRequest):
-        self.session_id = session_id
-        self.business_plan_id = business_plan_id
-        self.current_request = initial_request
-        self.update_queue = asyncio.Queue()
-        self.is_active = True
-        self.last_pdf_bytes: Optional[bytes] = None
-        
-    async def update_pdf(self, new_request: ExportRequest):
-        """Update the PDF with new content"""
-        self.current_request = new_request
-        
-        try:
-            # Generate new PDF
-            pdf_bytes, filename = create_pdf_document(new_request)
-            self.last_pdf_bytes = pdf_bytes
-            
-            # Notify subscribers of update
-            await self.update_queue.put({
-                'type': 'pdf_update',
-                'data': base64.b64encode(pdf_bytes).decode('utf-8'),
-                'filename': filename,
-                'timestamp': asyncio.get_event_loop().time()
-            })
-            
-        except Exception as e:
-            # Notify subscribers of error
-            await self.update_queue.put({
-                'type': 'pdf_error',
-                'error': str(e),
-                'timestamp': asyncio.get_event_loop().time()
-            })
-    
-    async def stream_updates(self) -> AsyncGenerator[bytes, None]:
-        """Stream PDF updates as they occur"""
-        while self.is_active:
-            try:
-                # Wait for updates with timeout
-                update = await asyncio.wait_for(self.update_queue.get(), timeout=30.0)
-                
-                if update['type'] == 'pdf_update':
-                    # Send SSE event for PDF update
-                    event_data = f"event: pdf_update\ndata: {{\"data\": \"{update['data']}\", \"filename\": \"{update['filename']}\"}}\n\n"
-                    yield event_data.encode('utf-8')
-                    
-                elif update['type'] == 'pdf_error':
-                    # Send SSE event for error
-                    error_data = f"event: pdf_error\ndata: {{\"error\": \"{update['error']}\"}}\n\n"
-                    yield error_data.encode('utf-8')
-                    
-            except asyncio.TimeoutError:
-                # Send keep-alive
-                yield b": keep-alive\n\n"
-            except Exception as e:
-                # Send error event
-                error_data = f"event: stream_error\ndata: {str(e)}\n\n"
-                yield error_data.encode('utf-8')
-                break
-    
-    def close(self):
-        """Close this session"""
-        self.is_active = False
-
-# Global instance
-live_pdf_generator = LivePDFGenerator()

app/DocumentGeneration/markdown_renderer.py

@@ -1,759 +0,0 @@
-# Markdown Renderer Module
-# Contains all markdown rendering functions for both PDF and Word
-
-import re
-import base64
-import os
-import sys
-import tempfile
-from typing import List, Dict, Any, Optional
-
-# Import from the same directory (Document Generation)
-from grouped import parse_content_into_groups, should_break_page_for_group
-from chart_generator import create_chart_from_data
-
-def clean_markdown_text(text: str) -> str:
-    """Clean markdown formatting for PDF generation - PRESERVE HEADINGS"""
-    if not text:
-        return ""
-    
-    # Remove markdown formatting BUT PRESERVE HEADING STRUCTURE
-    cleaned = text
-    
-    # PRESERVE HEADINGS - don't strip the # markers, keep them for rendering
-    # We'll handle styling at render time instead of stripping them
-    
-    # Remove bold, italic formatting - strip ** or * symbols
-    cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold
-    cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic
-    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
-    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
-    
-    # Remove links (keep text)
-    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
-    cleaned = re.sub(r'!\[([^\]]*)\]\([^)]+\)', '', cleaned)  # Remove images
-    
-    # Remove list markers (more aggressive)
-    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove list markers
-    cleaned = re.sub(r'^\s*\d+\.\s*', '', cleaned, flags=re.MULTILINE)  # Remove numbered list markers
-    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove any remaining list markers
-    
-    # Remove blockquotes
-    cleaned = re.sub(r'^\s*>\s*', '', cleaned, flags=re.MULTILINE)  # Remove blockquotes
-    
-    # Remove horizontal rules
-    cleaned = re.sub(r'^\s*[-*_]{3,}\s*$', '', cleaned, flags=re.MULTILINE)  # Remove horizontal rules
-    
-    # Remove code blocks
-    cleaned = re.sub(r'```[\s\S]*?```', '', cleaned)  # Remove code blocks
-    cleaned = re.sub(r'`.*?`', '', cleaned)  # Remove any remaining inline code
-    
-    # Remove emphasis markers - strip ** or * symbols
-    cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores
-    cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks
-    
-    # PRESERVE CHART DATA MARKERS for inline processing
-    # DO NOT REMOVE chart markers - they will be processed inline
-    # cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
-    # cleaned = re.sub(r'<!--CHARTDATASTART-->.*$', '', cleaned, flags=re.DOTALL)
-    # cleaned = re.sub(r'<!--CHARTDATAEND-->', '', cleaned)
-    
-    # REMOVE CHART DATA MARKERS for PDF rendering since they're not being processed
-    cleaned = re.sub(r'<!--CHART_DATA_START-->.*?<!--CHART_DATA_END-->', '', cleaned, flags=re.DOTALL)
-    cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
-    
-    # Remove any remaining HTML-like tags
-    cleaned = re.sub(r'<[^>]+>', '', cleaned)
-    
-    # Clean up extra whitespace and formatting
-    cleaned = re.sub(r'\n\s*\n\s*\n+', '\n\n', cleaned)  # Remove excessive line breaks
-    cleaned = re.sub(r'^\s+', '', cleaned, flags=re.MULTILINE)  # Remove leading whitespace
-    cleaned = re.sub(r'\s+$', '', cleaned, flags=re.MULTILINE)  # Remove trailing whitespace
-    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
-    
-    # Final cleanup
-    cleaned = cleaned.strip()
-    
-    return cleaned
-
-def clean_text_for_pdf(text: str) -> str:
-    """Clean text specifically for PDF generation, handling Unicode issues"""
-    if not text:
-        return ""
-    
-    # First clean markdown
-    cleaned = clean_markdown_text(text)
-    
-    # Replace problematic Unicode characters with ASCII equivalents
-    unicode_replacements = {
-        '\u2019': "'",  # Right single quotation mark
-        '\u2018': "'",  # Left single quotation mark
-        '\u201C': '"',  # Left double quotation mark
-        '\u201D': '"',  # Right double quotation mark
-        '\u2013': '-',  # En dash
-        '\u2014': '--', # Em dash
-        '\u2022': '•',  # Bullet
-        '\u2026': '...', # Horizontal ellipsis
-        '\u00A0': ' ',  # Non-breaking space
-        '\u00B0': '°',  # Degree sign
-        '\u00AE': '(R)', # Registered trademark
-        '\u2122': '(TM)', # Trademark
-        '\u00A9': '(C)', # Copyright
-    }
-    
-    for unicode_char, replacement in unicode_replacements.items():
-        cleaned = cleaned.replace(unicode_char, replacement)
-
-    # Additional space normalization after Unicode replacements to prevent double spaces
-    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
-    
-    return cleaned
-
-def process_content_with_inline_charts(doc, content: str, business_idea: str):
-    """Process content and render charts inline where they appear in the text"""
-    try:
-        from docx.shared import Inches
-    except ImportError:
-        raise Exception("python-docx is not installed. Please install it with: pip install python-docx")
-    
-    # Split content by chart markers - handle both formats
-    chart_pattern = r'<!--CHART_DATA_START-->(.*?)<!--CHART_DATA_END-->'
-    parts = re.split(chart_pattern, content, flags=re.DOTALL)
-    
-    # If no charts found, try alternative format
-    if len(parts) == 1:
-        chart_pattern = r'<!--CHARTDATASTART-->(.*?)<!--CHARTDATAEND-->'
-        parts = re.split(chart_pattern, content, flags=re.DOTALL)
-    
-    for i, part in enumerate(parts):
-        if i % 2 == 0:  # Regular content
-            if part.strip():
-                render_markdown_to_docx_grouped(doc, part.strip())
-        else:  # Chart data
-            try:
-                chart_array = eval(part.strip())
-                for chart_item in chart_array:
-                    if len(chart_item) >= 5:
-                        chart_type = chart_item[1]
-                        chart_title = chart_item[2]
-                        data = chart_item[4]
-                        
-                        # Add chart title
-                        doc.add_heading(f"{chart_title}", level=2)
-                        
-                        # Create and add chart
-                        chart_info = {
-                            "type": chart_type,
-                            "title": chart_title,
-                            "data": data
-                        }
-                        
-                        chart_bytes = create_chart_from_data(chart_info, business_idea)
-                        
-                        if chart_bytes:
-                            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
-                                tmp_img.write(chart_bytes)
-                                temp_img_path = tmp_img.name
-                            
-                            # Add image to Word document
-                            doc.add_picture(temp_img_path, width=Inches(6.0))  # 6 inches width
-                            
-                            # Clean up temp file
-                            os.remove(temp_img_path)
-            except Exception as e:
-                # If chart processing fails, just render the raw content
-                if part.strip():
-                    render_markdown_to_docx_grouped(doc, part.strip())
-
-
-def render_markdown_to_pdf(pdf, content: str, primary_color, accent_color, text_color):
-    """Render markdown content to PDF with proper heading styling and page break logic"""
-    if not content:
-        return
-    
-    lines = content.split('\n')
-    current_y = pdf.get_y()
-    
-    for line in lines:
-        line = line.strip()
-        if not line:
-            # Check if we need a page break for empty line
-            if current_y + 10 > 280:  # 280mm is roughly where we want to break
-                pdf.add_page()
-                current_y = 25
-            else:
-                pdf.ln(3)  # Consistent space for empty lines
-                current_y = pdf.get_y()
-            continue
-        
-        # Calculate estimated height needed for this line
-        estimated_height = 12  # Base height for text
-        
-        # Handle different heading levels
-        if line.startswith("# "):    # H1 - Main heading (like "Company Profile")
-            estimated_height = 25  # Heading + line + spacing
-            if current_y + estimated_height > 280:
-                pdf.add_page()
-                current_y = 25
-            
-            text = line[2:].strip()
-            pdf.set_font("Arial", "B", 20)  # Bold, size 20
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 10, text)
-            
-            # Calculate text width and make line autofit
-            text_width = pdf.get_string_width(text)
-            line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
-            
-            # Add subtle line under main heading - consistent with section titles
-            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
-            pdf.set_line_width(0.3)  # Thin line
-            pdf.line(25, current_y + 10, 25 + line_width, current_y + 10)
-            
-            current_y = pdf.get_y()
-            pdf.ln(8)  # Consistent space after main heading
-            current_y = pdf.get_y()
-            
-        elif line.startswith("## ") or re.match(r'^\d+\.\d+\s+', line):   # H2 - Subheading or numbered subheading
-            estimated_height = 20  # Subheading + line + spacing
-            if current_y + estimated_height > 280:
-                pdf.add_page()
-                current_y = 25
-            
-            text = line[3:].strip() if line.startswith("## ") else line.strip()
-            pdf.set_font("Arial", "B", 16)  # Bold, size 16
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 8, text)
-            
-            # Calculate text width and make line autofit
-            text_width = pdf.get_string_width(text)
-            line_width = min(text_width + 10, 160)  # Add 10mm padding, max 160mm
-            
-            # Add subtle line under subheading - consistent styling
-            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
-            pdf.set_line_width(0.3)  # Thin line
-            pdf.line(25, current_y + 8, 25 + line_width, current_y + 8)
-            
-            current_y = pdf.get_y()
-            pdf.ln(6)  # Consistent space after subheading
-            current_y = pdf.get_y()
-            
-        elif re.match(r'^\d+\.\d+\s+[A-Z]', line):  # Numbered subheadings like "3.6 SWOT Analysis"
-            estimated_height = 20  # Subheading + line + spacing
-            if current_y + estimated_height > 280:
-                pdf.add_page()
-                current_y = 25
-            
-            text = line.strip()
-            pdf.set_font("Arial", "B", 16)  # Bold, size 16
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 8, text)
-
-            
-            current_y = pdf.get_y()
-            pdf.ln(6)  # Consistent space after subheading
-            current_y = pdf.get_y()
-            
-        elif line.startswith("### ") or line.startswith("#### "):  # H3/H4 - Smaller subheadings
-            estimated_height = 18  # Subheading + spacing
-            if current_y + estimated_height > 280:
-                pdf.add_page()
-                current_y = 25
-            
-            text = line[4:].strip() if line.startswith("### ") else line[5:].strip()
-            pdf.set_font("Arial", "B", 14)  # Bold, size 14
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 8, text)
-            
-            current_y = pdf.get_y()
-            pdf.ln(4)  # Consistent space after subheading
-            current_y = pdf.get_y()
-            
-        elif line.startswith("**") and line.endswith("**"):  # Bold text that might be a heading
-            text = line.strip()  # Keep ** markers
-            # Check if this looks like a main heading (no numbers, not too long)
-            if not re.match(r'^\d+\.', text) and len(text) < 50:
-                estimated_height = 22  # Heading + line + spacing
-                if current_y + estimated_height > 280:
-                    pdf.add_page()
-                    current_y = 25
-                
-                pdf.set_font("Arial", "B", 18)  # Bold, size 18
-                pdf.set_text_color(*primary_color)  # Black
-                pdf.set_xy(25, current_y)
-                pdf.multi_cell(160, 9, text)
-                
-                current_y = pdf.get_y()
-                pdf.ln(6)  # Consistent space after heading
-                current_y = pdf.get_y()
-            else:
-                # Regular bold text
-                estimated_height = 12
-                if current_y + estimated_height > 280:
-                    pdf.add_page()
-                    current_y = 25
-                
-                pdf.set_font("Arial", "B", 12)  # Bold, size 12
-                pdf.set_text_color(*text_color)  # Dark gray
-                pdf.set_xy(25, current_y)
-                pdf.multi_cell(160, 8, text)
-                current_y = pdf.get_y()
-            
-        else:  # Normal paragraph text
-            # For long paragraphs, estimate height based on text length
-            estimated_height = max(12, len(line) // 80 * 12)  # Rough estimate
-            if current_y + estimated_height > 280:
-                pdf.add_page()
-                current_y = 25
-            
-            pdf.set_font("Arial", "", 12)  # Regular font, size 12
-            pdf.set_text_color(*text_color)  # Dark gray
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
-            current_y = pdf.get_y()
-
-
-def render_markdown_to_pdf_grouped(pdf, content: str, primary_color, accent_color, text_color):
-    """Render markdown content to PDF with subheading-content grouping and smart page breaks"""
-    if not content:
-        return
-    
-    print(f"DEBUG: render_markdown_to_pdf_grouped called with content length: {len(content)}")
-    print(f"DEBUG: FULL CONTENT:")
-    print("=" * 80)
-    print(content)
-    print("=" * 80)
-    
-    # Parse content into groups
-    groups = parse_content_into_groups(content)
-    
-    for group in groups:
-        subheading = group['subheading']
-        group_content = group['content']
-        subheading_type = group['subheading_type']
-        
-        # Get current Y position from PDF
-        current_y = pdf.get_y()
-        page_height = 280  # Approximate usable page height
-        
-        # Use smart page break logic
-        if should_break_page_for_group(pdf, group, current_y, page_height):
-            pdf.add_page()
-            current_y = 25
-            pdf.set_y(current_y)  # Set the PDF's Y position
-        
-        # Render subheading based on type - using original styling
-        # Use the pre-cleaned text from the group
-        text = group['subheading_clean']
-        
-        if subheading_type == 'h1':
-            pdf.set_font("Arial", "B", 20)  # Bold, size 20 (original size)
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 10, text)
-            
-            # Calculate text width and make line autofit
-            text_width = pdf.get_string_width(text)
-            line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
-            
-            # Add subtle line under main heading - consistent with section titles
-            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
-            pdf.set_line_width(0.3)  # Thin line
-            pdf.line(25, current_y + 10, 25 + line_width, current_y + 10)
-            
-            current_y = pdf.get_y()
-            pdf.ln(8)  # Consistent space after main heading
-            current_y = pdf.get_y()
-            
-        elif subheading_type == 'h2':
-            pdf.set_font("Arial", "B", 18)  # Bold, size 18 (original size)
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 9, text)
-            
-            # Add underline (original styling)
-            text_width = pdf.get_string_width(text)
-            line_width = min(text_width + 12, 160)
-            pdf.set_draw_color(221, 221, 221)  # Light gray line
-            pdf.set_line_width(0.3)
-            pdf.line(25, current_y + 9, 25 + line_width, current_y + 9)
-            
-            current_y = pdf.get_y()
-            pdf.ln(6)  # Space after subheading
-            current_y = pdf.get_y()
-            
-        elif subheading_type == 'h3':
-            pdf.set_font("Arial", "B", 14)  # Bold, size 14 (original size)
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 8, text)
-            
-            current_y = pdf.get_y()
-            pdf.ln(4)  # Space after subheading
-            current_y = pdf.get_y()
-            
-        elif subheading_type == 'h4':
-            pdf.set_font("Arial", "B", 12)  # Bold, size 12 (original size)
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 7, text)
-            
-            current_y = pdf.get_y()
-            pdf.ln(3)  # Space after subheading
-            current_y = pdf.get_y()
-            
-        elif subheading_type == 'bold':
-            line_height_heading = 9 # For size 18 heading
-            line_height_text = 8 # For size 12 text
-            
-            if not re.match(r'^\d+\.', text) and len(text) < 80:
-                # Main heading style
-                pdf.set_font("Arial", "B", 12) # Bold, size 12
-                pdf.set_text_color(*primary_color) # Black
-                pdf.set_xy(25, current_y)
-                pdf.multi_cell(160, 8, text) # Multi-cell for text
-                current_y = pdf.get_y() # Get updated Y position
-                pdf.ln(6)
-                current_y = pdf.get_y()
-            else:
-                # Regular bold text
-                pdf.set_font("Arial", "B", 12) # Bold, size 12
-                pdf.set_text_color(*text_color) # Dark gray
-                pdf.set_xy(25, current_y)
-                pdf.multi_cell(160, 8, text) # Multi-cell for text
-                current_y = pdf.get_y() # Get updated Y position
-            
-        elif subheading_type == 'numbered':
-            pdf.set_font("Arial", "B", 18)  # Bold, size 18 (original size)
-            pdf.set_text_color(*primary_color)  # Black
-            pdf.set_xy(25, current_y)
-            pdf.multi_cell(160, 9, text)
-            
-            # Add underline (original styling)
-            text_width = pdf.get_string_width(text)
-            line_width = min(text_width + 12, 160)
-            pdf.set_draw_color(221, 221, 221)  # Light gray line
-            pdf.set_line_width(0.3)
-            pdf.line(25, current_y + 9, 25 + line_width, current_y + 9)
-            
-            current_y = pdf.get_y()
-            pdf.ln(6)  # Space after subheading
-            current_y = pdf.get_y()
-        
-        # Render grouped content with simple styling
-        if group_content:
-            content_lines = group_content.split('\n')
-            for line in content_lines:
-                if line.strip():
-                    # Check if line contains text ending with ":" that should be bold
-                    if ':' in line:
-                        # Split the line by ":" to separate the label from the content
-                        parts = line.split(':', 1)  # Split only on first ":"
-                        if len(parts) == 2:
-                            label = parts[0].strip()
-                            content = parts[1].strip()
-                            
-                            # Render label in bold
-                            pdf.set_font("Arial", "B", 12)  # Bold
-                            pdf.set_text_color(*text_color)
-                            pdf.set_xy(25, current_y)
-                            pdf.multi_cell(160, 8, label + ":")
-                            current_y = pdf.get_y()
-                            
-                            # Render content in regular font
-                            if content:
-                                pdf.set_font("Arial", "", 12)  # Regular
-                                pdf.set_text_color(*text_color)
-                                pdf.set_xy(25, current_y)
-                                pdf.multi_cell(160, 8, content, align='L')  # Left align to prevent text justification
-                                current_y = pdf.get_y()
-                        else:
-                            # No content after ":", just render the whole line
-                            pdf.set_font("Arial", "B", 12)  # Bold for labels ending with ":"
-                            pdf.set_text_color(*text_color)
-                            pdf.set_xy(25, current_y)
-                            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
-                            current_y = pdf.get_y()
-                    elif ' - ' in line:
-                        # Split the line by " - " to separate the label from the content
-                        parts = line.split(' - ', 1)  # Split only on first " - "
-                        if len(parts) == 2:
-                            label = parts[0].strip()
-                            content = parts[1].strip()
-                            
-                            # Render label in bold
-                            pdf.set_font("Arial", "B", 12)  # Bold
-                            pdf.set_text_color(*text_color)
-                            pdf.set_xy(25, current_y)
-                            pdf.multi_cell(160, 8, label + " -")
-                            current_y = pdf.get_y()
-                            
-                            # Render content in regular font
-                            if content:
-                                pdf.set_font("Arial", "", 12)  # Regular
-                                pdf.set_text_color(*text_color)
-                                pdf.set_xy(25, current_y)
-                                pdf.multi_cell(160, 8, content, align='L')  # Left align to prevent text justification
-                                current_y = pdf.get_y()
-                        else:
-                            # No content after " - ", just render the whole line
-                            pdf.set_font("Arial", "B", 12)  # Bold for labels ending with " -"
-                            pdf.set_text_color(*text_color)
-                            pdf.set_xy(25, current_y)
-                            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
-                            current_y = pdf.get_y()
-                    else:
-                        # Regular paragraph rendering without mixed text processing
-                        pdf.set_font("Arial", "", 12)
-                        pdf.set_text_color(*text_color)
-                        pdf.set_xy(25, current_y)
-                        pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
-                        current_y = pdf.get_y()  # Update current_y after each line
-                else:
-                    # Empty line spacing
-                    pdf.ln(3)
-                    current_y = pdf.get_y()  # Update current_y after spacing
-
-
-def render_markdown_to_docx(doc, content: str):
-    """Render markdown content to Word document with proper heading styling"""
-    if not content:
-        return
-    
-    lines = content.split('\n')
-    
-    for line in lines:
-        line = line.strip()
-        if not line:
-            doc.add_paragraph()  # Empty paragraph for spacing
-            continue
-        
-        # Handle different heading levels
-        if line.startswith("# "):    # H1 - Main heading (like "Company Profile")
-            text = line[2:].strip()
-            doc.add_heading(text, level=1)
-        elif line.startswith("## ") or re.match(r'^\d+\.\d+\s+', line):   # H2 - Subheading or numbered subheading
-            text = line[3:].strip() if line.startswith("## ") else line.strip()
-            doc.add_heading(text, level=2)
-        elif re.match(r'^\d+\.\d+\s+[A-Z]', line):  # Numbered subheadings like "3.6 SWOT Analysis"
-            text = line.strip()
-            doc.add_heading(text, level=2)
-        elif line.startswith("### ") or line.startswith("#### "):  # H3/H4 - Smaller subheadings
-            text = line[4:].strip() if line.startswith("### ") else line[5:].strip()
-            doc.add_heading(text, level=3)
-        elif line.startswith("**") and line.endswith("**"):  # Bold text that might be a heading
-            text = line.strip()  # Keep ** markers
-            # Check if this looks like a main heading (no numbers, not too long)
-            if not re.match(r'^\d+\.', text) and len(text) < 50:
-                doc.add_heading(text, level=1)  # Treat as main heading
-            else:
-                # Regular bold text
-                doc.add_paragraph(text)
-        else:  # Normal paragraph text
-            # Check if line contains text ending with ":" that should be bold
-            if ':' in line:
-                # Split the line by ":" to separate the label from the content
-                parts = line.split(':', 1)  # Split only on first ":"
-                if len(parts) == 2:
-                    label = parts[0].strip()
-                    content = parts[1].strip()
-                    
-                    # Create paragraph with mixed formatting
-                    paragraph = doc.add_paragraph()
-                    # Add label in bold
-                    run = paragraph.add_run(label + ":")
-                    run.bold = True
-                    # Add content in regular font
-                    if content:
-                        run = paragraph.add_run(" " + content)
-                        run.bold = False
-                else:
-                    # No content after ":", just render the whole line in bold
-                    paragraph = doc.add_paragraph(line)
-                    paragraph.runs[0].bold = True
-            elif ' - ' in line:
-                # Split the line by " - " to separate the label from the content
-                parts = line.split(' - ', 1)  # Split only on first " - "
-                if len(parts) == 2:
-                    label = parts[0].strip()
-                    content = parts[1].strip()
-                    
-                    # Create paragraph with mixed formatting
-                    paragraph = doc.add_paragraph()
-                    # Add label in bold
-                    run = paragraph.add_run(label + " -")
-                    run.bold = True
-                    # Add content in regular font
-                    if content:
-                        run = paragraph.add_run(" " + content)
-                        run.bold = False
-                else:
-                    # No content after " - ", just render the whole line in bold
-                    paragraph = doc.add_paragraph(line)
-                    paragraph.runs[0].bold = True
-            else:
-                doc.add_paragraph(line)
-
-
-def render_markdown_to_docx_grouped(doc, content: str):
-    """Render markdown content to Word document with subheading-content grouping and smart page breaks"""
-    if not content:
-        return
-    
-    # Parse content into groups
-    groups = parse_content_into_groups(content)
-    
-    for i, group in enumerate(groups):
-        subheading = group['subheading']
-        group_content = group['content']
-        subheading_type = group['subheading_type']
-        
-        # Add page break before group if it's not the first group and the previous group was large
-        if i > 0:
-            # Check if we should add a page break to keep groups together
-            # This is a simple heuristic - in Word, we rely more on the natural flow
-            # but we can add manual page breaks for very large groups
-            if group['content_length'] > 1000:  # Large group threshold
-                doc.add_page_break()
-        
-        # Render subheading based on type - using original styling
-        # Use the pre-cleaned text from the group
-        text = group['subheading_clean']
-        
-        if subheading_type == 'h1':
-            doc.add_heading(text, level=1)
-        elif subheading_type == 'h2':
-            doc.add_heading(text, level=2)
-        elif subheading_type == 'h3':
-            doc.add_heading(text, level=3)
-        elif subheading_type == 'h4':
-            doc.add_heading(text, level=4)
-        elif subheading_type == 'bold':
-            if not re.match(r'^\d+\.', text) and len(text) < 80:
-                # Simple paragraph with bold text
-                paragraph = doc.add_paragraph(text)
-                paragraph.style = doc.styles['Heading 1'] # Apply heading style
-            else:
-                # Regular paragraph
-                doc.add_paragraph(text)
-        elif subheading_type == 'numbered':
-            doc.add_heading(text, level=2)
-        
-        # Render grouped content with simple styling
-        if group_content:
-            content_lines = group_content.split('\n')
-            for line in content_lines:
-                if line.strip():
-                    # Check if line contains text ending with ":" that should be bold
-                    if ':' in line:
-                        # Split the line by ":" to separate the label from the content
-                        parts = line.split(':', 1)  # Split only on first ":"
-                        if len(parts) == 2:
-                            label = parts[0].strip()
-                            content = parts[1].strip()
-                            
-                            # Create paragraph with mixed formatting
-                            paragraph = doc.add_paragraph()
-                            # Add label in bold
-                            run = paragraph.add_run(label + ":")
-                            run.bold = True
-                            # Add content in regular font
-                            if content:
-                                run = paragraph.add_run(" " + content)
-                                run.bold = False
-                        else:
-                            # No content after ":", just render the whole line in bold
-                            paragraph = doc.add_paragraph(line)
-                            paragraph.runs[0].bold = True
-                    elif ' - ' in line:
-                        # Split the line by " - " to separate the label from the content
-                        parts = line.split(' - ', 1)  # Split only on first " - "
-                        if len(parts) == 2:
-                            label = parts[0].strip()
-                            content = parts[1].strip()
-                            
-                            # Create paragraph with mixed formatting
-                            paragraph = doc.add_paragraph()
-                            # Add label in bold
-                            run = paragraph.add_run(label + " -")
-                            run.bold = True
-                            # Add content in regular font
-                            if content:
-                                run = paragraph.add_run(" " + content)
-                                run.bold = False
-                        else:
-                            # No content after " - ", just render the whole line in bold
-                            paragraph = doc.add_paragraph(line)
-                            paragraph.runs[0].bold = True
-                    else:
-                        # Simple paragraph addition without mixed text processing
-                        doc.add_paragraph(line)
-                else:
-                    doc.add_paragraph()  # Empty paragraph for spacing
-
-
-
-def clean_text_for_docx(text: str) -> str:
-    # Replace problematic Unicode characters with ASCII equivalents
-    unicode_replacements = {
-        '\u2019': "'",  # Right single quotation mark
-        '\u2018': "'",  # Left single quotation mark
-        '\u201C': '"',  # Left double quotation mark
-        '\u201D': '"',  # Right double quotation mark
-        '\u2013': '-',  # En dash
-        '\u2014': '--', # Em dash
-        '\u2022': '•',  # Bullet
-        '\u2026': '...', # Horizontal ellipsis
-        '\u00A0': ' ',  # Non-breaking space
-        '\u00B0': '°',  # Degree sign
-        '\u00AE': '(R)', # Registered trademark
-        '\u2122': '(TM)', # Trademark
-        '\u00A9': '(C)', # Copyright
-    }
-    
-    for unicode_char, replacement in unicode_replacements.items():
-        text = text.replace(unicode_char, replacement)
-    
-    # Simple text cleaning - keep basic punctuation and common symbols
-    text = ''.join(char for char in text if ord(char) < 128 or char in '•°$€£¥₹₩₽₪₺₴₼₸₾֏₲₡₣₦₵₨₱₫₭៛৳؋﷼%')
-    
-    return text
-
-
-
-
-
-
-
-
-
-def clean_unicode_for_pdf(text: str) -> str:
-    # Replace problematic Unicode characters with ASCII equivalents
-    unicode_replacements = {
-        '\u2019': "'",  # Right single quotation mark
-        '\u2018': "'",  # Left single quotation mark
-        '\u201C': '"',  # Left double quotation mark
-        '\u201D': '"',  # Right double quotation mark
-        '\u2013': '-',  # En dash
-        '\u2014': '--', # Em dash
-        '\u2022': '•',  # Bullet
-        '\u2026': '...', # Horizontal ellipsis
-        '\u00A0': ' ',  # Non-breaking space
-        '\u00B0': '°',  # Degree sign
-        '\u00AE': '(R)', # Registered trademark
-        '\u2122': '(TM)', # Trademark
-        '\u00A9': '(C)', # Copyright
-    }
-    
-    for unicode_char, replacement in unicode_replacements.items():
-        text = text.replace(unicode_char, replacement)
-    
-    # Simple text cleaning - keep basic punctuation and common symbols
-    text = ''.join(char for char in text if ord(char) < 128 or char in '•°$€£¥₹₩₽₪₺₴₼₸₾֏₲₡₣₦₵₨₱₫₭៛৳؋﷼%')
-    
-    return text
-

app/DocumentGeneration/mixed.py

@@ -1,6 +0,0 @@
-# This file has been removed as all its functions are not present in maintest.txt
-# Functions removed:
-# - make_sentences_ending_with_colon_bold()
-# - _render_mixed_text_to_pdf()
-# - clean_bold_text_for_pdf()
-# - process_bold_text_for_docx()

app/DocumentGeneration/pdf_generator.py

@@ -1,682 +0,0 @@
-# PDF Generator Module
-# Contains create_pdf_document() and all PDF-related functions
-
-import re
-import os
-import tempfile
-import time
-import sys
-from typing import List, Dict, Any
-
-# Add the parent directory to sys.path to import from models.py
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
-from models import ExportRequest
-
-# Import from the same directory (Document Generation)
-from document_helpers import (
-    filter_empty_sections,
-    extract_business_name_from_content,
-    remove_duplicate_headings
-)
-from table_of_content import generate_table_of_contents_after_content, add_table_of_contents_page
-from chart_generator import parse_embedded_chart_data, create_chart_from_data
-from markdown_renderer import (
-    clean_text_for_pdf,
-    render_markdown_to_pdf_grouped
-)
-
-# Add Currency Mapping path
-currency_mapping_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'Currency Mapping')
-if currency_mapping_path not in sys.path:
-    sys.path.append(currency_mapping_path)
-from CurrencyMapping.currency_mapping import convert_currency_symbols_to_iso
-
-# Import sort_sections_by_order from utils module
-from utils import sort_sections_by_order
-
-def calculate_real_page_numbers(request: ExportRequest, filtered_sections):
-    """Calculate real page numbers by creating a temporary PDF with all content INCLUDING charts"""
-    try:
-        from fpdf import FPDF
-    except ImportError:
-        raise Exception("fpdf2 is not installed. Please install it with: pip install fpdf2")
-    
-    # Create temporary PDF to calculate page numbers
-    temp_pdf = FPDF()
-    temp_pdf.set_auto_page_break(auto=True, margin=15)
-    
-    # Add cover page
-    temp_pdf.add_page()
-    
-    # Add TOC page (placeholder)
-    temp_pdf.add_page()
-    
-    # Parse charts from embedded chart data in section content
-    embedded_charts = parse_embedded_chart_data(filtered_sections)
-    
-    # Create charts and map them to sections
-    chart_info_map = {}
-    if embedded_charts:
-        for chart_info in embedded_charts:
-            chart_bytes = create_chart_from_data(chart_info, request.businessIdea or "Business")
-            if chart_bytes:
-                source_section = chart_info["source_section"]
-                if source_section not in chart_info_map:
-                    chart_info_map[source_section] = []
-                chart_info_map[source_section].append({
-                    "chart_bytes": chart_bytes,
-                    "title": chart_info["title"],
-                    "type": chart_info["type"]
-                })
-    
-    # Add all sections to calculate real page numbers INCLUDING charts
-    section_page_map = {}
-    sorted_sections = sort_sections_by_order(filtered_sections)
-    
-    for section in sorted_sections:
-        temp_pdf.add_page()
-        current_page = temp_pdf.page_no()
-        section_page_map[section.title] = current_page
-        
-        # Don't add section title manually - let the markdown content handle headings
-        
-        # Add section content
-        temp_pdf.set_font("Arial", "", 12)
-        temp_pdf.set_text_color(51, 51, 51)
-        temp_pdf.set_xy(25, temp_pdf.get_y())
-        
-        # Process content
-        try:
-            content_text = clean_text_for_pdf(section.content)
-        except Exception as e:
-            content_text = section.content or ""
-        
-        # Remove chart data markers
-        content_text = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', content_text, flags=re.DOTALL)
-        content_text = re.sub(r'<!--CHARTDATASTART-->.*$', '', content_text, flags=re.DOTALL)
-        
-        # No need to filter section titles since we're not adding them manually
-        
-        # Add content with proper markdown rendering
-        if content_text and content_text.strip():
-            render_markdown_to_pdf_grouped(temp_pdf, content_text, (0,0,0), (75,0,130), (51,51,51))
-        
-        # Add charts for this section (same logic as in actual PDF generation)
-        section_charts = chart_info_map.get(section.title, [])
-        
-        # Try different matching strategies for charts
-        if not section_charts:
-            # Case-insensitive match
-            for chart_source, charts in chart_info_map.items():
-                if chart_source.lower() == section.title.lower():
-                    section_charts = charts
-                    break
-            
-            # Partial match
-            if not section_charts:
-                for chart_source, charts in chart_info_map.items():
-                    if (section.title.lower() in chart_source.lower() or 
-                        chart_source.lower() in section.title.lower()):
-                        section_charts = charts
-                        break
-            
-            # Key-based match
-            if not section_charts and hasattr(section, 'key'):
-                for chart_source, charts in chart_info_map.items():
-                    if section.key and section.key.replace('prompt_', '') in chart_source.lower():
-                        section_charts = charts
-                        break
-        
-        # Add charts with same page break logic as actual PDF
-        if section_charts:
-            charts_per_page = 0
-            max_charts_per_page = 5
-            
-            for chart_info in section_charts:
-                try:
-                    chart_height_needed = 140  # Chart height (120) + title (20) + minimal spacing
-                    current_y = temp_pdf.get_y()
-                    charts_per_page += 1
-                    
-                    # Only force page break if absolutely necessary
-                    if (current_y + chart_height_needed > 290) or (charts_per_page > 5):
-                        temp_pdf.add_page()
-                        y_title = 25
-                        charts_per_page = 1
-                    else:
-                        y_title = current_y
-                    
-                    # Add minimal spacing before chart if not at top of page
-                    if y_title > 25:
-                        temp_pdf.ln(3)
-                    
-                    # Chart title is already included in the chart itself, no need for separate title
-                    
-                    # Add chart image
-                    img_width = 160  # Much larger chart width
-                    x = (210 - img_width) / 2
-                    y_img = y_title
-                    
-                    # Save image to temp file
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
-                        tmp_img.write(chart_info["chart_bytes"])
-                        temp_img_path = tmp_img.name
-                    
-                    # Add chart
-                    chart_height = 120  # Much larger chart height
-                    temp_pdf.image(temp_img_path, x=x, y=y_img, w=img_width)
-                    temp_pdf.ln(chart_height + 5)
-                    
-                    # Clean up temp file
-                    try:
-                        os.remove(temp_img_path)
-                    except Exception:
-                        pass
-                        
-                except Exception:
-                    # Skip faulty chart and continue
-                    continue
-    
-    return section_page_map
-
-def create_pdf_document(request: ExportRequest):
-    """Create a PROFESSIONAL PDF document from the business plan data using FPDF2
-    NOTE: Now uses matplotlib charts exclusively - old base64 chart logic commented out"""
-    try:
-        from fpdf import FPDF
-    except ImportError:
-        raise Exception("fpdf2 is not installed. Please install it with: pip install fpdf2")
-    
-    # Filter out empty sections to prevent blank pages
-    try:
-        filtered_sections = filter_empty_sections(request.sections)
-    except Exception as e:
-        raise Exception(f"Failed to filter sections: {str(e)}")
-    if not filtered_sections:
-        raise Exception("No valid sections found after filtering. All sections appear to be empty.")
-    
-    # First pass: Calculate real page numbers by creating a temporary PDF
-    section_page_map = calculate_real_page_numbers(request, filtered_sections)
-    
-    # Generate TOC with real page numbers
-    toc_items = generate_table_of_contents_after_content(filtered_sections, section_page_map, request.businessIdea)
-    
-    # Second pass: Create final PDF with TOC on page 2
-    pdf = FPDF()
-    pdf.set_auto_page_break(auto=True, margin=15)  # Reduced margin to allow more charts per page
-    
-    # Add confidentiality footer to every page
-    def add_confidentiality_footer(pdf):
-        pdf.set_font("Arial", "", 8)
-        pdf.set_text_color(100, 100, 100)  # Gray text
-        pdf.set_y(-15)  # 15mm from bottom
-        pdf.cell(0, 5, "CONFIDENTIAL - This document contains proprietary information and may not be shared without consent", 0, 0, 'C')
-    
-    # Override the footer method
-    pdf.footer = lambda: add_confidentiality_footer(pdf)
-    pdf.add_page()
-    
-    # Professional color scheme - Refined for bank/investor presentation
-    primary_color = (0, 0, 0)        # Black - for headings
-    accent_color = (75, 0, 130)      # Navy purple - for accent lines and highlights
-    text_color = (51, 51, 51)        # Dark gray - for body text
-    light_gray = (221, 221, 221)     # Lighter gray - for subtle lines (#DDDDDD)
-    navy_color = (25, 25, 112)       # Navy blue - for TOC and emphasis
-    
-    # Professional fonts - Arial for body, optional serif for main titles
-    title_font = 'Arial'  # Keep Arial for consistency
-    body_font = 'Arial'   # Modern business feel
-    
-    # Helper functions for consistent styling
-    def add_header(pdf, text, size=24, y_offset=25, primary_color=(0,0,0), accent_color=(75,0,130)):
-        pdf.set_font("Arial", "B", size)
-        pdf.set_text_color(*primary_color)
-        pdf.set_xy(25, y_offset)
-        pdf.cell(0, 18, text, ln=True)
-        
-        # Calculate text width and make line autofit
-        text_width = pdf.get_string_width(text)
-        line_width = min(text_width + 10, 160)  # Add 10mm padding, max 160mm (page width - margins)
-        
-        # Removed purple accent line
-        return y_offset + 25
-
-    def add_subheader(pdf, text, size=16, y_offset=None, primary_color=(0,0,0)):
-        if y_offset is None:
-            y_offset = pdf.get_y() + 10
-        pdf.set_font("Arial", "B", size)
-        pdf.set_text_color(*primary_color)
-        pdf.set_xy(25, y_offset)
-        pdf.cell(0, 14, text, ln=True)
-        
-        # Calculate text width and make line autofit
-        text_width = pdf.get_string_width(text)
-        line_width = min(text_width + 8, 160)  # Add 8mm padding, max 160mm (page width - margins)
-        
-        pdf.set_draw_color(221, 221, 221)  # Lighter gray (#DDDDDD) for subtle lines
-        pdf.set_line_width(0.3)  # Thinner line
-        pdf.line(25, y_offset + 14, 25 + line_width, y_offset + 14)
-        return y_offset + 20
-
-    def add_body_text(pdf, text, y_offset=None, text_color=(51,51,51)):
-        if y_offset is None:
-            y_offset = pdf.get_y() + 5
-        pdf.set_font("Arial", "", 12)
-        pdf.set_text_color(*text_color)
-        pdf.set_xy(25, y_offset)
-        pdf.multi_cell(160, 8, text, align='L')  # Left align to prevent text justification
-        return pdf.get_y()
-
-    def check_page_break(pdf, required_height=120, bottom_margin=300):
-        """Check if we need a page break and return the Y position to use"""
-        y = pdf.get_y()
-        if y + required_height > bottom_margin:
-            pdf.add_page()
-            return 25
-        return y
-
-    # ===== COVER PAGE =====
-    def add_cover_page():
-        # Clean white background - no purple background
-        
-        # Add company logo at the top
-        try:
-            # Use the MBD logo PNG file
-            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-            logo_path = os.path.join(project_root, 'assets', 'logos', 'MBD logo.png')
-            
-            if os.path.exists(logo_path):
-                # Add logo to PDF (centered, top of page) - LOGO FIRST, THEN TITLE BELOW
-                # Center the logo: (210 - 70) / 2 = 70, so logo starts at x=70
-                pdf.image(logo_path, x=70, y=20, w=70)  # Even larger size to show full logo
-                print(f"Logo added successfully from: {logo_path}")
-            else:
-                print(f"Logo file not found at: {logo_path}")
-        except Exception as e:
-            # Log any errors with logo
-            print(f"Logo error: {e}")
-            pass
-        
-        # Extract business name from content, fallback to businessIdea
-        extracted_business_name = extract_business_name_from_content(filtered_sections)
-        business_name = extracted_business_name or request.businessIdea or "Business Plan"
-        
-        # Company/Project name - DARK TEXT (moved down below logo)
-        pdf.set_font(title_font, "B", 32)
-        pdf.set_text_color(0, 0, 0)  # Black text for visibility on white background
-        pdf.ln(60)  # More space to move title below logo
-        pdf.cell(0, 25, business_name, ln=True, align='C')
-        
-        # Subtitle - DARK GRAY, BOLD, NO ITALICS
-        pdf.set_font(title_font, "B", 16)  # Reduced from 18pt, removed italics
-        pdf.set_text_color(51, 51, 51)  # Dark gray for visibility on white background
-        pdf.cell(0, 12, "Business Plan", ln=True, align='C')
-        
-        # Add some space
-        pdf.ln(40)
-    
-        
-        pdf.set_font(body_font, "", 12)
-        pdf.set_text_color(51, 51, 51)  # Dark text for content
-        pdf.set_xy(35, 145)
-        pdf.cell(0, 8, f"Created: {time.strftime('%B %d, %Y')}", ln=True)
-        pdf.set_xy(35, 153)
-        pdf.cell(0, 8, f"Format: {request.format.upper()}", ln=True)
-        pdf.set_xy(35, 161)
-        pdf.cell(0, 8, f"Sections: {len(request.sections)}", ln=True)
-        
-        # Footer - simple footer since confidentiality is now in page footer
-        pdf.set_font(body_font, "", 10)
-        pdf.set_text_color(51, 51, 51)  # Dark gray text for visibility on white background
-        pdf.set_xy(0, 280)
-        pdf.cell(0, 8, "Business Plan Document", ln=True, align='C')
-    
-
-    
-    # ===== SECTION PAGES =====
-    def add_sections_with_charts():
-        # Parse charts from embedded chart data in section content
-        embedded_charts = parse_embedded_chart_data(filtered_sections)
-        
-        if embedded_charts:
-            # Create actual charts from the parsed data
-            matplotlib_charts = []
-            chart_info_map = {}  # Map section names to their charts
-            
-            # logging.info(f"Chart info map keys: {list(chart_info_map.keys())}")
-            
-            for chart_info in embedded_charts:
-                chart_bytes = create_chart_from_data(chart_info, request.businessIdea or "Business")
-                if chart_bytes:
-                    matplotlib_charts.append(chart_bytes)
-                    # Map this chart to its source section
-                    source_section = chart_info["source_section"]
-                    # logging.info(f"Chart '{chart_info['title']}' has source_section: '{source_section}'")
-                    
-                    if source_section not in chart_info_map:
-                        chart_info_map[source_section] = []
-                    chart_info_map[source_section].append({
-                        "chart_bytes": chart_bytes,
-                        "title": chart_info["title"],
-                        "type": chart_info["type"]
-                    })
-                    # logging.info(f"Mapping chart '{chart_info['title']}' to source section: '{source_section}'")
-                    
-                    # CRITICAL DEBUG: Show the exact mapping being created
-                    # logging.info(f"  -> Chart '{chart_info['title']}' mapped to key '{source_section}' in chart_info_map")
-                else:
-                    pass
-            
-            # logging.info(f"Total charts created: {len(matplotlib_charts)}")
-            # logging.info(f"Final chart_info_map: {chart_info_map}")
-            
-            # Debug: Show all chart mappings
-            for source_section, charts in chart_info_map.items():
-                # logging.info(f"Source section '{source_section}' has {len(charts)} charts:")
-                for chart in charts:
-                    # logging.info(f"  - {chart['title']} ({chart['type']})")
-                    pass
-        
-        else:
-            matplotlib_charts = []
-            chart_info_map = {}
-        
-        total_charts_placed = 0
-        
-        # Sort sections according to predefined order
-        sorted_sections = sort_sections_by_order(filtered_sections)
-        # logging.info(f"Section titles in sorted order: {[s.title for s in sorted_sections]}")
-        
-        # CRITICAL DEBUG: Show exact section titles and their keys
-        for i, section in enumerate(sorted_sections):
-            # logging.info(f"Section {i+1}: '{section.title}' (key: {getattr(section, 'key', 'NO_KEY')})")
-            pass
-        
-        for i, section in enumerate(sorted_sections):
-            
-            # Always start each section on a new page
-            pdf.add_page()
-            
-            # Don't add section title manually - let the markdown content handle headings
-            
-            # Section content (properly positioned)
-            pdf.set_font(body_font, "", 12)
-            pdf.set_text_color(*text_color)
-            pdf.set_xy(25, pdf.get_y())  # Use current Y position for consistent spacing
-            
-            # Process content
-            try:
-                content_text = clean_text_for_pdf(section.content)
-            except Exception as e:
-                content_text = section.content or ""
-            try:
-                content_text = convert_currency_symbols_to_iso(content_text)
-            except Exception:
-                # If currency conversion fails, keep original text
-                pass
-            
-            # Remove chart data markers
-            content_text = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', content_text, flags=re.DOTALL)
-            content_text = re.sub(r'<!--CHARTDATASTART-->.*$', '', content_text, flags=re.DOTALL)
-            
-            # Remove chart titles from content to prevent duplicate headings
-            # Get chart titles for this section
-            section_charts = chart_info_map.get(section.title, [])
-            if not section_charts:
-                # Try case-insensitive match
-                for chart_source, charts in chart_info_map.items():
-                    if chart_source.lower() == section.title.lower():
-                        section_charts = charts
-                        break
-            
-            # Remove chart titles from content
-            for chart_info in section_charts:
-                chart_title = chart_info["title"]
-                # Remove various markdown heading formats for the chart title
-                patterns_to_remove = [
-                    rf'^#+\s*{re.escape(chart_title)}\s*$',  # # Title, ## Title, etc.
-                    rf'^\*\*{re.escape(chart_title)}\*\*\s*$',  # **Title**
-                    rf'^{re.escape(chart_title)}\s*$',  # Just the title
-                ]
-                for pattern in patterns_to_remove:
-                    content_text = re.sub(pattern, '', content_text, flags=re.MULTILINE | re.IGNORECASE)
-            
-            # No need to filter section titles since we're not adding them manually
-            
-            # Skip enhance_subheadings_with_bold for grouped rendering to preserve ** markers
-            # content_text = enhance_subheadings_with_bold(content_text)
-            content_text = remove_duplicate_headings(content_text)
-            
-            # Add content with proper markdown rendering using grouped approach
-            if content_text and content_text.strip():
-                render_markdown_to_pdf_grouped(pdf, content_text, primary_color, accent_color, text_color)
-            else:
-                # Add placeholder text to prevent blank page
-                pdf.multi_cell(160, 8, f"Content for {section.title} section is being processed...", align='L')
-                
-            # Add visual separation between content and charts
-            if content_text and content_text.strip():
-                pdf.ln(15)  # More generous spacing for better visual separation
-            
-            # ---- Charts for this section ----
-            charts_added = 0  # IMPORTANT: initialize to avoid NameError
-
-            # CRITICAL DEBUG: Show exactly what charts exist and their source_section values
-            if section.title == "Financial Plan & Funding":
-                # logging.info(f"=== LAST SECTION DEBUG ===")
-                # logging.info(f"Section title: '{section.title}'")
-                # logging.info(f"All chart_info_map keys: {list(chart_info_map.keys())}")
-                for key, charts in chart_info_map.items():
-                    # logging.info(f"  Key '{key}' has {len(charts)} charts")
-                    for chart in charts:
-                        # logging.info(f"    Chart: {chart['title']} ({chart['type']})")
-                        pass
-                # logging.info(f"=== END LAST SECTION DEBUG ===")
-                pass
-            
-            section_charts = chart_info_map.get(section.title, [])
-            # logging.info(f"Section '{section.title}': Direct lookup found {len(section_charts)} charts")
-            
-            # Strategy 1: Exact title match
-            if not section_charts:
-                # logging.info(f"No exact match found for '{section.title}'")
-                pass
-                
-                # Strategy 2: Case-insensitive match
-                for chart_source, charts in chart_info_map.items():
-                    if chart_source.lower() == section.title.lower():
-                        section_charts = charts
-                        # logging.info(f"Found charts via case-insensitive match: '{chart_source}' -> {len(charts)} charts")
-                        break
-                
-                # Strategy 3: Partial match
-                if not section_charts:
-                    for chart_source, charts in chart_info_map.items():
-                        if (section.title.lower() in chart_source.lower() or 
-                            chart_source.lower() in section.title.lower()):
-                            section_charts = charts
-                            # logging.info(f"Found charts via partial match: '{chart_source}' -> {len(charts)} charts")
-                            break
-                
-                # Strategy 4: Key-based match (for prompt_ prefixed sections)
-                if not section_charts and hasattr(section, 'key'):
-                    for chart_source, charts in chart_info_map.items():
-                        if section.key and section.key.replace('prompt_', '') in chart_source.lower():
-                            section_charts = charts
-                            # logging.info(f"Found charts via key match: '{section.key}' -> '{chart_source}' -> {len(charts)} charts")
-                            break
-            
-            # logging.info(f"Section '{section.title}': Final chart count: {len(section_charts)}")
-
-            if section_charts:
-                
-                # Group charts that can fit on the same page
-                charts_per_page = 0
-                max_charts_per_page = 5  # Allow up to 5 charts per page
-                
-                for chart_info in section_charts:
-                    try:
-                        # Check if we need a new page for this chart
-                        chart_height_needed = 140  # Chart height (120) + title (20) + minimal spacing
-                        
-                        # Smart page break logic - allow multiple charts per page
-                        current_y = pdf.get_y()
-                        charts_per_page += 1
-                        
-                        # Only force page break if absolutely necessary - allow up to 5 charts per page
-                        if (current_y + chart_height_needed > 290) or (charts_per_page > 5):
-                            pdf.add_page()
-                            # Header/footer removed for now
-                            y_title = 25  # Start at normal position
-                            charts_per_page = 1  # Reset counter for new page
-                        else:
-                            y_title = current_y
-                        
-                        # Add minimal spacing before chart if not at top of page
-                        if y_title > 25:  # If not at top of page, add minimal space
-                            pdf.ln(3)  # Minimal spacing to fit more charts per page
-                        
-                        # Chart title is already included in the chart itself, no need for separate subheader
-
-                        # Centered image with larger dimensions for better visibility
-                        img_width = 160  # Much larger chart width for better visibility
-                        x = (210 - img_width) / 2
-                        y_img = y_title
-
-                        # Save image to temp file
-                        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
-                            tmp_img.write(chart_info["chart_bytes"])
-                            temp_img_path = tmp_img.name
-
-                        # Chart dimensions (no border needed)
-                        chart_height = 120  # Much larger height for better visibility
-                        chart_width = img_width
-
-                        # Image
-                        pdf.image(temp_img_path, x=x, y=y_img, w=chart_width)
-
-                        # Move below image and clean up (spacing based on actual chart height)
-                        pdf.ln(chart_height + 5)  # Chart height (120) + minimal spacing between charts
-                        try:
-                            os.remove(temp_img_path)
-                        except Exception:
-                            pass
-
-                        charts_added += 1
-                        total_charts_placed += 1
-                    except Exception:
-                        # Skip faulty chart and continue rendering others
-                        continue
-            else:
-                # Debug: Check if there are any charts that might match this section
-                potential_matches = []
-                for chart_source, charts in chart_info_map.items():
-                    if (section.title.lower() in chart_source.lower() or 
-                        chart_source.lower() in section.title.lower()):
-                        potential_matches.append(f"'{chart_source}' -> {len(charts)} charts")
-                
-                if potential_matches:
-                    # logging.info(f"Section '{section.title}': Potential chart matches: {potential_matches}")
-                    pass
-                else:
-                    # logging.info(f"Section '{section.title}': No charts found and no potential matches")
-                    pass
-            
-            # Each section is already on its own page, no need for complex page break logic
-        
-
-    
-    
-    # ===== BUILD THE PDF =====
-    try:
-        # Add all sections
-        try:
-            add_cover_page()
-        except Exception as e:
-            raise Exception(f"Cover page failed: {str(e)}")
-            
-        # Add TOC on page 2 with REAL page numbers (already calculated above)
-        try:
-            if toc_items:
-                add_table_of_contents_page(pdf, toc_items, request.businessIdea)
-            else:
-                # Add a basic TOC page if no items were generated
-                pdf.add_page()
-                pdf.set_font("Arial", "B", 20)
-                pdf.set_text_color(0, 0, 0)
-                pdf.set_xy(25, 25)
-                pdf.cell(0, 18, "Table of Contents", ln=True)
-                pdf.set_font("Arial", "", 12)
-                pdf.set_text_color(51, 51, 51)
-                pdf.set_xy(25, 50)
-                pdf.multi_cell(160, 8, "No sections available for table of contents.", align='L')
-        except Exception as e:
-            # logging.error(f"Table of contents failed: {str(e)}")
-            pass
-            # Add a basic TOC page as fallback
-            pdf.add_page()
-            pdf.set_font("Arial", "B", 20)
-            pdf.set_text_color(0, 0, 0)
-            pdf.set_xy(25, 25)
-            pdf.cell(0, 18, "Table of Contents", ln=True)
-            pdf.set_font("Arial", "", 12)
-            pdf.set_text_color(51, 51, 51)
-            pdf.set_xy(25, 50)
-            pdf.multi_cell(160, 8, "Table of contents could not be generated.", align='L')
-            
-        # Executive summary is now handled as part of the sections
-        # No separate page needed - the first section contains the executive summary
-            
-        try:
-            add_sections_with_charts()
-        except Exception as e:
-            raise Exception(f"Sections with charts failed: {str(e)}")
-            
-        # CRITICAL CHECK: Ensure we have content in the PDF
-        total_pages = pdf.page_no()
-        
-        if total_pages < 2:  # Should have at least cover + 1 content page
-            # Add a content page to prevent blank PDF
-            pdf.add_page()
-            pdf.set_font("Arial", "B", 16)
-            pdf.set_text_color(255, 0, 0)
-            pdf.cell(0, 20, "Content Processing Issue", ln=True, align='C')
-            pdf.set_font("Arial", "", 12)
-            pdf.set_text_color(0, 0, 0)
-            pdf.cell(0, 10, "The PDF generation encountered an issue with content processing.", ln=True, align='C')
-            pdf.cell(0, 10, "Please check the server logs for detailed information.", ln=True, align='C')
-        
-        # Get PDF output and convert to bytes
-        try:
-            pdf_output = pdf.output(dest='S')
-            if isinstance(pdf_output, bytearray):
-                pdf_bytes = bytes(pdf_output)
-            else:
-                pdf_bytes = pdf_output.encode('latin-1') if isinstance(pdf_output, str) else pdf_output
-            
-            # CRITICAL SAFETY CHECK: Ensure PDF is not empty
-            if len(pdf_bytes) < 1000:  # PDF should be at least 1KB
-                # Try to add some content to prevent blank PDF
-                pdf.add_page()
-                pdf.set_font("Arial", "B", 16)
-                pdf.set_text_color(255, 0, 0)  # Red text
-                pdf.cell(0, 20, "PDF Generation Issue Detected", ln=True, align='C')
-                pdf.set_font("Arial", "", 12)
-                pdf.set_text_color(0, 0, 0)
-                pdf.cell(0, 10, "If you see this message, there was an issue with content processing.", ln=True, align='C')
-                pdf.cell(0, 10, "Please check the server logs for details.", ln=True, align='C')
-                
-                # Regenerate PDF with error message
-                pdf_output = pdf.output(dest='S')
-                if isinstance(pdf_output, bytearray):
-                    pdf_bytes = bytes(pdf_output)
-                else:
-                    pdf_bytes = pdf_output.encode('latin-1') if isinstance(pdf_output, str) else pdf_output
-            
-            return pdf_bytes, f"business_plan_{request.businessIdea or 'export'}.pdf"
-        except Exception as e:
-            raise Exception(f"PDF conversion failed: {str(e)}")
-        
-    except Exception as e:
-        # logging.error(f"PDF generation failed: {e}")
-        raise Exception(f"Failed to generate professional PDF: {str(e)}")

app/DocumentGeneration/table_of_content.py

@@ -1,205 +0,0 @@
-# Table of Contents Module
-# Contains functions to generate TOC AFTER content is placed with real page numbers
-
-import re
-import os
-import sys
-from typing import List, Dict, Any
-
-# Add the parent directory to sys.path to import from models.py and constants.py
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
-from models import ExportSection
-from constants import SECTION_ORDER
-
-def extract_first_heading_from_content(content: str) -> str:
-    """Extract the first heading from markdown content"""
-    if not content:
-        return ""
-    
-    lines = content.split('\n')
-    for line in lines:
-        line = line.strip()
-        if not line:
-            continue
-        
-        # Check for markdown headings (# ## ### etc.)
-        if line.startswith('#'):
-            # Extract heading text without the # symbols
-            heading_text = re.sub(r'^#+\s*', '', line).strip()
-            if heading_text:
-                return heading_text
-        
-        # Check for bold headings (**text**)
-        elif line.startswith('**') and line.endswith('**') and len(line) > 4:
-            # Extract text from bold markers
-            heading_text = line[2:-2].strip()
-            if heading_text:
-                return heading_text
-    
-    return ""
-
-def generate_table_of_contents_after_content(sections: List[ExportSection], section_page_map: Dict[str, int], business_idea: str) -> List[Dict[str, Any]]:
-    """Generate TOC AFTER all content is placed, using REAL page numbers from section_page_map
-    This ensures accurate page numbers based on actual content placement"""
-    toc_items = []
-    
-    # Create a mapping from section titles to section objects for easy lookup
-    section_map = {section.title: section for section in sections}
-    
-    # Add business plan sections in the predefined SECTION_ORDER
-    for i, expected_title in enumerate(SECTION_ORDER):
-        # Find the corresponding section - try multiple matching strategies
-        section = None
-        
-        # Strategy 1: Exact title match
-        section = section_map.get(expected_title)
-        
-        # Strategy 2: Case-insensitive match
-        if not section:
-            for section_title, section_obj in section_map.items():
-                if section_title.lower() == expected_title.lower():
-                    section = section_obj
-                    break
-        
-        # Strategy 3: Partial match (e.g., "Company Profile" matches "Company Profile Section")
-        if not section:
-            for section_title, section_obj in section_map.items():
-                if (expected_title.lower() in section_title.lower() or 
-                    section_title.lower() in expected_title.lower()):
-                    section = section_obj
-                    break
-        
-        # Strategy 4: Key-based match (remove 'prompt_' prefix and match)
-        if not section:
-            for section_obj in sections:
-                if section_obj.key:
-                    key_clean = section_obj.key.replace('prompt_', '') if section_obj.key.startswith('prompt_') else section_obj.key
-                    if key_clean.lower() == expected_title.lower().replace(' ', '').replace('&', ''):
-                        section = section_obj
-                        break
-        
-        # Only add sections that have actual content AND real page numbers - NO DUMMY DATA
-        has_content = bool(section and section.content and section.content.strip())
-        if has_content:
-            # Get the REAL page number from section_page_map
-            real_page = section_page_map.get(section.title, 0)
-            if real_page > 0:  # Only add if we have a real page number
-                # Extract the actual heading from markdown content
-                actual_heading = extract_first_heading_from_content(section.content)
-                
-                # Use the actual heading from markdown content, fallback to expected title
-                toc_title = actual_heading if actual_heading else expected_title
-                
-                toc_items.append({
-                    "title": toc_title,  # Use actual heading from markdown content
-                    "level": 1,
-                    "page": real_page,  # REAL page number from actual content placement
-                    "section_type": "section",
-                    "has_content": True,
-                    "section_obj": section  # Store reference to actual section
-                })
-    
-    return toc_items
-
-def add_table_of_contents_page(pdf, toc_items: List[Dict[str, Any]], business_idea: str):
-    """Add a professional table of contents page with REAL page numbers"""
-    
-    # TOC items are already in the correct order and have real page numbers
-    sorted_toc_items = toc_items
-    
-    # Professional color scheme - Refined for bank/investor presentation
-    primary_color = (0, 0, 0)        # Black - for headings
-    accent_color = (75, 0, 130)      # Navy purple - for accent lines and highlights
-    text_color = (51, 51, 51)        # Dark gray - for body text
-    light_gray = (221, 221, 221)     # Lighter gray - for subtle lines (#DDDDDD)
-    navy_color = (25, 25, 112)       # Navy blue - for TOC and emphasis
-    
-    # Page title - more compact
-    pdf.set_font("Arial", "B", 20)  # Reduced from 24 to 20
-    pdf.set_text_color(*primary_color)
-    pdf.set_xy(25, 20)  # Reduced from 25 to 20
-    pdf.cell(0, 15, "Table of Contents", ln=True)  # Reduced from 18 to 15
-    
-    # Calculate text width and make line autofit
-    text_width = pdf.get_string_width("Table of Contents")
-    line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
-    
-    # Removed purple accent line under TOC title
-    
-    # TOC content - optimized for single page layout
-    y_position = 50  # Reduced from 60 to 50
-    pages_used = 1
-    
-    for item in sorted_toc_items:
-        # Only add new page if absolutely necessary (very close to bottom)
-        if y_position > 290:  # Very close to bottom margin
-            pdf.add_page()
-            y_position = 25
-            pages_used += 1
-        
-        # Indent based on level - better indentation
-        indent = 0 if item["level"] == 1 else 20  # Increased indent for subsections
-        
-        # Font and color based on level - ALL sections same color
-        if item["level"] == 1:
-            pdf.set_font("Arial", "B", 12)
-            pdf.set_text_color(*navy_color)  # Navy blue for all main entries
-        else:
-            pdf.set_font("Arial", "", 10)
-            pdf.set_text_color(*text_color)
-        
-        # Title with hyperlink
-        title_width = pdf.get_string_width(item["title"])
-        pdf.set_xy(25 + indent, y_position)
-        try:
-            # FPDF2 hyperlinks: test both 0-based and 1-based indexing
-            # First try 1-based (no subtraction)
-            target_page = item["page"]
-            # Try different FPDF2 link methods
-            if hasattr(pdf, 'add_link'):
-                link_id = pdf.add_link()
-                pdf.set_link(link_id, page=target_page)
-                pdf.link(25 + indent, y_position, title_width, 8, link_id)
-            else:
-                pdf.link(25 + indent, y_position, title_width, 8, dest=target_page)
-        except:
-            pass  # If hyperlink fails, continue without it
-        pdf.cell(title_width, 8, item["title"], ln=False)
-        
-        # Dots leading to page number
-        pdf.set_font("Arial", "", 8)
-        pdf.set_text_color(128, 128, 128)  # Medium gray for dots
-        
-        # Calculate dots position
-        title_width = pdf.get_string_width(item["title"])
-        dots_start = 25 + indent + title_width + 5
-        dots_end = 160
-        
-        # Draw dots
-        for x in range(int(dots_start), int(dots_end), 3):
-            pdf.set_xy(x, y_position + 3)
-            pdf.cell(1, 1, ".", ln=False)
-        
-        # Page number with hyperlink - NOW USING REAL PAGE NUMBERS
-        page_number_width = pdf.get_string_width(str(item["page"]))
-        pdf.set_xy(160, y_position)
-        try:
-            # FPDF2 hyperlinks: test both 0-based and 1-based indexing
-            # First try 1-based (no subtraction)
-            target_page = item["page"]
-            # Try different FPDF2 link methods
-            if hasattr(pdf, 'add_link'):
-                link_id = pdf.add_link()
-                pdf.set_link(link_id, page=target_page)
-                pdf.link(160, y_position, page_number_width, 8, link_id)
-            else:
-                pdf.link(160, y_position, page_number_width, 8, dest=target_page)
-        except:
-            pass  # If hyperlink fails, continue without it
-        pdf.cell(0, 8, str(item["page"]), ln=False)
-        
-        # Reduced spacing between items for better page utilization
-        y_position += 8  # Reduced from 10 to 8 for even tighter spacing
-    
-    # Add some spacing at the end
-    pdf.ln(20)

app/DocumentGeneration/word_generator.py

@@ -1,279 +0,0 @@
-# Word Generator Module
-# Contains create_word_document() and all Word-related functions
-
-import re
-import os
-import tempfile
-import time
-import io
-import sys
-from typing import List, Dict, Any
-
-# Add the parent directory to sys.path to import from models.py
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
-from models import ExportRequest
-
-# Import from the same directory (Document Generation)
-from document_helpers import (
-    filter_empty_sections,
-    extract_business_name_from_content
-)
-# from table_of_content import generate_table_of_contents  # Not used in word generator
-from chart_generator import parse_embedded_chart_data, create_chart_from_data
-from markdown_renderer import (
-    render_markdown_to_docx_grouped,
-    process_content_with_inline_charts
-)
-
-# Add Currency Mapping path
-sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'Currency Mapping'))
-from CurrencyMapping.currency_mapping import convert_currency_symbols_to_iso
-
-def create_word_document(request: ExportRequest):
-    """Create a Word document from the business plan data with front page, TOC, and proper page breaks"""
-    try:
-        from docx import Document
-        from docx.shared import Inches, Pt, RGBColor
-        from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_TAB_ALIGNMENT
-        from docx.oxml import OxmlElement
-        from docx.oxml.ns import qn
-    except ImportError:
-        raise Exception("python-docx is not installed. Please install it with: pip install python-docx")
-    
-    # Filter out empty sections to prevent blank pages
-    try:
-        filtered_sections = filter_empty_sections(request.sections)
-    except Exception as e:
-        raise Exception(f"Failed to filter sections: {str(e)}")
-    if not filtered_sections:
-        raise Exception("No valid sections found after filtering. All sections appear to be empty.")
-    
-    doc = Document()
-    
-    # Add confidentiality footer to every page
-    section = doc.sections[0]
-    footer = section.footer
-    footer_para = footer.paragraphs[0]
-    footer_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    footer_run = footer_para.add_run("CONFIDENTIAL - This document contains proprietary information and may not be shared without consent")
-    footer_run.font.size = Pt(8)
-    footer_run.font.color.rgb = RGBColor(100, 100, 100)  # Gray text
-    
-    # ===== FRONT PAGE =====
-    # Add company logo at the top
-    try:
-        # Use the MBD logo PNG file
-        project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-        logo_path = os.path.join(project_root, 'assets', 'logos', 'MBD logo.png')
-        
-        if os.path.exists(logo_path):
-            # Add logo to Word document (centered, top of page)
-            logo_para = doc.add_paragraph()
-            logo_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-            logo_run = logo_para.add_run()
-            logo_run.add_picture(logo_path, width=Inches(3.0))  # Even larger size to show full logo
-            print(f"Logo added successfully from: {logo_path}")
-        else:
-            print(f"Logo file not found at: {logo_path}")
-    except Exception as e:
-        # Log any errors with logo
-        print(f"Logo error: {e}")
-        pass
-    
-    # Add top spacing
-    doc.add_paragraph()
-    doc.add_paragraph()
-    
-    # Extract business name from content, fallback to businessIdea
-    extracted_business_name = extract_business_name_from_content(filtered_sections)
-    business_name = extracted_business_name or request.businessIdea or "Business Plan"
-    
-    # Business name as main title with enhanced styling - PURPLE THEME
-    title = doc.add_heading(business_name, 0)
-    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    
-    # Style the title with larger font and PURPLE color
-    for run in title.runs:
-        run.font.size = Pt(36)
-        run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
-    
-    # Removed decorative line under title
-    
-    # Add subtitle with enhanced styling - PURPLE
-    doc.add_paragraph()
-    subtitle = doc.add_paragraph("Professional Business Plan Document")
-    subtitle.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    subtitle_run = subtitle.runs[0]
-    subtitle_run.font.size = Pt(18)
-    subtitle_run.font.color.rgb = RGBColor(124, 58, 237)  # DARKER PURPLE
-    subtitle_run.italic = True
-    
-    # Add more spacing
-    doc.add_paragraph()
-    doc.add_paragraph()
-    doc.add_paragraph()
-    
-    # Add document info in a styled box - PURPLE BORDER
-    info_para = doc.add_paragraph()
-    info_para.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    
-    # Add background color and border styling
-    info_run = info_para.add_run("Prepared by: Business Plan Generator")
-    info_run.font.size = Pt(14)
-    info_run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
-    
-    doc.add_paragraph()
-    date_para = doc.add_paragraph()
-    date_para.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    date_run = date_para.add_run(f"Date: {time.strftime('%B %Y')}")
-    date_run.font.size = Pt(14)
-    date_run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
-    
-    # Confidentiality statement removed - now in footer of every page
-    
-    # Add more spacing before footer
-    doc.add_paragraph()
-    doc.add_paragraph()
-    doc.add_paragraph()
-    doc.add_paragraph()
-    
-    # Add footer with enhanced styling - PURPLE
-    footer = doc.add_paragraph("Confidential Business Information")
-    footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    footer_run = footer.runs[0]
-    footer_run.font.size = Pt(12)
-    footer_run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
-    footer_run.bold = True
-    
-    # Removed decorative line above footer
-    
-    # ===== TABLE OF CONTENTS =====
-    # Add page break before TOC
-    doc.add_page_break()
-    
-    # Add TOC title
-    toc_title = doc.add_heading("Table of Contents", level=1)
-    toc_title.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    
-    # Removed decorative line under TOC title
-    
-    # Add spacing before TOC entries
-    doc.add_paragraph()
-    
-    # Sort sections according to predefined order (do this before TOC generation)
-    try:
-        sorted_sections = sort_sections_by_order(filtered_sections)
-    except Exception as e:
-        # Fallback: use filtered order if sorting fails
-        sorted_sections = filtered_sections
-    
-    # Generate TOC entries with actual page numbers
-    # Since each section starts on a new page, we can calculate page numbers
-    toc_items = []
-    current_page = 3  # Start after cover (1) and TOC (2)
-    
-    for section in sorted_sections:
-        if section.content and section.content.strip():
-            # Add main section
-            toc_items.append({
-                "title": section.title,
-                "level": 1,
-                "page": current_page
-            })
-            
-            # Skip subheadings and chart titles - only include main section headings
-            
-            current_page += 1  # Each section starts on a new page
-    
-    # Add the actual TOC entries
-    for item in toc_items:
-        # Create TOC entry paragraph
-        toc_para = doc.add_paragraph()
-        toc_para.paragraph_format.space_after = Pt(6)
-        
-        # Add section title
-        title_run = toc_para.add_run(item["title"])
-        title_run.font.size = Pt(11)
-        
-        # Add dots and page number
-        if item["level"] == 1:
-            # Main section - bold
-            title_run.bold = True
-            # Add dots
-            dots_run = toc_para.add_run(" " + "." * (60 - len(item["title"])) + " ")
-            dots_run.font.size = Pt(11)
-            dots_run.font.color.rgb = RGBColor(128, 128, 128)  # Gray
-            # Add page number
-            page_run = toc_para.add_run(str(item["page"]))
-            page_run.font.size = Pt(11)
-            page_run.bold = True
-        else:
-            # Subsection - indented
-            toc_para.paragraph_format.left_indent = Inches(0.3)
-            # Add dots
-            dots_run = toc_para.add_run(" " + "." * (50 - len(item["title"])) + " ")
-            dots_run.font.size = Pt(11)
-            dots_run.font.color.rgb = RGBColor(128, 128, 128)  # Gray
-            # Add page number
-            page_run = toc_para.add_run(str(item["page"]))
-            page_run.font.size = Pt(11)
-    
-    # logging.info(f"Generated {len(toc_items)} TOC items with actual page numbers")
-    
-    # Executive Summary is now handled as a regular section above
-    
-    # ===== MAIN SECTIONS =====
-    for i, section in enumerate(sorted_sections):
-        if section.content.strip():
-            # Add page break before each section (including Executive Summary)
-            doc.add_page_break()
-            
-            # Add section heading
-            doc.add_heading(section.title, level=1)
-            
-            # Clean and process content WITH inline charts
-            try:
-                clean_content = clean_text_for_pdf(section.content)
-            except Exception:
-                clean_content = section.content or ""
-            try:
-                clean_content = convert_currency_symbols_to_iso(clean_content)
-            except Exception:
-                pass
-            
-            # Remove the section title from content to prevent duplication
-            section_title_clean = section.title.strip()
-            content_lines = clean_content.split('\n')
-            filtered_lines = []
-            for line in content_lines:
-                line_clean = line.strip()
-                # Skip lines that match the section title (with or without markdown)
-                # Check for various markdown formats and variations
-                if (line_clean == section_title_clean or 
-                    line_clean == f"**{section_title_clean}**" or
-                    line_clean == f"# {section_title_clean}" or
-                    line_clean == f"## {section_title_clean}" or
-                    line_clean == f"### {section_title_clean}" or
-                    line_clean == f"#### {section_title_clean}" or
-                    # Also check if the line starts with the section title (for numbered headings)
-                    line_clean.startswith(f"{section_title_clean}") and len(line_clean) <= len(section_title_clean) + 10):
-                    continue
-                filtered_lines.append(line)
-            clean_content = '\n'.join(filtered_lines)
-            
-            # Process content with inline charts - THIS IS THE KEY CHANGE
-            process_content_with_inline_charts(doc, clean_content, request.businessIdea or "Business")
-            
-            doc.add_paragraph()
-    
-    # Charts are now handled inline with the sections above
-    
-    # Save to bytes
-    buffer = io.BytesIO()
-    doc.save(buffer)
-    buffer.seek(0)
-    doc_bytes = buffer.getvalue()
-    buffer.close()
-    
-    filename = f"business_plan_{request.businessIdea or 'export'}.docx"
-    return doc_bytes, filename

app/__init__.py

@@ -1,29 +0,0 @@
-# App Package
-# This file makes the app directory a proper Python package
-
-import os
-import sys
-
-# Add the current directory to sys.path
-current_dir = os.path.dirname(__file__)
-if current_dir not in sys.path:
-    sys.path.insert(0, current_dir)
-
-# Import main modules for easy access
-from models import ExportRequest, ExportSection, ExportResponse, SectionJob, BatchGenerateRequest, GenerateRequest, CreatePlanRequest
-from constants import SECTION_ORDER, SECTION_MAP, SECTION_COLUMNS
-from utils import sort_sections_by_order
-
-__all__ = [
-    'ExportRequest',
-    'ExportSection', 
-    'ExportResponse',
-    'SectionJob',
-    'BatchGenerateRequest',
-    'GenerateRequest',
-    'CreatePlanRequest',
-    'SECTION_ORDER',
-    'SECTION_MAP',
-    'SECTION_COLUMNS',
-    'sort_sections_by_order'
-]

app/constants.py

@@ -1,41 +0,0 @@
-# Constants and Configuration
-# Contains constants and configuration values to avoid circular imports
-
-# Human-readable section titles for TOC and display
-SECTION_ORDER = [
-    "Executive Summary",
-    "Company Profile", 
-    "Market Analysis",
-    "Product or Service",
-    "Business Model",
-    "Marketing & Growth",
-    "Operations Plan",
-    "Management Team",
-    "Financial Plan & Funding"
-]
-
-# Database helper constants
-SECTION_MAP = {
-    "prompt_ExecutiveSummary": ("executiveSummary", "executiveSummaryComplete", "executiveSummaryGenerating"),
-    "prompt_CompanyProfile": ("companyProfile", "companyProfileComplete", "companyProfileGenerating"),
-    "prompt_MarketAnalysis": ("marketAnalysis", "marketAnalysisComplete", "marketAnalysisGenerating"),
-    "prompt_ProductOrService": ("productOrService", "productOrServiceComplete", "productOrServiceGenerating"),
-    "prompt_BusinessModel": ("businessModel", "businessModelComplete", "businessModelGenerating"),
-    "prompt_MarketingGrowth": ("marketingGrowth", "marketingGrowthComplete", "marketingGrowthGenerating"),
-    "prompt_OperationsPlan": ("operationsPlan", "operationsPlanComplete", "operationsPlanGenerating"),
-    "prompt_ManagementTeam": ("managementTeam", "managementTeamComplete", "managementTeamGenerating"),
-    "prompt_FinancialPlanFunding": ("financialPlanFunding", "financialPlanFundingComplete", "financialPlanFundingGenerating"),
-}
-
-# Database column names for sections
-SECTION_COLUMNS = [
-    "executiveSummary",
-    "companyProfile",
-    "marketAnalysis",
-    "productOrService",
-    "businessModel",
-    "marketingGrowth",
-    "operationsPlan",
-    "managementTeam",
-    "financialPlanFunding",
-]

app/models.py

@@ -1,61 +0,0 @@
-# Models and Data Structures
-# Contains Pydantic models and data structures to avoid circular imports
-
-from pydantic import BaseModel
-from typing import List, Dict, Any, Optional, Literal
-
-class ExportSection(BaseModel):
-    """Represents a section of content for export"""
-    title: str
-    content: str
-    key: Optional[str] = None
-    order: Optional[int] = None
-
-class ExportRequest(BaseModel):
-    """Request model for document export"""
-    sections: List[ExportSection]
-    businessIdea: str
-    summary: str
-    format: Literal["pdf", "word"] = "pdf"
-    chartImages: Optional[List[str]] = None
-    includeCharts: bool = True
-    includeTOC: bool = True
-
-class ExportResponse(BaseModel):
-    """Response model for document export"""
-    success: bool
-    message: str
-    filename: Optional[str] = None
-    size: Optional[int] = None
-    downloadUrl: Optional[str] = None
-    documentData: Optional[str] = None
-
-class SectionJob(BaseModel):
-    """Job model for section generation"""
-    businessPlanId: str
-    sectionKey: str
-    businessIdea: str
-    countryCode: Optional[str] = None
-    defaultCountry: Optional[str] = None
-
-class BatchGenerateRequest(BaseModel):
-    """Request model for batch generation"""
-    businessPlanId: str
-    businessIdea: str
-    sections: List[str]
-    countryCode: Optional[str] = None
-    defaultCountry: Optional[str] = None
-
-class GenerateRequest(BaseModel):
-    """Request model for single section generation"""
-    businessPlanId: str
-    sectionKey: str
-    businessIdea: str
-    countryCode: Optional[str] = None
-    defaultCountry: Optional[str] = None
-
-class CreatePlanRequest(BaseModel):
-    """Request model for creating a new business plan"""
-    businessIdea: str
-    countryCode: Optional[str] = None
-    defaultCountry: Optional[str] = None

app/utils.py

@@ -1,42 +0,0 @@
-# Utility functions shared across modules
-# This file helps break circular imports between main.py and pdf_generator.py
-
-from typing import List
-from models import ExportSection
-from constants import SECTION_ORDER
-
-def sort_sections_by_order(sections: List[ExportSection]) -> List[ExportSection]:
-    """Sort sections according to the predefined SECTION_ORDER to ensure correct numerical ordering"""
-    # Create a mapping from section title to order index
-    order_map = {title: index for index, title in enumerate(SECTION_ORDER)}
-    
-    def get_section_order(section: ExportSection) -> int:
-        # Try to match by exact title first
-        if section.title in order_map:
-            order_index = order_map[section.title]
-            return order_index
-        
-        # Try case-insensitive matching
-        section_title_lower = section.title.lower()
-        for order_title, order_index in order_map.items():
-            if order_title.lower() == section_title_lower:
-                return order_index
-        
-        # Try to match by key (remove 'prompt_' prefix if present)
-        key_clean = section.key.replace('prompt_', '') if section.key.startswith('prompt_') else section.key
-        if key_clean in order_map:
-            order_index = order_map[key_clean]
-            return order_index
-        
-        # Try partial matching for keys
-        for order_title, order_index in order_map.items():
-            if key_clean.lower() in order_title.lower() or order_title.lower() in key_clean.lower():
-                return order_index
-        
-        # If no match found, put at the end
-        return len(SECTION_ORDER)
-    
-    # Sort sections by their order
-    sorted_sections = sorted(sections, key=get_section_order)
-    
-    return sorted_sections

package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "planify",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {}
-}