初始化项目

IndexCalculation/.gitignore

@@ -0,0 +1,2 @@
+.idea
+*.pyc

IndexCalculation/Utils/IndexStore/RegisterUtils.py

@@ -0,0 +1,15 @@
+# import requests
+#
+# from Utils.Schemas import IndicatorDescription
+#
+# URL = "http://test.fecribd.com/api/index_store/register"
+# TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2luZm8iOnsidWlkIjoiVUlEMDAwMSIsImVtYWlsIjoiZmVjcmliZEBmZWNyLmNvbS5jbiIsIm5hbWUiOiJyb290Iiwicm9sZSI6Ilx1N2JhMVx1NzQwNlx1NTQ1OCIsImRlcGFydG1lbnQiOiJcdTY1NzBcdTViNTdcdTUzMTZcdTkwZTgiLCJyb2xlX2lkIjoiUk9MRTAxIiwiZGVwYXJ0bWVudF9pZCI6IkQwMDEifSwiZXhwIjoxNjgzNDc2OTA4fQ.8girdw3n0WDktRuK0aSgGor10eb11nIFvRJqUtPZum4"
+# HEADERS = {"token": TOKEN}
+#
+#
+# def register_to_index_store(schema: IndicatorDescription):
+#     res = requests.post(url=URL, headers=HEADERS, json=schema.dict())
+#     if res.status_code == 200:
+#         return True
+#     else:
+#         return False

IndexCalculation/Utils/Schemas/IndexSchemas.py

@@ -0,0 +1,32 @@
+from enum import Enum
+from typing import List
+
+import pydantic
+from pydantic import BaseModel
+
+ENameRegex = pydantic.constr(regex="^[a-z_]{1,}$")
+CNameRegex = pydantic.constr(regex="^[\u4e00-\u9fa5a-zA-Z0-9（）]+$")
+
+
+class Parameter(BaseModel):
+    ename: ENameRegex = "example_param"
+    cname: str = "示例参数"
+    description: str = "参数介绍文字"
+
+
+class NatureEnum(Enum):
+    quantity = "定量"
+    quality = "定性"
+
+
+class IndicatorDescription(BaseModel):
+    ename: ENameRegex = "example_indicator"
+    cname: str = "示例指标"
+    description: str = "指标介绍文字"
+    nature: NatureEnum
+    category: str
+    parameters: List[Parameter]
+
+    class Config:
+        use_enum_values = True
+

IndexCalculation/main.py

@@ -0,0 +1,29 @@
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+import 基本信用评级指标
+
+app = FastAPI(
+    title="指标函数计算接口",
+    description="1.发送计算请求，返回结果数值\n"
+                "2.发送描述请求，返回指标描述信息",
+    version="v1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# 路由
+PREFIX = "/api/index_function"
+app.include_router(基本信用评级指标.router, prefix=PREFIX)
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8002)

IndexCalculation/requirements.txt

@@ -0,0 +1,5 @@
+fastapi~=0.85.0
+pydantic~=1.10.2
+uvicorn
+requests~=2.28.1
+pandas~=1.5.2

IndexCalculation/基本信用评级指标/__init__.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标 import 债务水平, 偿付能力, 偿债能力, 抗风险能力, 担保质量, 流动性, 流动性风险, 盈利能力, 经济实力, 规模, 财务杠杆, \
+    财政收支, 资产质量, 资本充足性, 资本结构, 资本要求, 运营效率, 风险抵御能力
+
+router = APIRouter()
+
+router.include_router(债务水平.router)
+router.include_router(偿付能力.router)
+router.include_router(偿债能力.router)
+router.include_router(抗风险能力.router)
+router.include_router(担保质量.router)
+router.include_router(流动性.router)
+router.include_router(流动性风险.router)
+router.include_router(盈利能力.router)
+router.include_router(经济实力.router)
+router.include_router(规模.router)
+router.include_router(财务杠杆.router)
+router.include_router(财政收支.router)
+router.include_router(资产质量.router)
+router.include_router(资本充足性.router)
+router.include_router(资本结构.router)
+router.include_router(资本要求.router)
+router.include_router(运营效率.router)
+router.include_router(风险抵御能力.router)
+

IndexCalculation/基本信用评级指标/债务水平/__init__.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.债务水平 import 债务率
+
+router = APIRouter(tags=["债务水平"])
+
+router.include_router(债务率.router)

IndexCalculation/基本信用评级指标/债务水平/债务率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "债务率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    地方政府债务余额: float
+    地方政府综合财力: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = (p.地方政府债务余额 / p.地方政府综合财力) * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿付能力/__init__.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.偿付能力 import 不良贷款率, 拨备覆盖率, 拨备覆盖率_商业银行, 核心一级资本充足率, 资本资产比率, 综合偿付能力充足率
+
+router = APIRouter(tags=["偿付能力"])
+
+router.include_router(不良贷款率.router)
+router.include_router(拨备覆盖率.router)
+router.include_router(拨备覆盖率_商业银行.router)
+router.include_router(核心一级资本充足率.router)
+router.include_router(资本资产比率.router)
+router.include_router(综合偿付能力充足率.router)

