bullishpy 0.49.0__tar.gz → 0.51.0__tar.gz

{bullishpy-0.49.0 → bullishpy-0.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.49.0
+Version: 0.51.0
 Summary: 
 Author: aan
 Author-email: andoludovic.andriamamonjy@gmail.com

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/analysis/analysis.py

@@ -530,8 +530,10 @@ class SubjectAnalysis(BaseModel):
 
     def compute_upside(self, last_price: float) -> None:
         if self.high_price_target is not None:
-            self.upside = (float(self.high_price_target) - float(last_price)) / float(
-                last_price
+            self.upside = (
+                (float(self.high_price_target) - float(last_price))
+                * 100
+                / float(last_price)
             )
 
     def to_news(self) -> Optional[str]:

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/analysis/indicators.py

@@ -359,6 +359,15 @@ def indicators_factory() -> List[Indicator]:
                     in_use_backtest=True,
                     processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
+                Signal(
+                    name="SMA_50_BELOW_SMA_200",
+                    description="SMA 50 is below SMA 200",
+                    type_info="Overbought",
+                    type=Optional[date],
+                    function=lambda d: d.SMA_50 < d.SMA_200,
+                    in_use_backtest=True,
+                    processing=ProcessingFunction(date=find_last_true_run_start),
+                ),
                 Signal(
                     name="PRICE_ABOVE_SMA_50",
                     description="Price is above SMA 50",
@@ -368,6 +377,15 @@ def indicators_factory() -> List[Indicator]:
                     in_use_backtest=True,
                     processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
+                Signal(
+                    name="PRICE_BELOW_SMA_50",
+                    description="Price is below SMA 50",
+                    type_info="Overbought",
+                    type=Optional[date],
+                    function=lambda d: d.SMA_50 > d.CLOSE,
+                    in_use_backtest=True,
+                    processing=ProcessingFunction(date=find_last_true_run_start),
+                ),
             ],
         ),
         Indicator(

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/analysis/predefined_filters.py

@@ -119,10 +119,99 @@ class NamedFilterQuery(FilterQuery):
             | {"name": f"{self.name} ({suffix})", rsi_parameter_name: DATE_THRESHOLD}
         )
 
+    def _custom_variant(
+        self, suffix: str, properties: Dict[str, Any]
+    ) -> "NamedFilterQuery":
+        return NamedFilterQuery.model_validate(
+            self.model_dump() | {"name": f"{self.name} ({suffix})", **properties}
+        )
+
+    def top_performers(self) -> "NamedFilterQuery":
+        properties = {
+            "volume_above_average": DATE_THRESHOLD,
+            "sma_50_above_sma_200": [
+                datetime.date.today() - datetime.timedelta(days=5000),
+                datetime.date.today(),
+            ],
+            "weekly_growth": [1, 100],
+            "monthly_growth": [8, 100],
+        }
+        return self._custom_variant("Top Performers", properties)
+
+    def poor_performers(self) -> "NamedFilterQuery":
+        properties = {
+            "sma_50_below_sma_200": [
+                datetime.date.today() - datetime.timedelta(days=5000),
+                datetime.date.today(),
+            ],
+            "price_below_sma_50": [
+                datetime.date.today() - datetime.timedelta(days=5000),
+                datetime.date.today(),
+            ],
+            "monthly_growth": [-100, 0],
+        }
+        return self._custom_variant("Poor Performers", properties)
+
+    def short_term_profitability(self) -> "NamedFilterQuery":
+        properties = {
+            "income": [
+                "positive_operating_income",
+                "positive_net_income",
+                "quarterly_positive_operating_income",
+                "quarterly_positive_net_income",
+            ],
+            "cash_flow": [
+                "positive_free_cash_flow",
+                "quarterly_positive_free_cash_flow",
+            ],
+            "eps": [
+                "positive_basic_eps",
+                "positive_diluted_eps",
+                "quarterly_positive_basic_eps",
+                "quarterly_positive_diluted_eps",
+            ],
+            "properties": [
+                "positive_return_on_assets",
+                "positive_return_on_equity",
+                "positive_debt_to_equity",
+                "operating_cash_flow_is_higher_than_net_income",
+                "quarterly_positive_return_on_assets",
+                "quarterly_positive_return_on_equity",
+                "quarterly_positive_debt_to_equity",
+                "quarterly_operating_cash_flow_is_higher_than_net_income",
+            ],
+        }
+        return self._custom_variant("Short-term profitability", properties)
+
+    def long_term_profitability(self) -> "NamedFilterQuery":
+        properties = {
+            "income": [
+                "growing_net_income",
+                "growing_operating_income",
+                "quarterly_growing_net_income",
+                "quarterly_growing_operating_income",
+            ],
+            "cash_flow": [
+                "growing_operating_cash_flow",
+                "quarterly_growing_operating_cash_flow",
+            ],
+            "eps": [
+                "growing_basic_eps",
+                "growing_diluted_eps",
+                "quarterly_growing_basic_eps",
+                "quarterly_growing_diluted_eps",
+            ],
+        }
+        return self._custom_variant("Long-term profitability", properties)
+
     def variants(self) -> List["NamedFilterQuery"]:
-        return [
+        variants_ = [
             self.country_variant("Europe", list(get_args(Europe))),
             self.country_variant("Us", list(get_args(Us))),
+            self.country_variant("Europe", list(get_args(Europe))).top_performers(),
+            self.country_variant("Us", list(get_args(Us))).top_performers(),
+            self.country_variant("Europe", list(get_args(Europe))).poor_performers(),
+            self.country_variant("Us", list(get_args(Us))).poor_performers(),
             self.country_variant("Europe", list(get_args(Europe)))
             .update_indicator_filter("RSI 30", "rsi_bullish_crossover_30")
             .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
@@ -142,6 +231,17 @@ class NamedFilterQuery(FilterQuery):
             .update_indicator_filter("RSI Neutral", "rsi_neutral")
             .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
         ]
+        variants_short_term_profitability = [
+            v.short_term_profitability() for v in variants_
+        ]
+        variants_long_term_profitability = [
+            v.long_term_profitability() for v in variants_
+        ]
+        return [
+            *variants_,
+            *variants_short_term_profitability,
+            *variants_long_term_profitability,
+        ]
 
 
 def load_custom_filters() -> List[NamedFilterQuery]:
@@ -174,39 +274,16 @@ SMALL_CAP = NamedFilterQuery(
     order_by_desc="market_capitalization",
 ).variants()
 
-TOP_PERFORMERS = NamedFilterQuery(
-    name="Top Performers",
-    volume_above_average=DATE_THRESHOLD,
-    sma_50_above_sma_200=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today(),
-    ],
-    weekly_growth=[1, 100],
-    monthly_growth=[8, 100],
-    order_by_desc="market_capitalization",
-).variants()
-
-TOP_PERFORMERS_YEARLY = NamedFilterQuery(
-    name="Top Performers Yearly",
-    sma_50_above_sma_200=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today(),
-    ],
-    price_above_sma_50=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today(),
-    ],
-    volume_above_average=DATE_THRESHOLD,
-    weekly_growth=[1, 100],
-    monthly_growth=[8, 100],
-    yearly_growth=[30, 100],
+LARGE_CAPS = NamedFilterQuery(
+    name="Large caps",
     order_by_desc="market_capitalization",
+    market_capitalization=[1e10, 1e14],
 ).variants()
 
