bullishpy 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

bullish/app/app.py

@@ -1,7 +1,7 @@
 import shelve
 import uuid
 from pathlib import Path
-from typing import Optional
+from typing import Optional, List, Type, Dict, Any
 
 import pandas as pd
 import streamlit as st
@@ -11,6 +11,7 @@ from bearish.models.price.prices import Prices  # type: ignore
 from bearish.models.query.query import AssetQuery, Symbols  # type: ignore
 from streamlit_file_browser import st_file_browser  # type: ignore
 
+from bullish.analysis.predefined_filters import PredefinedFilters
 from bullish.database.crud import BullishDb
 from bullish.figures.figures import plot
 from bullish.analysis.filter import (
@@ -18,9 +19,20 @@ from bullish.analysis.filter import (
     FilterUpdate,
     FilteredResults,
     FilterQueryStored,
+    FundamentalAnalysisFilters,
+    GROUP_MAPPING,
+    GeneralFilter,
+    TechnicalAnalysisFilters,
 )
 from bullish.jobs.models import JobTracker
-from bullish.jobs.tasks import update, news
+from bullish.jobs.tasks import update, news, analysis
+from pydantic import BaseModel
+
+from bullish.utils.checks import (
+    compatible_bearish_database,
+    compatible_bullish_database,
+    empty_analysis_table,
+)
 
 CACHE_SHELVE = "user_cache"
 DB_KEY = "db_path"
@@ -88,15 +100,151 @@ def dialog_pick_database() -> None:
     if event:
         db_path = Path(current_working_directory).joinpath(event["target"]["path"])
         if not (db_path.exists() and db_path.is_file()):
-            st.error("Please choose a valid file.")
+            st.stop()
+        if not compatible_bearish_database(db_path):
+            st.error(f"The database {db_path} is not compatible with this application.")
             st.stop()
         st.session_state.database_path = db_path
         store_db(db_path)
+        compatible_bullish_db = compatible_bullish_database(db_path)
+        if (not compatible_bullish_db) or (
+            compatible_bullish_db and empty_analysis_table(db_path)
+        ):
+            st.warning(
+                f"The database {db_path} has not the necessary data to run this application. "
+                "A backround job will be started to update the data."
+            )
+            analysis(db_path)
         st.rerun()
     if event is None:
         st.stop()
 
 
+@st.cache_resource
+def symbols() -> List[str]:
+    bearish_db_ = bearish_db(st.session_state.database_path)
+    return bearish_db_.read_symbols()
+
+
+def groups_mapping() -> Dict[str, List[str]]:
+    GROUP_MAPPING["symbol"] = symbols()
+    return GROUP_MAPPING
+
+
+def build_filter(model: Type[BaseModel], data: Dict[str, Any]) -> Dict[str, Any]:
+
+    for field, info in model.model_fields.items():
+        name = info.description or info.alias or field
+        default = info.default
+        if data.get(field) and data[field] != info.default:
+            default = data[field]
+        if info.annotation == Optional[List[str]]:  # type: ignore
+            data[field] = st.multiselect(
+                name,
+                groups_mapping()[field],
+                default=default,
+                key=hash((model.__name__, field)),
+            )
+
+        else:
+            ge = next(
+                (item.ge for item in info.metadata if hasattr(item, "ge")),
+                info.default[0] if info.default and len(info.default) == 2 else None,
+            )
+            le = next(
+                (item.le for item in info.metadata if hasattr(item, "le")),
+                info.default[1] if info.default and len(info.default) == 2 else None,
+            )
+            data[field] = list(
+                st.slider(  # type: ignore
+                    name, ge, le, tuple(default), key=hash((model.__name__, field))
+                )
+            )
+    return data
+
+
+@st.dialog("⏳  Jobs", width="large")
+def jobs() -> None:
+    with st.expander("Update data"):
+        bearish_db_ = bearish_db(st.session_state.database_path)
+        update_query = sp.pydantic_form(key="update", model=FilterUpdate)
+        if (
+            update_query
+            and st.session_state.data is not None
+            and not st.session_state.data.empty
+        ):
+            symbols = st.session_state.data["symbol"].unique().tolist()
+            res = update(
+                database_path=st.session_state.database_path,
+                symbols=symbols,
+                update_query=update_query,
+            )  # enqueue & get result-handle
+            bearish_db_.write_job_tracker(
+                JobTracker(job_id=str(res.id), type="Update data")
+            )
+            st.success("Data update job has been enqueued.")
+            st.rerun()
+    with st.expander("Update analysis"):
+        if st.button("Update analysis"):
+            analysis(st.session_state.database_path)
+
+
+@st.dialog("📥  Load", width="large")
+def load() -> None:
+    bearish_db_ = bearish_db(st.session_state.database_path)
+    existing_filtered_results = bearish_db_.read_list_filtered_results()
+    option = st.selectbox("Select portfolio", ["", *existing_filtered_results])
+    if option:
+        filtered_results_ = bearish_db_.read_filtered_results(option)
+        if filtered_results_:
+            st.session_state.data = bearish_db_.read_analysis_data(
+                symbols=filtered_results_.symbols
+            )
+            st.rerun()
+
+
+@st.dialog("🔍  Filter", width="large")
+def filter() -> None:
+    with st.container():
+        column_1, column_2 = st.columns(2)
+        with column_1:
+            # TODO: order here matters
+            with st.expander("Predefined filters"):
+                predefined_filter_names = (
+                    PredefinedFilters().get_predefined_filter_names()
+                )
+                option = st.selectbox(
+                    "Select a predefined filter",
+                    ["", *predefined_filter_names],
+                )
+                if option:
+                    data_ = PredefinedFilters().get_predefined_filter(option)
+                    st.session_state.filter_query.update(data_)
+            with st.expander("Technical Analysis"):
+                for filter in TechnicalAnalysisFilters:
+                    with st.expander(filter._description):  # type: ignore
+                        build_filter(filter, st.session_state.filter_query)
+
+        with column_2:
+            with st.expander("Fundamental Analysis"):
+                for filter in FundamentalAnalysisFilters:
+                    with st.expander(filter._description):  # type: ignore
+                        build_filter(filter, st.session_state.filter_query)
+            with st.expander("General filter"):
+                build_filter(GeneralFilter, st.session_state.filter_query)
+
+    if st.button("🔍 Apply"):
+        query = FilterQuery.model_validate(st.session_state.filter_query)
+        if query.valid():
+            st.session_state.data = bearish_db(
+                st.session_state.database_path
+            ).read_filter_query(query)
+            st.session_state.ticker_figure = None
+            st.session_state.filter_query = {}
+            st.session_state.query = query
+            st.rerun()
+
+
 @st.dialog("📈  Price history and analysis", width="large")
 def dialog_plot_figure() -> None:
     st.markdown(
@@ -104,7 +252,7 @@ def dialog_plot_figure() -> None:
     <style>
     div[data-testid="stDialog"] div[role="dialog"]:has(.big-dialog) {
         width: 90vw;
-        height: 110vh;
+        height: 170vh;
     }
     </style>
     """,
@@ -115,97 +263,101 @@ def dialog_plot_figure() -> None:
     st.session_state.ticker_figure = None
 
 
-def main() -> None:  # noqa: PLR0915, C901
+@st.dialog("⭐ Save filtered results")
+def save_filtered_results(bearish_db_: BullishDb) -> None:
+    user_input = st.text_input("Selection name").strip()
+    headless = st.checkbox("Headless mode", value=True)
+    apply = st.button("Apply")
+    if apply:
+        if not user_input:
+            st.error("This field is required.")
+        else:
+            symbols = st.session_state.data["symbol"].unique().tolist()
+            filtered_results = FilteredResults(
+                name=user_input,
+                filter_query=FilterQueryStored.model_validate(
+                    st.session_state.query.model_dump(
+                        exclude_unset=True, exclude_defaults=True
+                    )
+                ),
+                symbols=symbols,
+            )
+
+            bearish_db_.write_filtered_results(filtered_results)
+            res = news(
+                database_path=st.session_state.database_path,
+                symbols=symbols,
+                headless=headless,
+            )
+            bearish_db_.write_job_tracker(
+                JobTracker(job_id=str(res.id), type="Fetching news")
+            )
+            st.session_state.filter_query = None
+            st.session_state.query = None
+            st.rerun()
+
+
+def main() -> None:
+    hide_elements = """
+            <style>
+                div[data-testid="stSliderTickBarMin"],
+                div[data-testid="stSliderTickBarMax"] {
+                    display: none;
+                }
+            </style>
+    """
+
+    st.markdown(hide_elements, unsafe_allow_html=True)
     assign_db_state()
+
     if st.session_state.database_path is None:
         dialog_pick_database()
     bearish_db_ = bearish_db(st.session_state.database_path)
     charts_tab, jobs_tab = st.tabs(["Charts", "Jobs"])
     if "data" not in st.session_state:
         st.session_state.data = load_analysis_data(bearish_db_)
-    with st.sidebar:
-        with st.expander("Filter"):
-            view_query = sp.pydantic_form(key="my_form", model=FilterQuery)
-            if view_query:
-                st.session_state.data = bearish_db_.read_filter_query(view_query)
-                st.session_state.ticker_figure = None
-                st.session_state.filter_query = view_query
-            with st.container(border=True):
-                disabled = "filter_query" not in st.session_state
-                if "filter_query" in st.session_state:
-                    disabled = st.session_state.filter_query is None
-                user_input = st.text_input("Enter your name:", disabled=disabled)
-                headless = st.checkbox("Headless mode", value=True, disabled=disabled)
-                if st.button("Save", disabled=disabled):
-                    name = user_input.strip()
-                    if not name:
-                        st.error("This field is required.")
-                    else:
-                        symbols = st.session_state.data["symbol"].unique().tolist()
-                        filtered_results = FilteredResults(
-                            name=name,
-                            filter_query=FilterQueryStored.model_validate(
-                                st.session_state.filter_query.model_dump()
-                            ),
-                            symbols=symbols,
-                        )
-
-                        bearish_db_.write_filtered_results(filtered_results)
-                        res = news(
-                            database_path=st.session_state.database_path,
-                            symbols=symbols,
-                            headless=headless,
-                        )
-                        bearish_db_.write_job_tracker(
-                            JobTracker(job_id=str(res.id), type="Fetching news")
-                        )
-                        st.session_state.filter_query = None
-                        st.success(f"Hello, {user_input}!")
-        with st.expander("Load"):
-            existing_filtered_results = bearish_db_.read_list_filtered_results()
-            option = st.selectbox("Saved results", ["", *existing_filtered_results])
-            if option:
-                filtered_results_ = bearish_db_.read_filtered_results(option)
-                if filtered_results_:
-                    st.session_state.data = bearish_db_.read_analysis_data(
-                        symbols=filtered_results_.symbols
-                    )
 
-        with st.expander("Update"):
-            update_query = sp.pydantic_form(key="update", model=FilterUpdate)
+    with charts_tab:
+        with st.container():
+            columns = st.columns(12)
+            with columns[0]:
+                if st.button(" 🔍 ", use_container_width=True):
+                    st.session_state.filter_query = {}
+                    filter()
+            with columns[1]:
+                if (
+                    "query" in st.session_state
+                    and st.session_state.query is not None
+                    and st.session_state.query.valid()
+                ):
+                    favorite = st.button(" ⭐ ", use_container_width=True)
+                    if favorite:
+                        save_filtered_results(bearish_db_)
+            with columns[-1]:
+                if st.button(" 📥 ", use_container_width=True):
+                    load()
+
+        with st.container():
+            st.dataframe(
+                st.session_state.data,
+                on_select=on_table_select,
+                selection_mode="single-row",
+                key="selected_data",
+                use_container_width=True,
+                height=600,
+            )
             if (
-                update_query
-                and st.session_state.data is not None
-                and not st.session_state.data.empty
+                "ticker_figure" in st.session_state
+                and st.session_state.ticker_figure is not None
             ):
-                symbols = st.session_state.data["symbol"].unique().tolist()
-                res = update(
-                    database_path=st.session_state.database_path,
-                    symbols=symbols,
-                    update_query=update_query,
-                )  # enqueue & get result-handle
-                bearish_db_.write_job_tracker(
-                    JobTracker(job_id=str(res.id), type="Update data")
-                )
-                st.success("Data update job has been enqueued.")
-                st.rerun()
-    with charts_tab:
-        st.header("✅ Data overview")
-        st.dataframe(
-            st.session_state.data,
-            on_select=on_table_select,
-            selection_mode="single-row",
-            key="selected_data",
-            use_container_width=True,
-            height=600,
-        )
-        if (
-            "ticker_figure" in st.session_state
-            and st.session_state.ticker_figure is not None
-        ):
-            dialog_plot_figure()
+                dialog_plot_figure()
 
     with jobs_tab:
+        columns = st.columns(12)
+        with columns[0]:
+            if st.button(" ⏳ ", use_container_width=True):
+                jobs()
+
         job_trackers = bearish_db_.read_job_trackers()
         st.dataframe(
             job_trackers,

bullish/cli.py

@@ -64,7 +64,9 @@ def serve(
             time.sleep(1)
 
     except Exception as exc:  # pragma: no cover
-        typer.secho(f"❌ Failed to start services: {exc}", fg=typer.colors.RED, err=True)
+        typer.secho(
+            f"❌ Failed to start services: {exc}", fg=typer.colors.RED, err=True
+        )
         _shutdown()
 
 

bullish/database/alembic/versions/037dbd721317_.py

@@ -5,6 +5,7 @@ Revises:
 Create Date: 2025-06-14 16:50:56.919222
 
 """
+
 from typing import Sequence, Union
 
 import sqlalchemy as sa