IndexCalculation/基本信用评级指标/偿付能力/不良贷款率.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "不良贷款率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    次级类贷款: float
+    可疑类贷款: float
+    损失类贷款: float
+    各项贷款: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.次级类贷款 + p.可疑类贷款 + p.损失类贷款
+        result = d / p.各项贷款 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿付能力/拨备覆盖率.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "拨备覆盖率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    应收融资租赁款减值准备: float
+    不良应收融资租赁款: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.应收融资租赁款减值准备 / p.不良应收融资租赁款 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿付能力/拨备覆盖率_商业银行.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "拨备覆盖率-商业银行（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    贷款损失准备: float
+    不良贷款余额: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.贷款损失准备 / p.不良贷款余额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿付能力/核心一级资本充足率.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "核心一级资本充足率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    核心一级资本: float
+    对应资本扣除项: float
+    风险加权资产: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.核心一级资本 + p.对应资本扣除项
+        result = d / p.风险加权资产 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿付能力/综合偿付能力充足率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "综合偿付能力充足率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    实际资本: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.实际资本 / 200000000 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿付能力/资本资产比率.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "资本资产比率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    所有者权益: float
+    总资产: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.所有者权益 / p.总资产 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/CFO_总债务.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "CFO/总债务（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    短期借款: float
+    长期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    应付债券: float
+    其他长期有息债务: float
+    经营活动产生的现金流量净额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        result = p.经营活动产生的现金流量净额 / d
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/CFO_总债务_三年加权计算.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "CFO/总债务_三年加权计算（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期短期借款: float
+    当期长期借款: float
+    当期交易性金融负债: float
+    当期应付票据: float
+    当期一年内到期的非流动负债: float
+    当期其他短期有息债务: float
+    当期应付债券: float
+    当期其他长期有息债务: float
+    当期经营活动产生的现金流量净额: float
+
+    上期短期借款: float
+    上期长期借款: float
+    上期交易性金融负债: float
+    上期应付票据: float
+    上期一年内到期的非流动负债: float
+    上期其他短期有息债务: float
+    上期应付债券: float
+    上期其他长期有息债务: float
+    上期经营活动产生的现金流量净额: float
+
+    上二期短期借款: float
+    上二期长期借款: float
+    上二期交易性金融负债: float
+    上二期应付票据: float
+    上二期一年内到期的非流动负债: float
+    上二期其他短期有息债务: float
+    上二期应付债券: float
+    上二期其他长期有息债务: float
+    上二期经营活动产生的现金流量净额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ratio1 = p.当期经营活动产生的现金流量净额 / (
+                    p.当期短期借款 + p.当期交易性金融负债 + p.当期应付票据 + p.当期一年内到期的非流动负债 + p.当期其他短期有息债务 + p.当期长期借款 + p.当期应付债券 + p.当期其他长期有息债务)
+        ratio2 = p.上期经营活动产生的现金流量净额 / (
+                    p.上期短期借款 + p.上期交易性金融负债 + p.上期应付票据 + p.上期一年内到期的非流动负债 + p.上期其他短期有息债务 + p.上期长期借款 + p.上期应付债券 + p.上期其他长期有息债务)
+        ratio3 = p.上二期经营活动产生的现金流量净额 / (
+                    p.上二期短期借款 + p.上二期交易性金融负债 + p.上二期应付票据 + p.上二期一年内到期的非流动负债 + p.上二期其他短期有息债务 + p.上二期长期借款 + p.上二期应付债券 + p.上二期其他长期有息债务)
+        result = ratio1 * 0.5 + ratio2 * 0.2 + ratio3 + 0.3
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/EBITDA利息保障倍数.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBITDA利息保障倍数（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    利润总额: float
+    计入财务费用的利息支出: float
+    固定资产: float
+    无形资产: float
+    长期待摊费用: float
+    资本化利息支出: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.利润总额 + p.计入财务费用的利息支出 + p.固定资产 + p.无形资产 + p.长期待摊费用
+        d = p.计入财务费用的利息支出 + p.资本化利息支出
+        result = m / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/EBITDA利息保障倍数_三年加权计算.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBITDA利息保障倍数_三年加权计算（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期利润总额: float
+    当期计入财务费用的利息支出: float
+    当期固定资产: float
+    当期无形资产: float
+    当期长期待摊费用: float
+    当期资本化利息支出: float
+
+    上期利润总额: float
+    上期计入财务费用的利息支出: float
+    上期固定资产: float
+    上期无形资产: float
+    上期长期待摊费用: float
+    上期资本化利息支出: float
+
+    上二期利润总额: float
+    上二期计入财务费用的利息支出: float
+    上二期固定资产: float
+    上二期无形资产: float
+    上二期长期待摊费用: float
+    上二期资本化利息支出: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ratio1 = (p.当期利润总额 + p.当期计入财务费用的利息支出 + p.当期固定资产 + p.当期无形资产 + p.当期长期待摊费用) / (p.当期计入财务费用的利息支出 + p.当期资本化利息支出) * 100
+        ratio2 = (p.上期利润总额 + p.上期计入财务费用的利息支出 + p.上期固定资产 + p.上期无形资产 + p.上期长期待摊费用) / (p.上期计入财务费用的利息支出 + p.上期资本化利息支出) * 100
+        ratio3 = (p.上二期利润总额 + p.上二期计入财务费用的利息支出 + p.上二期固定资产 + p.上二期无形资产 + p.上二期长期待摊费用) / (p.上二期计入财务费用的利息支出 + p.上二期资本化利息支出) * 100
+        result = ratio1*0.5 + ratio2*0.3 + ratio3*0.2
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/EBIT利息保障倍数.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBIT利息保障倍数（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净利润: float
+    计入财务费用的利息支出: float
+    所得税: float
+    资本化利息支出: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.净利润 + p.计入财务费用的利息支出 + p.所得税
+        d = p.计入财务费用的利息支出 + p.资本化利息支出
+        result = m / d
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/EBIT利息保障倍数_三年加权计算.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBIT利息保障倍数_三年加权计算（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期净利润: float
+    当期计入财务费用的利息支出: float
+    当期所得税: float
+    当期资本化利息支出: float
+
+    上期净利润: float
+    上期计入财务费用的利息支出: float
+    上期所得税: float
+    上期资本化利息支出: float
+
+    上二期净利润: float
+    上二期计入财务费用的利息支出: float
+    上二期所得税: float
+    上二期资本化利息支出: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ratio1 = (p.当期净利润 + p.当期计入财务费用的利息支出 + p.当期所得税) / (p.当期计入财务费用的利息支出 + p.当期资本化利息支出)
+        ratio2 = (p.上期净利润 + p.上期计入财务费用的利息支出 + p.上期所得税) / (p.上期计入财务费用的利息支出 + p.上期资本化利息支出)
+        ratio3 = (p.上二期净利润 + p.上二期计入财务费用的利息支出 + p.上二期所得税) / (p.上二期计入财务费用的利息支出 + p.上二期资本化利息支出)
+        result = ratio1*0.5 + ratio2*0.3 + ratio3*0.2
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/__init__.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter
+from IndexCalculation.基本信用评级指标.偿债能力 import CFO_总债务, EBITDA利息保障倍数, EBIT利息保障倍数, 总债务_EBITDA, 经营性现金流净额_总债务, 经营性现金流净额_总债务_三年加权平均, \
+    调整后的经营性现金流净额_总债务, 销售商品提供劳务收到的现金_总债务, 非筹资性现金流入量_总债务, CFO_总债务_三年加权计算, EBITDA利息保障倍数_三年加权计算, EBIT利息保障倍数_三年加权计算
+
+router = APIRouter(tags=["偿债能力"])
+
+router.include_router(CFO_总债务.router)
+router.include_router(EBITDA利息保障倍数.router)
+router.include_router(EBIT利息保障倍数.router)
+router.include_router(总债务_EBITDA.router)
+router.include_router(经营性现金流净额_总债务.router)
+router.include_router(经营性现金流净额_总债务_三年加权平均.router)
+router.include_router(调整后的经营性现金流净额_总债务.router)
+router.include_router(销售商品提供劳务收到的现金_总债务.router)
+router.include_router(非筹资性现金流入量_总债务.router)
+router.include_router(CFO_总债务_三年加权计算.router)
+router.include_router(EBITDA利息保障倍数_三年加权计算.router)
+router.include_router(EBIT利息保障倍数_三年加权计算.router)
+