-LARGE_CAPS = NamedFilterQuery(
-    name="Large caps",
+MID_CAPS = NamedFilterQuery(
+    name="Mid-caps",
     order_by_desc="market_capitalization",
-    limit="50",
+    market_capitalization=[5e8, 1e10],
 ).variants()
 
 NEXT_EARNINGS_DATE = NamedFilterQuery(
@@ -222,10 +299,9 @@ NEXT_EARNINGS_DATE = NamedFilterQuery(
 def predefined_filters() -> list[NamedFilterQuery]:
     return [
         *SMALL_CAP,
-        *TOP_PERFORMERS,
-        *TOP_PERFORMERS_YEARLY,
         *LARGE_CAPS,
         *NEXT_EARNINGS_DATE,
+        *MID_CAPS,
         *load_custom_filters(),
     ]
 

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/app/app.py

@@ -27,14 +27,13 @@ from bullish.analysis.filter import (
     GeneralFilter,
     TechnicalAnalysisFilters,
 )
-from bullish.jobs.tasks import update, news, analysis
+from bullish.jobs.tasks import update, news, analysis, initialize
 from pydantic import BaseModel
 
 from bullish.utils.checks import (
     compatible_bearish_database,
     compatible_bullish_database,
     empty_analysis_table,
-    DataBaseSingleTon,
 )
 
 CACHE_SHELVE = "user_cache"
@@ -235,33 +234,28 @@ def load() -> None:
 
 @st.dialog("🔍  Filter", width="large")
 def filter() -> None:
+    with st.container(), 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.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)
+
+        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 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)
@@ -421,7 +415,10 @@ def main() -> None:
     if st.session_state.database_path is None:
         dialog_pick_database()
     bearish_db_ = bearish_db(st.session_state.database_path)
-    DataBaseSingleTon(path=st.session_state.database_path)
+    initialize(
+        database_path=st.session_state.database_path,
+        job_type="Initialize",
+    )
     charts_tab, jobs_tab = st.tabs(["Charts", "Jobs"])
     if "data" not in st.session_state:
         st.session_state.data = load_analysis_data(bearish_db_)

bullishpy-0.51.0/bullish/database/alembic/versions/260fcff7212e_.py

@@ -0,0 +1,45 @@
+"""
+
+Revision ID: 260fcff7212e
+Revises: 4ee82b171449
+Create Date: 2025-08-11 10:08:17.582390
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import sqlite
+
+# revision identifiers, used by Alembic.
+revision: str = "260fcff7212e"
+down_revision: Union[str, None] = "4ee82b171449"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("analysis", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("sma_50_below_sma_200", sa.Date(), nullable=True))
+        batch_op.add_column(sa.Column("price_below_sma_50", sa.Date(), nullable=True))
+        batch_op.create_index(
+            "ix_analysis_price_below_sma_50", ["price_below_sma_50"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_sma_50_below_sma_200", ["sma_50_below_sma_200"], unique=False
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("analysis", schema=None) as batch_op:
+        batch_op.drop_index("ix_analysis_sma_50_below_sma_200")
+        batch_op.drop_index("ix_analysis_price_below_sma_50")
+        batch_op.drop_column("price_below_sma_50")
+        batch_op.drop_column("sma_50_below_sma_200")
+
+    # ### end Alembic commands ###

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/jobs/models.py

@@ -4,7 +4,9 @@ from typing import Literal, get_args
 import pandas as pd
 from pydantic import BaseModel, Field
 
-JobType = Literal["Update data", "Update analysis", "Fetching news", "backtest signals"]
+JobType = Literal[
+    "Update data", "Update analysis", "Fetching news", "backtest signals", "Initialize"
+]
 JobStatus = Literal["Completed", "Failed", "Running", "Started"]
 StatusIcon = ["✅ Completed", "❌ Failed", "🔄 Running", "🚀 Started"]
 

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/jobs/tasks.py

@@ -18,11 +18,26 @@ from ..analysis.industry_views import compute_industry_view
 from ..analysis.predefined_filters import predefined_filters, load_custom_filters
 from ..database.crud import BullishDb
 from bullish.analysis.filter import FilterUpdate
-from ..utils.checks import DataBaseSingleTon
 
 logger = logging.getLogger(__name__)
 
 
+class DataBaseSingleTon:
+    _instance = None
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, path: Optional[Path] = None) -> None:
+        if not hasattr(self, "path"):  # Only set once
+            self.path = path
+
+    def valid(self) -> bool:
+        return hasattr(self, "path") and self.path is not None
+
+
 def job_tracker(func: Callable[..., Any]) -> Callable[..., Any]:
     @functools.wraps(func)
     def wrapper(
@@ -75,6 +90,18 @@ def _base_update(
     compute_industry_view(bullish_db)
 
 
+@huey.task(context=True)  # type: ignore
+@job_tracker
+def initialize(
+    database_path: Path,
+    job_type: JobType,
+    task: Optional[Task] = None,
+) -> None:
+    database = DataBaseSingleTon(path=database_path)
+    if not database.valid():
+        raise ValueError("Database path is not valid.")
+
+
 @huey.task(context=True)  # type: ignore
 @job_tracker
 def update(

{bullishpy-0.49.0 → bullishpy-0.51.0}/bullish/utils/checks.py

@@ -2,9 +2,10 @@ import sqlite3
 from contextlib import contextmanager
 from pathlib import Path
 from sqlite3 import Connection
-from typing import List, Generator, Optional, Any
+from typing import Generator, List
 
 from bearish.database.schemas import *  # type: ignore # noqa: F403
+
 from bullish.database.schemas import *  # noqa: F403
 
 
@@ -64,19 +65,3 @@ def compatible_bearish_database(database_path: Path) -> bool:
 
 def compatible_bullish_database(database_path: Path) -> bool:
     return _compatible_table(database_path, "bullish.database.schemas")
-
-
-class DataBaseSingleTon:
-    _instance = None
-
-    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self, path: Optional[Path] = None) -> None:
-        if not hasattr(self, "path"):  # Only set once
-            self.path = path
-
-    def valid(self) -> bool:
-        return hasattr(self, "path")

{bullishpy-0.49.0 → bullishpy-0.51.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "bullishpy"
-version = "0.49.0"
+version = "0.51.0"
 description = ""
 authors = ["aan <andoludovic.andriamamonjy@gmail.com>"]
 readme = "README.md"