update

.gitignore

@@ -0,0 +1,2 @@
+.token
+__pycache__

app.py

@@ -1,42 +1,53 @@
-from typing import Any
+from typing import Final
 
-import gradio as gr
+import gradio as gr  # type: ignore
 
-from utils import get_calculated_df, get_info, text2oddslist
+import src.func as func
 
-DEFAULT_AMOUNT = 5000
+DEFAULT_AMOUNT: Final[int] = 10_000
 
 
-def calculate(_amount: Any, _text: Any) -> tuple[str, dict]:
-    amount = int(_amount) or DEFAULT_AMOUNT
+def clear(text: str) -> str:
+    return func.clear(text)
 
-    df = get_calculated_df(amount, text2oddslist(str(_text)))
-    info = get_info(df)
 
-    # dfの整形
-    display_cols = ["odds", "buy", "refound"]
-    if df["name"].map(lambda name: name != "").any():
-        display_cols = ["name"] + display_cols
+def calculate(budget: int, text: str) -> tuple[str, list[list]]:
+    try:
+        return func.calculate(budget, text)
+    except Exception as e:
+        raise gr.Error(e)
 
-    # markdownの整形
-    md_string = (
-        f"**購入額:** ¥ **{info['sum']:,}**<br>"
-        f"**点数:** **{info['num_kind']}** 点<br>"
-        f"**払戻:** ¥ **{info['refound_mean']:,}** (**{info['profit_mean']:+,}** (**{info['rate_min']:+.0%}**))<br>"
-        "---"
-    )
 
-    return md_string, df[["index"] + display_cols]
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            budget_input = gr.Number(value=DEFAULT_AMOUNT, label="予算")
+            text_input = gr.Textbox(label="netkeiba 買い目コピペ")
+            with gr.Row():
+                calculate_button = gr.Button(value="Calculate", variant="primary")
+                clear_button = gr.Button(value="Clear")
 
+        with gr.Column():
+            markdown_output = gr.Markdown()
+            df_output = gr.Dataframe(
+                value=[],
+                label=None,
+                headers=["", "", "オッズ", "賭け額", "払戻"],
+                datatype=["str", "str", "number", "number", "number"],
+                col_count=(5, "fixed"),
+            )
 
-amount_input = gr.Number(value=DEFAULT_AMOUNT, label="amount")
-text_input = gr.Textbox(label="text")
-markdown_output = gr.Markdown()
-df_output = gr.Dataframe(type="pandas")
-iface = gr.Interface(
-    fn=calculate,
-    inputs=[amount_input, text_input],
-    outputs=[markdown_output, df_output],
-)
+    # click
+    calculate_button.click(
+        calculate,
+        inputs=[budget_input, text_input],
+        outputs=[markdown_output, df_output],
+    )
+    clear_button.click(
+        clear,
+        inputs=[text_input],
+        outputs=[text_input],
+    )
 
-iface.launch()
+if "__main__" == __name__:
+    demo.launch(debug=True)

archive/app.py

@@ -0,0 +1,42 @@
+from typing import Any
+
+import gradio as gr
+
+from archive.utils import get_calculated_df, get_info, text2oddslist
+
+DEFAULT_AMOUNT = 5000
+
+
+def calculate(_amount: Any, _text: Any) -> tuple[str, dict]:
+    amount = int(_amount) or DEFAULT_AMOUNT
+
+    df = get_calculated_df(amount, text2oddslist(str(_text)))
+    info = get_info(df)
+
+    # dfの整形
+    display_cols = ["odds", "buy", "refound"]
+    if df["name"].map(lambda name: name != "").any():
+        display_cols = ["name"] + display_cols
+
+    # markdownの整形
+    md_string = (
+        f"**購入額:** ¥ **{info['sum']:,}**<br>"
+        f"**点数:** **{info['num_kind']}** 点<br>"
+        f"**払戻:** ¥ **{info['refound_mean']:,}** (**{info['profit_mean']:+,}** (**{info['rate_min']:+.0%}**))<br>"
+        "---"
+    )
+
+    return md_string, df[["index"] + display_cols]
+
+
+amount_input = gr.Number(value=DEFAULT_AMOUNT, label="amount")
+text_input = gr.Textbox(label="text")
+markdown_output = gr.Markdown()
+df_output = gr.Dataframe(type="pandas")
+iface = gr.Interface(
+    fn=calculate,
+    inputs=[amount_input, text_input],
+    outputs=[markdown_output, df_output],
+)
+
+iface.launch()

app_gradio.py → archive/app_gradio.py