IndexCalculation/基本信用评级指标/偿债能力/总债务_EBITDA.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "总债务/EBITDA（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    短期借款: float
+    长期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    应付债券: float
+    其他长期有息债务: float
+    利润总额: float
+    计入财务费用的利息支出: float
+    固定资产: float
+    无形资产: float
+    长期待摊费用: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        d = p.利润总额 + p.计入财务费用的利息支出 + p.固定资产 + p.无形资产 + p.长期待摊费用
+        result = m / d
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/经营性现金流净额_总债务.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "经营性现金流净额/总债务（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    短期借款: float
+    长期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    应付债券: float
+    其他长期有息债务: float
+    经营活动产生的现金流量净额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        result = p.经营活动产生的现金流量净额 / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/经营性现金流净额_总债务_三年加权平均.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "经营性现金流净额/总债务_三年加权计算（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期短期借款: float
+    当期长期借款: float
+    当期交易性金融负债: float
+    当期应付票据: float
+    当期一年内到期的非流动负债: float
+    当期其他短期有息债务: float
+    当期应付债券: float
+    当期其他长期有息债务: float
+    当期经营活动产生的现金流量净额: float
+
+    上期短期借款: float
+    上期长期借款: float
+    上期交易性金融负债: float
+    上期应付票据: float
+    上期一年内到期的非流动负债: float
+    上期其他短期有息债务: float
+    上期应付债券: float
+    上期其他长期有息债务: float
+    上期经营活动产生的现金流量净额: float
+
+    上二期短期借款: float
+    上二期长期借款: float
+    上二期交易性金融负债: float
+    上二期应付票据: float
+    上二期一年内到期的非流动负债: float
+    上二期其他短期有息债务: float
+    上二期应付债券: float
+    上二期其他长期有息债务: float
+    上二期经营活动产生的现金流量净额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ratio1 = p.当期经营活动产生的现金流量净额 / (p.当期短期借款 + p.当期交易性金融负债 + p.当期应付票据 + p.当期一年内到期的非流动负债 + p.当期其他短期有息债务 + p.当期长期借款 + p.当期应付债券 + p.当期其他长期有息债务) * 100
+        ratio2 = p.上期经营活动产生的现金流量净额 / (p.上期短期借款 + p.上期交易性金融负债 + p.上期应付票据 + p.上期一年内到期的非流动负债 + p.上期其他短期有息债务 + p.上期长期借款 + p.上期应付债券 + p.上期其他长期有息债务) * 100
+        ratio3 = p.上二期经营活动产生的现金流量净额 / (p.上二期短期借款 + p.上二期交易性金融负债 + p.上二期应付票据 + p.上二期一年内到期的非流动负债 + p.上二期其他短期有息债务 + p.上二期长期借款 + p.上二期应付债券 + p.上二期其他长期有息债务) * 100
+        result = ratio1 * 0.5 + ratio2 * 0.3 + ratio3 * 0.2
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/调整后的经营性现金流净额_总债务.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "调整后的经营性现金流净额/总债务（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    经营活动产生的现金流量净额: float
+    经营性应收项目的减少: float
+    经营性应付项目的增加: float
+    短期借款: float
+    长期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    应付债券: float
+    其他长期有息债务: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.经营活动产生的现金流量净额 - p.经营性应收项目的减少 - p.经营性应付项目的增加
+        d = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        result = m / d
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/销售商品提供劳务收到的现金_总债务.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "销售商品、提供劳务收到的现金/总债务（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    销售商品提供劳务收到的现金: float
+    短期借款: float
+    长期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    应付债券: float
+    其他长期有息债务: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        result = p.销售商品提供劳务收到的现金 / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/偿债能力/非筹资性现金流入量_总债务.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "非筹资性现金流入量/总债务（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    经营活动产生的现金流量净额: float
+    投资活动产生的现金流量净额: float
+    短期借款: float
+    长期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    应付债券: float
+    其他长期有息债务: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.经营活动产生的现金流量净额 + p.投资活动产生的现金流量净额
+        d = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        result = m / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/抗风险能力/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.抗风险能力 import 杠杆倍数, 资本充足率
+
+router = APIRouter(tags=["抗风险能力"])
+
+router.include_router(杠杆倍数.router)
+router.include_router(资本充足率.router)
+

