Upload 7 files

app.py

@@ -1,65 +1,68 @@
-#!/usr/bin/env phython3
-#-*- coding: utf-8 -*-
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 import os
 import io
 import json
 import math
 import base64
 from datetime import datetime
-from typing import List, Optional, Dict , Any
+from typing import List, Optional, Dict, Any
 
 import gradio as gr
 from openai import OpenAI
 from pydantic import BaseModel, Field, ValidationError
 import yaml
 
-from schemas import FinancialEctract, ExtraxtedPeriod, MultipleSuggestion
-from finanxe_core import(
-    copute_ratios,
+from schemas import FinancialExtract, ExtractedPeriod, MultipleSuggestion
+from finance_core import (
+    compute_ratios,
     credit_decision,
     loan_decision,
-    invesement_decision,
+    investment_decision,
     build_report_dict,
 )
-from llm_extract import(
+from llm_extract import (
     get_client,
     upload_file_to_openai,
     extract_financials_from_files,
     suggest_multiples_with_llm,
 )
 
-HF_SPACE = os.environ.get("HF_SPACE_NAME","hf-credit-loan-investment-app")
-VISION_MODEL = os.environ.get("OPENAI_VISION_MODEL", "gpt-5")
-TEXT_MODEL = os.environ.get("OPENAI_TEXT_MODEL", "gpt-5")
-BASE_RATE =float(os.environ.get("BASE_RATE", "2.0")) #% per annum, cofigurable
+
+HF_SPACE = os.environ.get("HF_SPACE_NAME", "hf-credit-loan-investment-app")
+VISION_MODEL = os.environ.get("OPENAI_VISION_MODEL", "gpt-4o-mini")
+TEXT_MODEL   = os.environ.get("OPENAI_TEXT_MODEL",   "gpt-4o-mini")
+BASE_RATE    = float(os.environ.get("BASE_RATE", "2.0"))  # % per annum, configurable
+
 
 def _load_policies() -> dict:
-    cfg_path= os.path.join(os.path.dirname(__file__),"config","risk_policies.yaml")
-    with open(cfg_path, "r",encoding="utf-8") as f:
+    cfg_path = os.path.join(os.path.dirname(__file__), "config", "risk_policies.yaml")
+    with open(cfg_path, "r", encoding="utf-8") as f:
         return yaml.safe_load(f)
-    
+
+
 POLICIES = _load_policies()
 
 
-def analyze(files: List[gr.File],company_name: str, industry_hint: str, currency: str,
-            base_rate:float, want_credit:bool, want_loan: bool,want_invest: bool, debug:bool):
-    """Main pipline used by the Gradio UI."""
+def analyze(files: List[gr.File], company_name: str, industry_hint: str, currency_hint: str,
+            base_rate: float, want_credit: bool, want_loan: bool, want_invest: bool, debug: bool):
+    """Main pipeline used by the Gradio UI."""
     try:
         client = get_client()
     except Exception as e:
         raise gr.Error(str(e))
-    
+
     if not files or len(files) == 0:
-        raise gr.Error("決算書ファイル（PDF/画像）を１つ以上アップロードしてください。")
-    
-    # 1)Upload files to OpenAI and extract stuctured financials via vision ＋Structured Outputs
-    try：
+        raise gr.Error("決算書ファイル（PDF/画像）を1つ以上アップロードしてください。")
+
+    # 1) Upload files to OpenAI and extract structured financials via vision + Structured Outputs
+    try:
         file_ids = []
-        for f in files :
+        for f in files:
             file_ids.append(upload_file_to_openai(client, f.name, f.read()))
     except Exception as e:
-        raise gr.Error(f"ファイルのアップロードに失敗しました：{e}")
-    
+        raise gr.Error(f"ファイルのアップロードに失敗しました: {e}")
+
     try:
         extract = extract_financials_from_files(
             client=client,
@@ -70,16 +73,16 @@ def analyze(files: List[gr.File],company_name: str, industry_hint: str, currency
             debug=debug,
         )
     except Exception as e:
-        raise gr.Error(f"LLM抽出に失敗しました：{e}")
-    
-    #allow override company name / indutry if provided
+        raise gr.Error(f"LLM抽出に失敗しました: {e}")
+
+    # allow override company name / industry if provided
     if company_name:
-        extract.company_name =company_name
+        extract.company_name = company_name
     if industry_hint:
         extract.industry = industry_hint
 
-    # 2) Compute derived rasios and risk score
-    ratios =copute_ratios(extract)
+    # 2) Compute derived ratios and risk score
+    ratios = compute_ratios(extract)
 
     # 3) Decisions
     decisions = {}
@@ -89,110 +92,115 @@ def analyze(files: List[gr.File],company_name: str, industry_hint: str, currency
         decisions["loan"] = loan_decision(extract, ratios, base_rate or BASE_RATE, POLICIES)
     if want_invest:
         # Ask LLM for suggested multiples if industry present
-        multiple: Optional[MultipleSuggestion] = None
+        multiples: Optional[MultipleSuggestion] = None
         try:
-            multiple = suggest_multiples_with_llm(
+            multiples = suggest_multiples_with_llm(
                 client=client,
                 text_model=TEXT_MODEL,
                 industry=extract.industry or industry_hint or "",
-                region="ja",
+                region="JP",
                 debug=debug,
             )
         except Exception:
-            multiple = None
-        decisions["investment"] = invesement_decision(extract, ratios, POLICIES, multiple)
+            multiples = None
+        decisions["investment"] = investment_decision(extract, ratios, POLICIES, multiples)
 
     # 4) Build a combined report (dict) and return displays
     report = build_report_dict(extract, ratios, decisions)
     report_json = json.dumps(report, ensure_ascii=False, indent=2)
 
-    #Save a downloadable JSON
-    ts = datetime.utcnow().strftime("%Ym%d-%H%M%S")
-    out_path =f"/mnt/data/report-{ts}.json"
-    with open(out_path,"w", encoding="utf-8") as f:
+    # Save a downloadable JSON
+    ts = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+    out_path = f"/mnt/data/report-{ts}.json"
+    with open(out_path, "w", encoding="utf-8") as f:
         f.write(report_json)
 
     # Pretty sections for Gradio
-    summary_md =[]
-    summary_md.append(f"### 企業名\n{extract.company_name or '(不明)'}")
+    summary_md = []
+    summary_md.append(f"### 企業名\n{extract.company_name or '（不明）'}")
     if extract.industry:
         summary_md.append(f"### 業種（推定/指定）\n{extract.industry}")
+    if extract.currency:
+        summary_md.append(f"### 通貨\n{extract.currency}")
     if extract.fiscal_year_end:
-        summary_md.append(f"### 決算期末\n{extract.fisxal_year_end}")
+        summary_md.append(f"### 決算期末\n{extract.fiscal_year_end}")
 
     summary_md.append("### 指標（主要）")
     summary_md.append(
-        f"- 売上高:{ratios.get('revenue')}\n"
-        f"- 営業利益(EBIT):{ratios.get('ebit')}\n"
-        f"- EBITDA:{ratios.get('ebitda')}\n"
-        f"- 当期純利益:{ratios.get('net_income')}\n"
-        f"- 流動比率:{ratios.get('current_ratio')}\n"
-        f"- 当座比率:{ratios.get('quick_ratio')}\n"
-        f"- D/Eレシオ:{ratios.get('debt_to_equity')}\n"
-        f"- インタレストカバレッジ:{ratios.get('inerest_coverage')}\n"
-        f"- 売上成長率:{ratios.get('revenue_growth_pct')}"
+        f"- 売上高: {ratios.get('revenue')}\n"
+        f"- 営業利益（EBIT）: {ratios.get('ebit')}\n"
+        f"- EBITDA: {ratios.get('ebitda')}\n"
+        f"- 当期純利益: {ratios.get('net_income')}\n"
+        f"- 流動比率: {ratios.get('current_ratio')}\n"
+        f"- 当座比率: {ratios.get('quick_ratio')}\n"
+        f"- D/Eレシオ: {ratios.get('debt_to_equity')}\n"
+        f"- インタレストカバレッジ: {ratios.get('interest_coverage')}\n"
+        f"- 売上成長率: {ratios.get('revenue_growth_pct')}"
     )
 
     if "credit" in decisions:
         c = decisions["credit"]
         summary_md.append("### 与信判断（提案）")
         summary_md.append(
-            f"- 与信ランク:**{c['rationg']}**(スコア {c['risk_score']}/100)\n"
-            f"- 取引サイト:**{c['site_days']}日**\n"
-            f"- 取引可能上限:**{c{'tansaction_limit_display'}}**\n"
-            f"- 見直しタイミング:**{c['review_cycle']}**"
+            f"- 与信ランク: **{c['rating']}**（スコア {c['risk_score']}/100）\n"
+            f"- 取引サイト: **{c['site_days']}日**\n"
+            f"- 取引可能上限: **{c['transaction_limit_display']}**\n"
+            f"- 見直しタイミング: **{c['review_cycle']}**"
         )
-    
+
     if "loan" in decisions:
         l = decisions["loan"]
-        summary_md.append("### 融資判断（提案）" )
+        summary_md.append("### 融資判断（提案）")
         summary_md.append(
-            f"- 融資上限額（概算）:**{l['max_principal_display']}**\n"
-            f"- 期間案：**{l['term_yeras']}年**\n"
-            f"- 参考金利:**{l['interest_rate_pct']}%**\n"
-            f"- 目標DSCR:**{l['target_dscr']}**"
+            f"- 融資上限額（概算）: **{l['max_principal_display']}**\n"
+            f"- 期間案: **{l['term_years']}年**\n"
+            f"- 参考金利: **{l['interest_rate_pct']}%**\n"
+            f"- 目標DSCR: **{l['target_dscr']}**"
         )
-    
+
     if "investment" in decisions:
         inv = decisions["investment"]
         summary_md.append("### 投資判断（提案）")
         summary_md.append(
-            f"- 推定企業価値(EV):**{inv['ev_display']}**\n"
-            f"- 推定時価総額:**{inv['market_cap_display']}**\n"
-            f"- 想定投資レンジ:**{inv['recommended_check_size_display']}**\n"
-            f"- 魅力度:**{inv['attractiveness']}/5**(成長性:{inv['growth_label']})"
+            f"- 推定企業価値（EV）: **{inv['ev_display']}**\n"
+            f"- 推定時価総額: **{inv['market_cap_display']}**\n"
+            f"- 想定投資レンジ: **{inv['recommended_check_size_display']}**\n"
+            f"- 魅力度: **{inv['attractiveness']}/5**（成長性: {inv['growth_label']}）"
         )
-    
-    #Return
-    return "\n\n".join(summary_md),gr.JSON.update(value=json.loads(report_json)),out_path
+
+    # Return
+    return "\n\n".join(summary_md), gr.JSON.update(value=json.loads(report_json)), out_path
+
 
 def build_ui():
-    with gr.Blocks(theme = gr.themes.Soft(), css = "footer{visivility: hidden}") as demo:
-        gr.Markdown("# 決算書→与信・融資・投資判断（HF+OpenAI)")
+    with gr.Blocks(theme=gr.themes.Soft(), css="footer {visibility: hidden}") as demo:
+        gr.Markdown("# 決算書→与信・融資・投資判断（HF+OpenAI）")
         with gr.Row():
             with gr.Column():
-                files = gr.File(label="決算書ファイル(PDF/JPG/PNG,複数可)",file_types=[".pdf",".png",".jpg",".jpeg"],file_count="multiple")
+                files = gr.File(label="決算書ファイル（PDF/JPG/PNG, 複数可）", file_types=[".pdf", ".png", ".jpg", ".jpeg"], file_count="multiple")
                 company_name = gr.Textbox(label="会社名（任意）")
-                industry_hint = gr.Textbox(label="業種（任意)")
-                currency_hint = gr.Textbox(label="通過(任意,例： JPY, USD)")
-                base_rate = gr.Number(label="ベース金利(%/年)",value=BASE_RATE)
-                want_credit = gr.Checkbox(label="与信判断",value=True)
-                want_loan = gr.Checkbox(label="融資判断",value=True)
-                want_invest = gr.Checkbox(label="投資判断",value=True)
-                debug = gr.Checkbox(label="デバッグモード(LLM抽出JSONを厳密化)",value=False)
+                industry_hint = gr.Textbox(label="業種（任意）")
+                currency_hint = gr.Textbox(label="通貨（任意, 例: JPY, USD）")
+                base_rate = gr.Number(label="ベース金利（%/年）", value=BASE_RATE)
+                want_credit = gr.Checkbox(label="与信判断", value=True)
+                want_loan = gr.Checkbox(label="融資判断", value=True)
+                want_invest = gr.Checkbox(label="投資判断", value=True)
+                debug = gr.Checkbox(label="デバッグモード（LLM抽出JSONを厳密化）", value=False)
                 run_btn = gr.Button("分析する", variant="primary")
             with gr.Column():
                 summary = gr.Markdown()
-                report = gr.JSON(label="詳細レポート(JSON)")
-                download = gr.File(label="レポート(JSONダウンロード)")
+                report = gr.JSON(label="詳細レポート（JSON）")
+                download = gr.File(label="レポート（JSONダウンロード）")
 
-        run_btn.chek(
+        run_btn.click(
             analyze,
             inputs=[files, company_name, industry_hint, currency_hint, base_rate, want_credit, want_loan, want_invest, debug],
-            outputs=[summary, report, download]        
+            outputs=[summary, report, download]
         )
+
     return demo
 
-if __name__== "__main__":
-    demo =build_ui()
-    demo.launch()
+
+if __name__ == "__main__":
+    demo = build_ui()
+    demo.launch()

config:risk_policies.yaml

@@ -1,20 +1,20 @@
 # Basic policy knobs (extend as needed)
-liquidity :
-    current_ratio_good: 2.0
-    current_ratio_ok: 1.5
+liquidity:
+  current_ratio_good: 2.0
+  current_ratio_ok: 1.5
 
 leverage:
-    debt_to_equity_good: 0.5
-    debt_to_equity_ok: 1.0
+  debt_to_equity_good: 0.5
+  debt_to_equity_ok: 1.0
 
 coverage:
-    interest_coverage_good: 6.0
-    interest_coverage_ok: 3.0
+  interest_coverage_good: 6.0
+  interest_coverage_ok: 3.0
 
 profitability:
-    net_margin_good: 0.1
-    net_margin_ok: 0.03
+  net_margin_good: 0.1
+  net_margin_ok: 0.03
 
 growth:
-    revenue_growth_high: 0.2
-    revenue_growth_ok: 0.05
+  revenue_growth_high: 0.2
+  revenue_growth_ok: 0.05

finance_core.py

@@ -1,31 +1,33 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 import math
-from typing import Dict, Any ,Optional
+from typing import Dict, Any, Optional
 from dataclasses import dataclass
 
-from schemas import FinancalExtract, ExtractedPeriod, MultipleSuggestion
+from schemas import FinancialExtract, ExtractedPeriod, MultipleSuggestion
 
-def _fmt_currency(x: Optional[float],currency:str) -> str:
+
+def _fmt_currency(x: Optional[float], currency: str) -> str:
     if x is None:
-        return "-"
-    try :
+        return "—"
+    try:
         # compact format
-        absx=abs(x)
-        if absx >=1e12:
+        absx = abs(x)
+        if absx >= 1e12:
             return f"{x/1e12:.2f}兆{currency}"
-        if absx >=1e8:
+        if absx >= 1e8:
             return f"{x/1e8:.2f}億{currency}"
-        if absx >=1e6:
+        if absx >= 1e6:
             return f"{x/1e6:.2f}百万{currency}"
-        return f"{x:,0f}{currency}"
+        return f"{x:,.0f}{currency}"
     except Exception:
-        return f"{x}{currency}"
+        return f"{x} {currency}"
+
 
 def compute_ratios(extract: FinancialExtract) -> Dict[str, Any]:
-    """Cmpute derived metrics from the latest period(and prior if exists)."""
-    latest: Optional[ExtractedPeriod]= extract.latest()
-    prev: Optional[ExtractedPeriod]= extract.previous()
+    """Compute derived metrics from the latest period (and prior if exists)."""
+    latest: Optional[ExtractedPeriod] = extract.latest()
+    prev: Optional[ExtractedPeriod] = extract.previous()
 
     currency = extract.currency or ""
 
@@ -35,62 +37,66 @@ def compute_ratios(extract: FinancialExtract) -> Dict[str, Any]:
         revenue = latest.revenue
         cogs = latest.cogs
         ebit = latest.ebit
-        ebitda = latest.ebitda if latest.ebitda is not None else (latest.ebit + (latest.depreciation or 0.0)if latest.ebit is not None else None)
+        ebitda = latest.ebitda if latest.ebitda is not None else (latest.ebit + (latest.depreciation or 0.0) if latest.ebit is not None else None)
         net_income = latest.net_income
         cash = latest.cash_and_equivalents
         ar = latest.accounts_receivable
-        inv = latest.accounts_payable
-        ap = latest.accoutnts_payable
+        inv = latest.inventory
+        ap = latest.accounts_payable
         ca = latest.current_assets
-        cl = latest.current_laiabilities
+        cl = latest.current_liabilities
         ta = latest.total_assets
         te = latest.total_equity
+        td = latest.total_debt
         interest = latest.interest_expense
 
         gross_profit = (revenue - cogs) if revenue is not None and cogs is not None else None
-        gross_margin = (gross_profit/revenue)if revenue and gross_profit is not None else None
-        ebit_margin = (ebit/revenue)if revenue and ebit is not None else None
-        ebitda_margin = (ebitda /revenue) if revenue and ebitda is not None else None
+        gross_margin = (gross_profit / revenue) if revenue and gross_profit is not None else None
+        ebit_margin = (ebit / revenue) if revenue and ebit is not None else None
+        ebitda_margin = (ebitda / revenue) if revenue and ebitda is not None else None
 
-        current_ratio = (ca/cl) if ca and cl else None
+        current_ratio = (ca / cl) if ca and cl else None
         quick_assets = (cash or 0.0) + (ar or 0.0)
-        quick_ratio = (quick_assets/cl)if quick_assets and cl else None
+        quick_ratio = (quick_assets / cl) if quick_assets and cl else None
 
-        debt_to_equity = (td/te)if td is not None and te else None
-        interest_coverage = (ebit / interest)if ebit is not None and interest else None
+        debt_to_equity = (td / te) if td is not None and te else None
+        interest_coverage = (ebit / interest) if ebit is not None and interest else None
 
         ratios.update({
-            "revenue": _fmt_currency(revenue,currency),
-            "ebit":_fmt_currency(ebit, currency),
-            "ebitda":_fmt_currency(ebitda,currency),
-            "net_income":_fmt_currency(net_income,currency),
-            "gross_margin_pct":f"{gross_margin*100:.1f}%"if fross_margin is not None else "-",
-            "ebit_margin_pct": f"{ebit_margin*100:.1f}%"if ebitda_margin si not None else "-",
-            "quick_ratio":f"{quick_ratio:.2f}"if quick_ratio is not None else "-",
-            "debt_to_equity":f"{debt_to_equity:.2f}"if debt_to_equity is not None else "-",
-            "interest_coverage": f"{interest_coverage:.2f}" if interest_coverage is not None else "-",
+            "revenue": _fmt_currency(revenue, currency),
+            "ebit": _fmt_currency(ebit, currency),
+            "ebitda": _fmt_currency(ebitda, currency),
+            "net_income": _fmt_currency(net_income, currency),
+            "gross_margin_pct": f"{gross_margin*100:.1f}%" if gross_margin is not None else "—",
+            "ebit_margin_pct": f"{ebit_margin*100:.1f}%" if ebit_margin is not None else "—",
+            "ebitda_margin_pct": f"{ebitda_margin*100:.1f}%" if ebitda_margin is not None else "—",
+            "current_ratio": f"{current_ratio:.2f}" if current_ratio is not None else "—",
+            "quick_ratio": f"{quick_ratio:.2f}" if quick_ratio is not None else "—",
+            "debt_to_equity": f"{debt_to_equity:.2f}" if debt_to_equity is not None else "—",
+            "interest_coverage": f"{interest_coverage:.2f}" if interest_coverage is not None else "—",
         })
 
-    if latest and prev and latest.revenue and prev.revenueand and prev.revenue != 0:
-        growth =(latest.revenue - prev.revenue)/ abs(prev.revenue)
+    if latest and prev and latest.revenue and prev.revenue and prev.revenue != 0:
+        growth = (latest.revenue - prev.revenue) / abs(prev.revenue)
         ratios["revenue_growth_pct"] = f"{growth*100:.1f}%"
         ratios["_revenue_growth_float"] = growth
     else:
-        ratios["revenue_growth_pct"] = "-"
+        ratios["revenue_growth_pct"] = "—"
         ratios["_revenue_growth_float"] = None
 
     ratios["_latest_currency"] = extract.currency or "JPY"
     ratios["_latest_revenue"] = latest.revenue if latest else None
-    ratios["_latest_cebitda"] = (latest.ebitda if latest and latest.ebitda is not None else
-                                 (latest.ebit + (latest.depreciation or 0.0)if latest and latest.ebit is not None else None))
-    ratios["_latest_current_ratio"] = float(ratios["current_ratio"])if isinstance(ratios.get("current_ratio"), str) and ratios["current_ratio"]not in ("-",)else None
-    ratios["latest_quick_ratio"] = float(ratios["quick_ratio"])if isinstance(ratios.get("quick_ratio"),str) and ratios["quick_ratio"]not in ("-",)else None
+    ratios["_latest_ebitda"] = (latest.ebitda if latest and latest.ebitda is not None else
+                                (latest.ebit + (latest.depreciation or 0.0) if latest and latest.ebit is not None else None))
+    ratios["_latest_current_ratio"] = float(ratios["current_ratio"]) if isinstance(ratios.get("current_ratio"), str) and ratios["current_ratio"] not in ("—",) else None
+    ratios["_latest_quick_ratio"] = float(ratios["quick_ratio"]) if isinstance(ratios.get("quick_ratio"), str) and ratios["quick_ratio"] not in ("—",) else None
 
-    #Raw for computations
-    ratios["_latest"] = latest.dict()if latest else{}
+    # Raw for computations
+    ratios["_latest"] = latest.dict() if latest else {}
     return ratios
 
-def _risk_score(latest:ExtractedPeriod, ratios: Dict[str, Any], policies: Dict[str, Any]) -> float:
+
+def _risk_score(latest: ExtractedPeriod, ratios: Dict[str, Any], policies: Dict[str, Any]) -> float:
     """Simple additive score 0-100 based on policy thresholds."""
     score = 50.0
 
@@ -102,9 +108,9 @@ def _risk_score(latest:ExtractedPeriod, ratios: Dict[str, Any], policies: Dict[s
             score += 10
         elif cr >= 1.5:
             score += 6
-        elif cr >= 1.2 :
-            score +=3
-        elif cr< 1.0:
+        elif cr >= 1.2:
+            score += 3
+        elif cr < 1.0:
             score -= 10
 
     # Leverage
@@ -115,11 +121,11 @@ def _risk_score(latest:ExtractedPeriod, ratios: Dict[str, Any], policies: Dict[s
             score += 8
         elif de <= 1.0:
             score += 4
-        elif de >2.0:
+        elif de > 2.0:
             score -= 8
-    
-    #Interest coverage
-    ebit,interest =latest.ebit, latest.interest_expense
+
+    # Interest coverage
+    ebit, interest = latest.ebit, latest.interest_expense
     if ebit is not None and interest:
         ic = ebit / interest
         if ic >= 6:
@@ -128,110 +134,161 @@ def _risk_score(latest:ExtractedPeriod, ratios: Dict[str, Any], policies: Dict[s
             score += 6
         elif ic >= 1.5:
             score += 3
-        elif ic <1.0:
-            score -=12
+        elif ic < 1.0:
+            score -= 12
 
     # Profitability
     revenue = latest.revenue
-    net = latest.net_incoe
+    net = latest.net_income
     if revenue and net is not None:
-        nm = net /revenue
-        if nm  >= 0.1:
-            score +=6
+        nm = net / revenue
+        if nm >= 0.1:
+            score += 6
         elif nm >= 0.03:
             score += 3
-        elif nm< 0:
+        elif nm < 0:
             score -= 8
-    
-    #Growth
+
+    # Growth
     g = ratios.get("_revenue_growth_float")
     if g is not None:
         if g >= 0.2:
             score += 6
         elif g >= 0.05:
-            score +=3
+            score += 3
         elif g < 0:
             score -= 5
 
-    return max (0.0, min (100.0, score))
+    return max(0.0, min(100.0, score))
+
 
-def _rating(score:float) -> str:
+def _rating(score: float) -> str:
     if score >= 85: return "A"
     if score >= 70: return "B"
     if score >= 55: return "C"
     if score >= 40: return "D"
     return "E"
 
-def credit_decision(extract: FinancialExtract, ratios: Dict[str, Any],policies: Dict[str, Any]) -> Dict[str, Any]:
-    lateset = extract.latest()
+
+def credit_decision(extract: FinancialExtract, ratios: Dict[str, Any], policies: Dict[str, Any]) -> Dict[str, Any]:
+    latest = extract.latest()
     currency = extract.currency or "JPY"
-    if not lateset:
-        return{
-            "tating":"E",
-            "risk_score":0,
-            "site_days":0,
-            "transaction_limit_sisplay":_fmt_currency(0.0, currency),
-            "review_cycle":"取引前入金（与信不可)",
+    if not latest:
+        return {
+            "rating": "E",
+            "risk_score": 0,
+            "site_days": 0,
+            "transaction_limit": 0.0,
+            "transaction_limit_display": _fmt_currency(0.0, currency),
+            "review_cycle": "取引前入金（与信不可）",
         }
-    
-    score = _risk_score(lateset, ratios, policies)
-    rationg = _ _rating(score)
 
-    site_map = {"A":90,"B":60,"C":45,"D":30,"E":0}
-    review_map ={"A":"年1回","B":"半年毎","C":"四半期毎","D":"月次","E":"取引毎"}
+    score = _risk_score(latest, ratios, policies)
+    rating = _rating(score)
+
+    site_map = {"A": 90, "B": 60, "C": 45, "D": 30, "E": 0}
+    review_map = {"A": "年1回", "B": "半年毎", "C": "四半期毎", "D": "月次", "E": "取引ごと"}
 
     # Transaction limit heuristic
     revenue = latest.revenue or 0.0
-    working_capital = (lateset.current_assets or 0.0) - (latest.current_liabilities or 0.0)
-    liquidity_factor = 0.4 +0.6 *min (1.0,max(0.0,(float(ratios.get("current_ratio",0)if ratios.get("current_ratio")!="-"else 0)/2.0)))
-    risk_factor =0.5 + 0.5 *(score/100.0)
+    working_capital = (latest.current_assets or 0.0) - (latest.current_liabilities or 0.0)
+    liquidity_factor = 0.4 + 0.6 * min(1.0, max(0.0, (float(ratios.get("current_ratio", 0) if ratios.get("current_ratio") != "—" else 0) / 2.0)))
+    risk_factor = 0.5 + 0.5 * (score / 100.0)
 
-    #Base: monthly revenue × (site/30) × buffer
-    site_days = site_map[ratig]
-    base_limit = (revenue/12.0) * (site_days/30.0) * 0.6
+    # Base: monthly revenue × (site/30) × buffer
+    site_days = site_map[rating]
+    base_limit = (revenue / 12.0) * (site_days / 30.0) * 0.6
     # Cap by working capital (can't exceed 40% of WC)
     cap = max(0.0, working_capital) * 0.4
-    tx_limit = min(cap,base_limit * liquidity_factor * risk_factor)
+    tx_limit = min(cap, base_limit * liquidity_factor * risk_factor)
     tx_limit = max(0.0, tx_limit)
 
-    return{
-        "rating":rating,
-        "risk_score":site_days,
-        "site_days":site_days,
-        "transaction_limit_display":_fmt_currency(tx_limit, currency),
-        "review_cycle":review_map[rating],
+    return {
+        "rating": rating,
+        "risk_score": round(score, 1),
+        "site_days": site_days,
+        "transaction_limit": tx_limit,
+        "transaction_limit_display": _fmt_currency(tx_limit, currency),
+        "review_cycle": review_map[rating],
     }
 
-def _annuity_factor(rate:float, years: int) -> float:
-    """Annual amortization fctor for an annuity loan, rate in %,years int."""
-    r = rate /100.0
+
+def _annuity_factor(rate: float, years: int) -> float:
+    """Annual amortization factor for an annuity loan, rate in %, years int."""
+    r = rate / 100.0
     n = max(1, years)
     if r <= 0:
-        return 1.0/n
-    return r/ (1-(1+r)**(-n))
+        return 1.0 / n
+    return r / (1 - (1 + r) ** (-n))
+
 
-def loan_decision(extract: FinancialExtract, tatios: Dict[str, Any],base_rate_pct: float, policies: Dict[str, Any]) -> Dict[str, Any]:
+def loan_decision(extract: FinancialExtract, ratios: Dict[str, Any], base_rate_pct: float, policies: Dict[str, Any]) -> Dict[str, Any]:
     latest = extract.latest()
     currency = extract.currency or "JPY"
     if not latest:
-        return {"ev":0.0, "ev_display":_fmt_currency(0.0, currency),
-                "market_cap":0.0, "market_cap_display":_fmt_currency(0.0,currency),
-                "recommended_chek_size":0.0, "recommended_check_size_display":_fmt_currency(0.0,currency),
-                "attractiveness":1, "growth_label":"Low"}
-    
+        return {"max_principal": 0.0, "max_principal_display": _fmt_currency(0.0, currency),
+                "term_years": 0, "interest_rate_pct": base_rate_pct, "target_dscr": 0.0}
+
+    score = _risk_score(latest, ratios, policies)
+    rating = _rating(score)
+
+    # Risk premium by rating
+    rp = {"A": 0.5, "B": 1.0, "C": 2.0, "D": 3.5, "E": 0.0}[rating]
+    if rating == "E":
+        return {"max_principal": 0.0, "max_principal_display": _fmt_currency(0.0, currency),
+                "term_years": 0, "interest_rate_pct": 0.0, "target_dscr": 0.0}
+
+    interest_rate_pct = base_rate_pct + rp
+    term_years = {"A": 5, "B": 4, "C": 3, "D": 1}[rating]
+    target_dscr = {"A": 1.6, "B": 1.4, "C": 1.3, "D": 1.2}[rating]
+
+    ebitda = ratios.get("_latest_ebitda")
+    if not ebitda or ebitda <= 0:
+        return {"max_principal": 0.0, "max_principal_display": _fmt_currency(0.0, currency),
+                "term_years": term_years, "interest_rate_pct": interest_rate_pct, "target_dscr": target_dscr}
+
+    ann = _annuity_factor(interest_rate_pct, term_years)
+    annual_debt_service_cap = ebitda / target_dscr
+    max_principal = max(0.0, annual_debt_service_cap / ann)
+
+    # Cap by net tangible assets (if available): up to 50% of total assets - cash buffer
+    ta = latest.total_assets or 0.0
+    cash = latest.cash_and_equivalents or 0.0
+    nta_cap = max(0.0, (ta - cash) * 0.5)
+    max_principal = min(max_principal, nta_cap)
+
+    return {
+        "max_principal": max_principal,
+        "max_principal_display": _fmt_currency(max_principal, currency),
+        "term_years": term_years,
+        "interest_rate_pct": round(interest_rate_pct, 2),
+        "target_dscr": target_dscr,
+    }
+
+
+def investment_decision(extract: FinancialExtract, ratios: Dict[str, Any], policies: Dict[str, Any],
+                        multiples: Optional[MultipleSuggestion]) -> Dict[str, Any]:
+    latest = extract.latest()
+    currency = extract.currency or "JPY"
+    if not latest:
+        return {"ev": 0.0, "ev_display": _fmt_currency(0.0, currency),
+                "market_cap": 0.0, "market_cap_display": _fmt_currency(0.0, currency),
+                "recommended_check_size": 0.0, "recommended_check_size_display": _fmt_currency(0.0, currency),
+                "attractiveness": 1, "growth_label": "Low"}
+
     # Growth label
-    g = ratios.get("_revenue_growht_float")
+    g = ratios.get("_revenue_growth_float")
     if g is None:
         glabel = "Unknown"
     elif g >= 0.25:
         glabel = "High"
-    elif g >=0.05:
+    elif g >= 0.05:
         glabel = "Medium"
     else:
         glabel = "Low"
-    
+
     # Choose multiples
-    ebitda = latest.ebitda if latest.ebitda is not None else (latest.ebit + (latest.depreciation or 0.0)if latest.ebit is not None else None)
+    ebitda = latest.ebitda if latest.ebitda is not None else (latest.ebit + (latest.depreciation or 0.0) if latest.ebit is not None else None)
     revenue = latest.revenue or 0.0
     total_debt = latest.total_debt or 0.0
     cash = latest.cash_and_equivalents or 0.0
@@ -240,18 +297,18 @@ def loan_decision(extract: FinancialExtract, tatios: Dict[str, Any],base_rate_pc
     if multiples and ebitda and ebitda > 0:
         ev = ebitda * multiples.ebitda_multiple
     elif ebitda and ebitda > 0:
-        ev = ebitda * 8.0 #default
+        ev = ebitda * 8.0  # default
     else:
         # fallback to revenue multiple
         rev_mult = multiples.revenue_multiple if multiples else 1.5
         ev = revenue * rev_mult
 
-    market_cap = max(0.0,ev - net_debt)
+    market_cap = max(0.0, ev - net_debt)
 
-    #Check size heuristic: 5-15% of market cap depending or rating 
-    score = _ _risk_score(latest, ratios, policies)
+    # Check size heuristic: 5–15% of market cap depending on rating
+    score = _risk_score(latest, ratios, policies)
     rating = _rating(score)
-    pct = {"A":0.15,"B":0.12,"C":0.08,"D":0.04,"E":0.0}[rating]
+    pct = {"A": 0.15, "B": 0.12, "C": 0.08, "D": 0.04, "E": 0.0}[rating]
     check = market_cap * pct
 
     # Attractiveness 1-5 based on score + growth
@@ -259,30 +316,31 @@ def loan_decision(extract: FinancialExtract, tatios: Dict[str, Any],base_rate_pc
     if rating == "A":
         attractiveness = 5 if glabel == "High" else 4
     elif rating == "B":
-        attractiveness = 4 if glabel ! ="Low" else 3
+        attractiveness = 4 if glabel != "Low" else 3
     elif rating == "C":
-        attractiveness = 4 if glabel == "High" else 2
+        attractiveness = 3 if glabel == "High" else 2
     elif rating == "D":
         attractiveness = 1
 
-    return{
-        "ev":ev, "ev_display":_fmt_currency(ev, currency),
-        "market_cap":market_cap, "market_cap_display":_fmt_currency(market_cap,currency),
-        "recommended_check_size":check, "recommentded_check_size_display":_fmt_currency(check,currency),
-        "attractiveness":attractiveness,
-        "growth_label":glabel,
+    return {
+        "ev": ev, "ev_display": _fmt_currency(ev, currency),
+        "market_cap": market_cap, "market_cap_display": _fmt_currency(market_cap, currency),
+        "recommended_check_size": check, "recommended_check_size_display": _fmt_currency(check, currency),
+        "attractiveness": attractiveness,
+        "growth_label": glabel,
     }
 
-def build_report_dict(extract: FinancalExtract, ratios: Dict[str, Any], decisions:Dict[str, Any]) -> Dict[str, Any]:
-    return{
-        "metadata":{
-            "company_name":extract.company_name,
-            "industry":extract.industry,
-            "currency":extract.currency,
-            "fiscal_year_end":extract.fiscal_year_end,
+
+def build_report_dict(extract: FinancialExtract, ratios: Dict[str, Any], decisions: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "metadata": {
+            "company_name": extract.company_name,
+            "industry": extract.industry,
+            "currency": extract.currency,
+            "fiscal_year_end": extract.fiscal_year_end,
         },
-        "extracted":extract.dict()
-        "ratios":ratios,
-        "decisions":decisions,
-        "disclaimer":"本ツールはAIによる推定・一般的な計算式に基づく参考提案であり、投資勧誘・融資約定・与信保証を目的としたものではありません。最終判断は自己責任で、必要に応じて専門家の確認を行ってください。"
-    }
+        "extracted": extract.dict(),
+        "ratios": ratios,
+        "decisions": decisions,
+        "disclaimer": "本ツールはAIによる推定・一般的な計算式に基づく参考提案であり、投資勧誘・融資約定・与信保証を目的としたものではありません。最終判断は自己責任で、必要に応じて専門家の確認を行ってください。",
+    }

llm_extract.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 import os
-import jason
+import json
 from typing import List, Optional
 
 from openai import OpenAI
@@ -9,79 +9,82 @@ from pydantic import ValidationError
 
 from schemas import FinancialExtract, MultipleSuggestion
 
-VISION_MODEL = os.environ.get("OPENAI_VISION_MODEL","gpt-5")
-TEXT_MODEL = os.environ.get("OPENAI_TEXT_MODEL", "gpt-5")
+
+VISION_MODEL = os.environ.get("OPENAI_VISION_MODEL", "gpt-4o-mini")
+TEXT_MODEL   = os.environ.get("OPENAI_TEXT_MODEL",   "gpt-4o-mini")
+
 
 def get_client() -> OpenAI:
     key = os.environ.get("OPENAI_API_KEY")
     if not key:
-        raise RuntimeError("OPENAI_API_KEYが未設定です。 Spaces → Settings → Variable and secrets で追加してください。")
+        raise RuntimeError("OPENAI_API_KEY が未設定です。Spaces → Settings → Variables and secrets で追加してください。")
     return OpenAI(api_key=key, timeout=120)
 
-def upload_file_to_openai(xlient: OpenAI, filename: str, file_byte:bytes) -> str:
+
+def upload_file_to_openai(client: OpenAI, filename: str, file_bytes: bytes) -> str:
     """Upload file bytes to OpenAI Files API and return file_id."""
     from io import BytesIO
-    bio = BytesIO(file_byte)
+    bio = BytesIO(file_bytes)
     # Prefer 'vision', fallback to 'assistants' for SDK compatibility
     try:
-        f = client.siles.creare(file=("uploaded", bio),purpose="vision")
+        f = client.files.create(file=("uploaded", bio), purpose="vision")
     except Exception:
-        f = client.files.create(file=("uploaded",bio), purpose="assistants")
+        f = client.files.create(file=("uploaded", bio), purpose="assistants")
     return f.id
 
-def _financial_sxhema_json():
-    #Pydantic -> JSON Schema
+
+def _financial_schema_json():
+    # Pydantic -> JSON Schema
     return FinancialExtract.model_json_schema()
 
-def extract_financials_from_files(client: OpenAI, file_ids: List[str],company_hint:Optional[str],
-                                  currency_hint: Optional[str], model:str = VISION_MODEL,
+
+def extract_financials_from_files(client: OpenAI, file_ids: List[str], company_hint: Optional[str],
+                                  currency_hint: Optional[str], model: str = VISION_MODEL,
                                   debug: bool = False) -> FinancialExtract:
-    """Use Vision model to read statements and produce normalized finacials(latest + previous)"""
+    """Use vision model to read statements and produce normalized financials (latest + previous)."""
     system = (
-        " You are a meticulous financial analyst. Read the provided financial statement filise"
-        "and extraxt the lateser two fiscal periods' key items with units normalized to the statement currency."
-        "If multiple statements exist, prefer consolidated figures."
-        "Return strictly valid JSON that conforms to the provided JSON schema."
-        "IF any time is missing, set it to null rather than guessing."
+        "You are a meticulous financial analyst. Read the provided financial statement files "
+        "and extract the latest two fiscal periods' key items with units normalized to the statement currency. "
+        "If multiple statements exist, prefer consolidated figures. "
+        "Return strictly valid JSON that conforms to the provided JSON schema. "
+        "If any item is missing, set it to null rather than guessing."
     )
-
     user_text = (
-        "Extraxt the company name, currency, fiscal year end, and the latest twp periods' numbers"
-        "(revenue, COGS, EBIT, depreciation, EBITDA, net income, cash ,receivables, inventory, payable,"
-        "current assets, current liabilities, total assets, total equity, total debt, expense)."
-        "If both annual and quarterly are present, prefer annual."
-        "Do not compute new numbers except EBITDA =EBIT + depreciation when both are available."
+        "Extract the company name, currency, fiscal year end, and the latest two periods' numbers "
+        "(revenue, COGS, EBIT, depreciation, EBITDA, net income, cash, receivables, inventory, payables, "
+        "current assets, current liabilities, total assets, total equity, total debt, interest expense). "
+        "If both annual and quarterly are present, prefer annual. "
+        "Do not compute new numbers except EBITDA = EBIT + depreciation when both are available."
     )
     if company_hint:
         user_text += f"\nCompany hint: {company_hint}"
     if currency_hint:
-        user_text += f"\nCurrency hint:{currency_hint}"
+        user_text += f"\nCurrency hint: {currency_hint}"
 
-    #Using the Responses API with Structured Outputs JSON schema
+    # Using the Responses API with Structured Outputs JSON schema
     resp = client.responses.create(
         model=model,
         input=[
             {
-                "role":"system"
-                "content":[{"type_text","text":system}],
+                "role": "system",
+                "content": [{"type": "input_text", "text": system}],
             },
             {
-                "role":"user",
-                "content":[{"type":"input_text","text":user_text}]+[
-                    {"type":"input_file","file_ids": fid} for fid in file_ids
+                "role": "user",
+                "content": [{"type": "input_text", "text": user_text}] + [
+                    {"type": "input_file", "file_id": fid} for fid in file_ids
                 ],
             },
-        ]
-        response_fromat={
-                "type":"json_schema",
-                "json_schema":{
-                    "name":"FinancialExtract",
-                    "schema":_financial_schema_json(),
-                    "strict":True,
-                },
+        ],
+        response_format={
+            "type": "json_schema",
+            "json_schema": {
+                "name": "FinancialExtract",
+                "schema": _financial_schema_json(),
+                "strict": True,
             },
-            max_output_tokens=2048,
-        
+        },
+        max_output_tokens=2048,
     )
 
     try:
@@ -94,65 +97,66 @@ def extract_financials_from_files(client: OpenAI, file_ids: List[str],company_hi
 
     if not raw:
         raise RuntimeError("LLMからの応答が空でした。")
-    
+
     try:
-        data =json.loads(raw)
+        data = json.loads(raw)
     except json.JSONDecodeError as e:
         if not debug:
             raw2 = raw.strip()
             if raw2.startswith("```"):
-                raw2 = raw2.strip("`").split("\n",1)[-1]
-                data = json.loads(raw2)
+                raw2 = raw2.strip("`").split("\n", 1)[-1]
+            data = json.loads(raw2)
         else:
             raise
 
     try:
-        extract = FinancialExtract.model_validate(date)
+        extract = FinancialExtract.model_validate(data)
     except ValidationError as ve:
-        raise RuntimeError(f"構造化出力の検証に失敗：{ve}")
-    
+        raise RuntimeError(f"構造化出力の検証に失敗: {ve}")
+
     return extract
 
-def suggest_multiples_with_llm(client: OpenAI, text_model:str, industry: str, region: str = "JP",debug: bool =False) -> Optional[MultipleSuggestion]:
-    """Ask a small text model to propose resonable valuation multiples for the given industry/region."""
+
+def suggest_multiples_with_llm(client: OpenAI, text_model: str, industry: str, region: str = "JP", debug: bool = False) -> Optional[MultipleSuggestion]:
+    """Ask a small text model to propose reasonable valuation multiples for the given industry/region."""
     if not industry:
         return None
-    
-    system = " You are an equity analyst. Provide conservative valuation multiple estimates for the given industry and region."
+
+    system = "You are an equity analyst. Provide conservative valuation multiple estimates for the given industry and region."
     user = (
-        f"Industry:{industry}\nRegion: {region}\n"
-        "Return a short JSON with keys: revenue_multiple(float),ebitda_multiple(float)."
+        f"Industry: {industry}\nRegion: {region}\n"
+        "Return a short JSON with keys: revenue_multiple (float), ebitda_multiple (float). "
         "Use public-market small/mid-cap ranges where applicable and be conservative."
     )
 
     resp = client.responses.create(
         model=text_model,
         input=[
-            {"role":"system","content":[{"type":"input_text","text":system}]},
-            {"role":"user","content":[{"type":"input_text","text":user}]},
+            {"role": "system", "content": [{"type": "input_text", "text": system}]},
+            {"role": "user", "content": [{"type": "input_text", "text": user}]},
         ],
         response_format={
-            "type":"json_schema",
-            "json_schema":{
-                "name":"MultipleSuggestion",
-                "schema":MultipleSuggestion.model_json_schema(),
-                "strict":True,
+            "type": "json_schema",
+            "json_schema": {
+                "name": "MultipleSuggestion",
+                "schema": MultipleSuggestion.model_json_schema(),
+                "strict": True,
             },
         },
         max_output_tokens=200,
     )
 
     try:
-
         raw = resp.output_text
     except Exception:
         try:
             raw = resp.output[0].content[0].text
         except Exception:
             raw = None
+
     if not raw:
         return None
-    
+
     try:
         data = json.loads(raw)
         return MultipleSuggestion.model_validate(data)
@@ -160,4 +164,3 @@ def suggest_multiples_with_llm(client: OpenAI, text_model:str, industry: str, re
         if debug:
             raise
         return None
-    

schemas.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 from typing import Optional, List
 from pydantic import BaseModel, Field
 
+
 class ExtractedPeriod(BaseModel):
-    period_label: Optional[str] = Field(None, description = "e.g., FY2024,FY2023" "")
-    revenue:Optional[float] = None
+    period_label: Optional[str] = Field(None, description="e.g., FY2024, FY2023")
+    revenue: Optional[float] = None
     cogs: Optional[float] = None
     ebit: Optional[float] = None
     depreciation: Optional[float] = None
@@ -14,28 +15,35 @@ class ExtractedPeriod(BaseModel):
 
     cash_and_equivalents: Optional[float] = None
     accounts_receivable: Optional[float] = None
-    total_assests: Optional[float] = None
+    inventory: Optional[float] = None
+    accounts_payable: Optional[float] = None
+
+    current_assets: Optional[float] = None
+    current_liabilities: Optional[float] = None
+    total_assets: Optional[float] = None
     total_equity: Optional[float] = None
     total_debt: Optional[float] = None
-    interest_expense:Optional[float] = None
+    interest_expense: Optional[float] = None
+
 
 class FinancialExtract(BaseModel):
     company_name: Optional[str] = None
     industry: Optional[str] = None
-    currency: Optional[str] = None
-    fiscal_year_end: Optional[str] = None
-    period: List[ExtractedPeriod]
+    currency: Optional[str] = None  # e.g., JPY, USD
+    fiscal_year_end: Optional[str] = None  # YYYY-MM-DD if known
+    periods: List[ExtractedPeriod]
 
     def latest(self) -> Optional[ExtractedPeriod]:
         if not self.periods:
             return None
-        return self.period[0]
-    
-    def prebious(self) -> Optional[ExtractedPeriod]:
+        return self.periods[0]
+
+    def previous(self) -> Optional[ExtractedPeriod]:
         if not self.periods or len(self.periods) < 2:
             return None
-        return self.period[1]
-    
+        return self.periods[1]
+
+
 class MultipleSuggestion(BaseModel):
     revenue_multiple: float = 1.5
-    ebitda_multiple: float =8.0
+    ebitda_multiple: float = 8.0