@@ -1,7 +1,9 @@
 import gradio as gr
-from utils import get_calculated_df, get_info, text2oddslist
+from archive.utils import get_calculated_df, get_info, text2oddslist
 
 DEFAULT_AMOUNT = 5000
+
+
 def calculate(amount, text):
     amount = amount or DEFAULT_AMOUNT
     odds_list = text2oddslist(text)

app_streamlit.py → archive/app_streamlit.py

@@ -1,5 +1,6 @@
 import streamlit as st
-from utils import get_calculated_df, get_info, text2oddslist
+
+from archive.utils import get_calculated_df, get_info, text2oddslist
 
 amount: int = int(st.number_input("amount", min_value=100, value=3000, step=100))
 text: str = st.text_area("text", "")

kculculate.code-workspace

@@ -0,0 +1,63 @@
+{
+  "folders": [
+    {
+      "name": "kculculate",
+      "path": "."
+    }
+  ],
+  "settings": {
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit",
+      "source.fixAll.stylelint": "explicit"
+    },
+    "editor.formatOnSave": true,
+    "editor.formatOnPaste": true,
+    "editor.formatOnType": true,
+    "json.format.keepLines": true,
+    "[javascript]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[typescript]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[typescriptreact]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[css]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    },
+    "[json]": {
+      "editor.defaultFormatter": "vscode.json-language-features"
+    },
+    "search.exclude": {
+      "**/node_modules": true,
+      "static": true
+    },
+    "[python]": {
+      "editor.defaultFormatter": "ms-python.black-formatter",
+      "editor.codeActionsOnSave": {
+        "source.organizeImports": "explicit"
+      }
+    },
+    "flake8.args": [
+      "--max-line-length=119",
+      "--max-complexity=15",
+      "--ignore=E203,E501,E704,W503",
+      "--exclude=.venv,.git,__pycache__,.mypy_cache,.hg"
+    ],
+    "isort.args": ["--settings-path=pyproject.toml"],
+    "black-formatter.args": ["--config=pyproject.toml"],
+    "mypy-type-checker.args": ["--config-file=pyproject.toml"],
+    "python.analysis.extraPaths": ["./backend"]
+  },
+  "extensions": {
+    "recommendations": [
+      "esbenp.prettier-vscode",
+      "dbaeumer.vscode-eslint",
+      "ms-python.flake8",
+      "ms-python.isort",
+      "ms-python.black-formatter",
+      "ms-python.mypy-type-checker"
+    ]
+  }
+}

makefile

@@ -0,0 +1,7 @@
+.PHONY: lint
+lint: ## run tests with poetry (isort, black, pflake8, mypy)
+	poetry run black src
+	poetry run isort src
+	poetry run pflake8 src
+	poetry run mypy src --explicit-package-bases
+

pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "kculculate"
+version = "0.1.0"
+description = ""
+authors = ["neoai-kterasawa <[email protected]>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+gradio = "^4.39.0"
+pydantic = "^2.8.2"
+
+[tool.poetry.group.dev.dependencies]
+isort = "^5.13.2"
+black = "^24.4.2"
+mypy = "^1.11.0"
+pyproject-flake8 = "^7.0.0"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -1,3 +1,2 @@
-pandas==2.1.0
-streamlit==1.26.0
-gradio==3.44.3
+gradio == "4.39.0"
+pydantic == "2.8.2"

src/func.py

@@ -0,0 +1,19 @@
+from typing import Final
+
+from src.model.odds import Choices
+
+DEFAULT_AMOUNT: Final[int] = 10_000
+
+
+def calculate(budget: int, raw_text: str) -> tuple[str, list[list]]:
+    choices = Choices.from_text(raw_text)
+    choices_with_bet = choices.to_choices_with_bet(budget)
+
+    summary_markdown = choices_with_bet.to_summary_markdwown()
+    table = choices_with_bet.to_table()
+
+    return summary_markdown, table
+
+
+def clear(text: str) -> str:
+    return ""

src/model/odds.py

@@ -0,0 +1,161 @@
+import re
+
+from pydantic import (
+    BaseModel,
+    RootModel,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+    computed_field,
+    field_validator,
+)
+
+
+class Choice(BaseModel):
+    number: StrictStr
+    name: StrictStr
+    odds: StrictFloat
+
+
+class ChoiceWithBet(Choice):
+    bet_amount: StrictInt
+
+    @computed_field  # type: ignore
+    @property
+    def pay_back(self) -> int:
+        return int(self.bet_amount * self.odds)
+
+    @computed_field  # type: ignore
+    @property
+    def profit(self) -> int:
+        return self.pay_back - self.bet_amount
+
+
+class Choices(RootModel[list[Choice]]):
+    root: list[Choice]
+
+    @field_validator("root")
+    @classmethod
+    def ensure_at_least_one_choice(cls, choices: list[Choice]) -> list[Choice]:
+        if len(choices) == 0:
+            raise ValueError("買い目が1つもありません")
+        return choices
+
+    def to_choices_with_bet(self, budget: int) -> "ChoicesWithBet":
+        inverse_ratios_sum = sum(1 / choice.odds for choice in self.root)
+
+        # 重み計算
+        choice_with_bet_list: list[ChoiceWithBet] = []
+        for chice in self.root:
+            weight = (1 / chice.odds) / inverse_ratios_sum
+            # 逆比
+            choice_with_bet_list.append(
+                ChoiceWithBet(
+                    number=chice.number,
+                    name=chice.name,
+                    odds=chice.odds,
+                    bet_amount=max(int(weight * budget / 100) * 100, 100),
+                )
+            )
+
+        return ChoicesWithBet(root=choice_with_bet_list)
+
+    @classmethod
+    def from_text(cls, text: str) -> "Choices":
+        lines = text.split("\n")
+        for strat_key in ("選択", "オッズ", "組み合わせ", "オッズを見て個別選択"):
+            if strat_key in lines:
+                lines = lines[lines.index(strat_key) + 1 :]
+        text = "\n".join(lines)
+        # pcの時
+        is_pc = re.match(r"[\d\n]+", text)
+        if is_pc:
+            return cls._from_text_from_pc(text)
+        # moduleの時
+        return cls._from_text_from_mobile(text)
+
+    @classmethod
+    def _from_text_from_pc(cls, text: str) -> "Choices":
+        choices_list: list[Choice] = []
+        tmp_list: list[str] = []
+        lines: list[str] = text.split("\n")
+        for line in lines:
+            is_odds = "." in line
+            if is_odds:
+                choices_list.append(
+                    Choice(
+                        number="-".join(tmp_list),
+                        name="",
+                        odds=float(line),
+                    )
+                )
+                tmp_list = []
+            else:
+                if line.strip():
+                    tmp_list.append(line.strip())
+        return cls(root=choices_list)
+
+    @classmethod
+    def _from_text_from_mobile(cls, text: str) -> "Choices":
+        choice_list: list[Choice] = []
+        lines: list[str] = text.split("\n")
+        for strat_key in ("選択", "オッズ", "組み合わせ", "オッズを見て個別選択"):
+            if strat_key in lines:
+                lines = lines[lines.index(strat_key) + 1 :]
+        if "すべてを選択" in lines:
+            lines = lines[: lines.index("すべてを選択")]
+        for i in range(len(lines) // 3):
+            # oddsが1つ目にある
+            if "." in lines[3 * i + 1]:
+                idx_odds = 1
+                idx_name = 2
+            else:
+                idx_odds = 2
+                idx_name = 1
+
+            choice_list.append(
+                Choice(
+                    number="-".join(lines[3 * i].split()),
+                    name="-".join(lines[3 * i + idx_name].split()),
+                    odds=float(lines[3 * i + idx_odds]),
+                )
+            )
+        return cls(root=choice_list)
+
+
+class ChoicesWithBet(RootModel[list[ChoiceWithBet]]):
+    root: list[ChoiceWithBet]
+
+    def to_summary_markdwown(self) -> str:
+        return (
+            f"**点数**: {len(self.root)} 点<br>"
+            f"**購入額**: ¥ {self.total_bet_amount:,}<br>"
+            f"**回収率**: {self.average_pay_back / self.total_bet_amount:.0%}"
+        )
+
+    def to_table(self) -> list[list]:
+        return [
+            [
+                choice.number,
+                choice.name,
+                choice.odds,
+                choice.bet_amount,
+                choice.pay_back,
+            ]
+            for choice in self.root
+        ]
+
+    @computed_field  # type: ignore
+    @property
+    def total_bet_amount(self) -> int:
+        return sum(choice.bet_amount for choice in self.root)
+
+    @computed_field  # type: ignore
+    @property
+    def average_pay_back(self) -> float:
+        return sum(choice.pay_back for choice in self.root) / len(self.root)
+
+    @computed_field  # type: ignore  # type: ignore
+    @property
+    def average_profit(self) -> float:
+        return sum(choice.profit for choice in self.root) / len(self.root)