IndexCalculation/基本信用评级指标/抗风险能力/杠杆倍数.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "杠杆倍数（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    风险资产: float
+    净资产: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.风险资产 / p.净资产 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/抗风险能力/资本充足率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "资本充足率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    资本净额: float
+    风险加权资产: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.资本净额 / p.风险加权资产 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/担保质量/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.担保质量 import 累计代偿回收率, 累计代偿率
+
+router = APIRouter(tags=["担保质量"])
+
+router.include_router(累计代偿回收率.router)
+router.include_router(累计代偿率.router)
+

IndexCalculation/基本信用评级指标/担保质量/累计代偿回收率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "累计代偿回收率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    累计代偿回收额: float
+    累计担保代偿额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.累计代偿回收额 / p. 累计担保代偿额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/担保质量/累计代偿率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "累计代偿率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    累计担保代偿额: float
+    累计解保额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.累计担保代偿额 / p.累计解保额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/流动性/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.流动性 import 净稳定资金率, 高流动性资产占比
+
+router = APIRouter(tags=["流动性"])
+
+router.include_router(净稳定资金率.router)
+router.include_router(高流动性资产占比.router)
+

IndexCalculation/基本信用评级指标/流动性/净稳定资金率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净稳定资金率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    可用稳定资金: float
+    所需稳定资金: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.可用稳定资金 / p.所需稳定资金 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/流动性/高流动性资产占比.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "高流动性资产占比（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    货币资金: float
+    以公允价值且其变动计入其他综合收益的金融资产: float
+    买入返售金融资产: float
+    一年内到期的定期存款: float
+    总资产: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.货币资金 + p.以公允价值且其变动计入其他综合收益的金融资产 + p.买入返售金融资产 + p.一年内到期的定期存款
+        result = d / p.总资产 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/流动性风险/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.流动性风险 import 流动性比例
+from IndexCalculation.基本信用评级指标.流动性风险 import 流动性比率
+
+router = APIRouter(tags=["流动性风险"])
+
+router.include_router(流动性比例.router)
+router.include_router(流动性比率.router)
+

IndexCalculation/基本信用评级指标/流动性风险/流动性比例.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "流动性比例（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    流动性资产余额: float
+    流动性负债余额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.流动性资产余额 / p.流动性负债余额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/流动性风险/流动性比率.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "流动性比率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    现金: float
+    对央行的债权: float
+    对同业的债权: float
+    交易性金融资产: float
+    相关受限资产: float
+    资产总计: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.现金 + p.对央行的债权 + p.对同业的债权 + p.交易性金融资产 + p.相关受限资产
+        result = m / p.资产总计 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/EBITDA利润率.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBITDA利润率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    利润总额: float
+    计入财务费用的利息支出: float
+    固定资产: float
+    无形资产: float
+    长期待摊费用: float
+    营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ebitda = p.利润总额 + p.计入财务费用的利息支出 + p.固定资产 + p.无形资产 + p.长期待摊费用
+        result = ebitda / p.利润总额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/EBITDA利润率_三年加权计算.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBITDA利润率_三年加权计算（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期利润总额: float
+    当期计入财务费用的利息支出: float
+    当期固定资产: float
+    当期无形资产: float
+    当期长期待摊费用: float
+    当期营业收入: float
+    上期利润总额: float
+    上期计入财务费用的利息支出: float
+    上期固定资产: float
+    上期无形资产: float
+    上期长期待摊费用: float
+    上期营业收入: float
+    上二期利润总额: float
+    上二期计入财务费用的利息支出: float
+    上二期固定资产: float
+    上二期无形资产: float
+    上二期长期待摊费用: float
+    上二期营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ebitda1 = (p.当期利润总额 + p.当期计入财务费用的利息支出 + p.当期固定资产 + p.当期无形资产 + p.当期长期待摊费用) / p.当期利润总额 * 100
+        ebitda2 = (p.上期利润总额 + p.上期计入财务费用的利息支出 + p.上期固定资产 + p.上期无形资产 + p.上期长期待摊费用) / p.上期利润总额 * 100
+        ebitda3 = (p.上二期利润总额 + p.上二期计入财务费用的利息支出 + p.上二期固定资产 + p.上二期无形资产 + p.上二期长期待摊费用) / p.上二期利润总额 * 100
+        result = ebitda1 * 0.5 + ebitda2*0.3 + ebitda3*0.2
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/EBIT利润率.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBIT利润率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    利润总额: float
+    计入财务费用的利息支出: float
+    营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = (p.利润总额 + p.计入财务费用的利息支出) / p.营业收入 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/EBIT利润率_三年加权计算.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBIT利润率_三年加权计算（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期利润总额: float
+    当期计入财务费用的利息支出: float
+    当期营业收入: float
+
+    上期利润总额: float
+    上期计入财务费用的利息支出: float
+    上期营业收入: float
+
+    上二期利润总额: float
+    上二期计入财务费用的利息支出: float
+    上二期营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ebit1 = (p.当期利润总额 + p.当期计入财务费用的利息支出) / p.当期营业收入 * 100
+        ebit2 = (p.上期利润总额 + p.上期计入财务费用的利息支出) / p.上期营业收入 * 100
+        ebit3 = (p.上二期利润总额 + p.上二期计入财务费用的利息支出) / p.上二期营业收入 * 100
+        result = ebit1 * 0.5 + ebit2 * 0.3 + ebit3 * 0.2
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/EBIT利润率_含投资收益.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "EBIT利润率_含投资收益（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    利润总额: float
+    计入财务费用的利息支出: float
+    营业收入_含投资收益: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = (p.利润总额 + p.计入财务费用的利息支出) / p. 营业收入_含投资收益 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/__init__.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.盈利能力 import EBITDA利润率, EBIT利润率, EBIT利润率_含投资收益, 净资产收益率, 平均资本回报率, \
+    总资产报酬率, 拨备前利润_平均风险加权资产, 毛利率, 经调整营业利润率, 综合成本率, 综合费用率, 营业利润率, 营业利润率_三年加权计算, \
+    费用收入比, EBITDA利润率_三年加权计算, EBIT利润率_三年加权计算, 总资产报酬率_三年加权计算
+
+router = APIRouter(tags=["盈利能力"])
+
+router.include_router(EBITDA利润率.router)
+router.include_router(EBITDA利润率_三年加权计算.router)
+router.include_router(EBIT利润率.router)
+router.include_router(EBIT利润率_三年加权计算.router)
+router.include_router(EBIT利润率_含投资收益.router)
+router.include_router(净资产收益率.router)
+router.include_router(平均资本回报率.router)
+router.include_router(总资产报酬率.router)
+router.include_router(总资产报酬率_三年加权计算.router)
+router.include_router(拨备前利润_平均风险加权资产.router)
+router.include_router(毛利率.router)
+router.include_router(经调整营业利润率.router)
+router.include_router(综合成本率.router)
+router.include_router(综合费用率.router)
+router.include_router(营业利润率.router)
+router.include_router(营业利润率_三年加权计算.router)
+router.include_router(费用收入比.router)

IndexCalculation/基本信用评级指标/盈利能力/净资产收益率.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净资产收益率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净利润: float
+    期末所有者权益合计: float
+    期初所有者权益合计: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = (p.期末所有者权益合计 + p.期初所有者权益合计) / 2
+        result = p.净利润 / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/平均资本回报率.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "平均资本回报率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净利润: float
+    本期末所有者权益_含少数股东权益: float
+    上期末所有者权益_含少数股东权益: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = (p.本期末所有者权益_含少数股东权益 + p.上期末所有者权益_含少数股东权益) / 2
+        result = p.净利润 / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/总资产报酬率.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "总资产报酬率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净利润: float
+    所得税: float
+    利息费用: float
+    期末资产总计: float
+    期初资产总计: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = (p.期末资产总计 + p.期初资产总计) / 2
+        result = (p.净利润 + p.所得税 + p.利息费用) / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/总资产报酬率_三年加权计算.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "总资产报酬率_三年加权计算（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期净利润: float
+    当期所得税: float
+    当期利息: float
+    上期资产总计: float
+    当期资产总计: float
+
+    上期净利润: float
+    上期所得税: float
+    上期利息: float
+    上二期资产总计: float
+
+    上二期净利润: float
+    上二期所得税: float
+    上二期利息: float
+    上三期资产总计: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ratio1 = (p.当期净利润 + p.当期所得税 + p.当期利息) / ((p.上期资产总计 + p.当期资产总计) / 2) * 100
+        ratio2 = (p.上期净利润 + p.上期所得税 + p.上期利息) / ((p.上二期资产总计 + p.上期资产总计) / 2) * 100
+        ratio3 = (p.上二期净利润 + p.上二期所得税 + p.上二期利息) / ((p.上三期资产总计 + p.上二期资产总计) / 2) * 100
+        result = ratio1 * 0.5 + ratio2 * 0.3 + ratio3 * 0.3
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/拨备前利润_平均风险加权资产.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "拨备前利润/平均风险加权资产"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    利润总额: float
+    减值准备金: float
+    平均风险加权资产: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = (p.利润总额 + p.减值准备金) / p.平均风险加权资产
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "+inf"  # 此处本应为算式无意义，特殊处理为正无穷大
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/毛利率.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "毛利率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业收入: float
+    营业成本: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.营业收入 - p.营业成本
+        result = d / p.营业收入 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/经调整营业利润率.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "经调整营业利润率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业利润: float
+    营业总成本_含信用减值损失及资产减值损失: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.营业利润 / (p.营业利润 + p.营业总成本_含信用减值损失及资产减值损失) * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/综合成本率.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "综合成本率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    分保费用: float
+    营业税金及附加: float
+    手续费及佣金支出: float
+    业务及管理费: float
+    摊回分保费用: float
+    已赚保费: float
+    赔付支出: float
+    摊回赔付支出: float
+    提取保险责任准备金: float
+    摊回保险责任准备金: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = (p.分保费用 + p.营业税金及附加 + p.手续费及佣金支出 + p.业务及管理费 - p.摊回分保费用) / p.已赚保费 * 100
+        f = (p.赔付支出 - p.摊回赔付支出 + p.提取保险责任准备金 - p.摊回保险责任准备金) / p.已赚保费 * 100
+        result = d + f
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/综合费用率.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "综合费用率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    分保费用: float
+    营业税金及附加: float
+    手续费及佣金支出: float
+    业务及管理费: float
+    摊回分保费用: float
+    已赚保费: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.分保费用 + p.营业税金及附加 + p.手续费及佣金支出 + p.业务及管理费 - p.摊回分保费用
+        result = d / p.已赚保费 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/营业利润率.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "营业利润率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业利润: float
+    营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.营业利润 / p.营业收入 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/营业利润率_三年加权计算.py

@@ -0,0 +1,30 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "营业利润率_三年加权计算（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    当期营业利润: float
+    当期营业收入: float
+    上期营业利润: float
+    上期营业收入: float
+    上二期营业利润: float
+    上二期营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        ratio1 = p.当期营业利润 / p.当期营业收入 * 100
+        ratio2 = p.上期营业利润 / p.上期营业收入 * 100
+        ratio3 = p.上二期营业利润 / p.上二期营业收入 * 100
+        result = (ratio1 * 0.5 + ratio2 * 0.3 + ratio3 * 0.2) * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/盈利能力/费用收入比.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "费用收入比（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业成本: float
+    管理费用: float
+    营业收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = (p.营业成本 + p.管理费用) / p.营业收入 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/经济实力/__init__.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.经济实力 import 人均GDP_全国平均GDP
+
+router = APIRouter(tags=["经济实力"])
+
+router.include_router(人均GDP_全国平均GDP.router)

IndexCalculation/基本信用评级指标/经济实力/人均GDP_全国平均GDP.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "人均GDP/全国平均GDP（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    人均GDP: float
+    全国平均GDP: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.人均GDP / p.全国平均GDP
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/__init__.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.规模 import 供水及污水处理能力, 信托资产规模, 净资产, 原煤产量, 总资产, 营业收入, 通行费收入
+
+router = APIRouter(tags=["规模"])
+
+router.include_router(供水及污水处理能力.router)
+router.include_router(信托资产规模.router)
+router.include_router(净资产.router)
+router.include_router(原煤产量.router)
+router.include_router(总资产.router)
+router.include_router(营业收入.router)
+router.include_router(通行费收入.router)

IndexCalculation/基本信用评级指标/规模/供水及污水处理能力.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "供水及污水处理能力（万吨/日）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    供水及污水处理能力: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.供水及污水处理能力 / 10000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/信托资产规模.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "信托资产规模（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    信托资产规模: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.信托资产规模 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/净资产.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净资产（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净资产: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.净资产 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/净资本.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净资本（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净资本: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.净资本 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/原煤产量.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "原煤产量（万吨）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    原煤产量: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.原煤产量 / 10000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/总资产.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "总资产（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    总资产: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.总资产 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/营业收入.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "营业收入（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业收入: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.营业收入 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/规模/通行费收入.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "通行费（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    通行费收入: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.通行费收入 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/财务杠杆/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.财务杠杆 import 总债务资本化比率, 资产负债率, 剔除预收款后的资产负债率
+
+router = APIRouter(tags=["财务杠杆"])
+
+router.include_router(剔除预收款后的资产负债率.router)
+router.include_router(总债务资本化比率.router)
+router.include_router(资产负债率.router)

IndexCalculation/基本信用评级指标/财务杠杆/剔除预收款后的资产负债率.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "剔除预收款后的资产负债率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    负债合计: float
+    合同负债: float
+    资产总计: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.负债合计 - p.合同负债
+        d = p.资产总计 - p.合同负债
+        result = m / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/财务杠杆/总债务资本化比率.py

@@ -0,0 +1,35 @@
+"""
+总债务资本化比率（%）
+"""
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "总债务资本化比率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    短期借款: float
+    交易性金融负债: float
+    应付票据: float
+    一年内到期的非流动负债: float
+    其他短期有息债务: float
+    长期借款: float
+    应付债券: float
+    其他长期有息债务: float
+    所有者权益合计: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        m = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务
+        d = p.短期借款 + p.交易性金融负债 + p.应付票据 + p.一年内到期的非流动负债 + p.其他短期有息债务 + p.长期借款 + p.应付债券 + p.其他长期有息债务 + p.所有者权益合计
+        result = m / d * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/财务杠杆/资产负债率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "资产负债率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    负债合计: float
+    资产总计: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.负债合计 / p.资产总计 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/财政收支/__init__.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+from IndexCalculation.基本信用评级指标.财政收支 import 税收收入_一般预算收入, 财政平衡率, 一般预算收入
+
+router = APIRouter(tags=["财政收支"])
+
+router.include_router(税收收入_一般预算收入.router)
+router.include_router(财政平衡率.router)
+router.include_router(一般预算收入.router)

IndexCalculation/基本信用评级指标/财政收支/一般预算收入.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "一般预算收入（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    一般预算收入: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.一般预算收入 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/财政收支/税收收入_一般预算收入.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "税收收入/一般预算收入（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    税收收入: float
+    一般预算收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.税收收入 / p.一般预算收入
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/财政收支/财政平衡率.py

@@ -0,0 +1,27 @@
+"""
+财政平衡率（%）
+"""
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "财政平衡率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    一般预算支出: float
+    一般预算收入: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.一般预算收入 / p.一般预算支出 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资产质量/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.资产质量 import 固有资产不良率, 租赁资产不良率
+
+router = APIRouter(tags=["资产质量"])
+
+router.include_router(固有资产不良率.router)
+router.include_router(租赁资产不良率.router)
+

IndexCalculation/基本信用评级指标/资产质量/固有资产不良率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "固有资产不良率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    固有不良资产: float
+    信用风险资产合计: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.固有不良资产 / p.信用风险资产合计 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资产质量/租赁资产不良率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "租赁资产不良率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    不良融资租赁资产余额: float
+    应收融资租赁资产余额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.不良融资租赁资产余额 / p.应收融资租赁资产余额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本充足性/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.资本充足性 import 净资本, 资本杠杆率, 风险覆盖率
+
+router = APIRouter(tags=["资本充足性"])
+
+router.include_router(净资本.router)
+router.include_router(资本杠杆率.router)
+router.include_router(风险覆盖率.router)
+

IndexCalculation/基本信用评级指标/资本充足性/净资本.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净资本（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净资本: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.净资本 / 100000000
+        return round(result, 2)
+
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本充足性/资本杠杆率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "资本杠杆率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    核心净资本: float
+    表内外资产总额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.核心净资本 / p.表内外资产总额 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本充足性/风险覆盖率.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "风险覆盖率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净资本: float
+    各项风险资本准备之和: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.净资本 / p.各项风险资本准备之和 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本结构/__init__.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.资本结构 import 所有者权益, 实收资本
+
+router = APIRouter(tags=["资本结构"])
+
+router.include_router(所有者权益.router)
+router.include_router(实收资本.router)

IndexCalculation/基本信用评级指标/资本结构/实收资本.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "实收资本（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    实收资本: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.实收资本 / 100000000
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本结构/所有者权益.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+
+INDEX = "所有者权益（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    所有者权益: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.所有者权益 / 100000000
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本要求/__init__.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.资本要求 import 净资本_各项风险资本之和, 净资本规模
+
+router = APIRouter(tags=["资本要求"])
+
+router.include_router(净资本_各项风险资本之和.router)
+router.include_router(净资本规模.router)

IndexCalculation/基本信用评级指标/资本要求/净资本_各项风险资本之和.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净资本/各项风险资本之和（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净资本: float
+    各项风险资本准备之和: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.净资本 / p.各项风险资本准备之和 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/资本要求/净资本规模.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "净资本规模（亿元）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    净资本: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.净资本 / 100000000
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/运营效率/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.运营效率 import 存货周转率, 应收账款周转率, 期间费用率, 经调整的存货周转率
+
+router = APIRouter(tags=["运营效率"])
+
+router.include_router(存货周转率.router)
+router.include_router(应收账款周转率.router)
+router.include_router(期间费用率.router)
+router.include_router(经调整的存货周转率.router)

IndexCalculation/基本信用评级指标/运营效率/存货周转率.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "存货周转率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业成本: float
+    期初存货: float
+    期末存货: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.营业成本 / (p.期初存货 + p.期末存货) * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/运营效率/应收账款周转率.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "应收账款周转率（次）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    营业收入: float
+    期初应收账款: float
+    期末应收账款: float
+    期初应收票据: float
+    期末应收票据: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = (p.期初应收账款 + p.期末应收账款) / 2
+        m = (p.期初应收票据 + p.期末应收票据) / 2
+        result = p.营业收入 / (d + m) * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/运营效率/期间费用率.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "期间费用率（%）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    财务费用: float
+    管理费用: float
+    销售费用: float
+    营业收入: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        d = p.财务费用 + p.管理费用 + p.销售费用
+        result = d / p.营业收入 * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/运营效率/经调整的存货周转率.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "经调整的存货周转率（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    销售商品提供劳务收到的现金: float
+    存货: float
+    合同负债: float
+
+
+# 计算接口
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.销售商品提供劳务收到的现金 / (p.存货 - p.合同负债) * 100
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"

IndexCalculation/基本信用评级指标/风险抵御能力/__init__.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+from IndexCalculation.基本信用评级指标.风险抵御能力 import 融资性担保放大倍数, 两项准备金余额_应收代偿款净额
+
+router = APIRouter(tags=["风险抵御能力"])
+
+router.include_router(融资性担保放大倍数.router)
+router.include_router(两项准备金余额_应收代偿款净额.router)

IndexCalculation/基本信用评级指标/风险抵御能力/两项准备金余额_应收代偿款净额.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+INDEX = "（两项）准备金余额/应收代偿款净额（倍）"
+
+router = APIRouter()
+
+
+class Params(BaseModel):
+    准备金余额: float
+    应收代偿款净额: float
+
+
+@router.post("/{}".format(INDEX))
+def func(p: Params):
+    try:
+        result = p.准备金余额 / p.应收代偿款净额
+        return round(result, 2)
+
+    except ZeroDivisionError:
+        return "算式无意义"
+    except Exception:
+        return "计算错误"