trd-utils 0.0.57__py3-none-any.whl

trd_utils/html_utils/html_formats.py

@@ -0,0 +1,72 @@
+import html
+
+def camel_to_snake(str_value: str) -> str:
+    """
+    Convert CamelCase to snake_case.
+    https://stackoverflow.com/a/44969381/16518789
+    """
+    return ''.join(['_'+c.lower() if c.isupper() else c for c in str_value]).lstrip('_')
+
+def to_camel_case(snake_str: str) -> str:
+    """
+    Convert snake_case to CamelCase.
+    https://stackoverflow.com/a/19053800/16518789
+    """
+    return "".join(x.capitalize() for x in snake_str.lower().split("_"))
+
+def to_lower_camel_case(snake_str: str) -> str:
+    # We capitalize the first letter of each component except the first one
+    # with the 'capitalize' method and join them together.
+    camel_string = to_camel_case(snake_str)
+    return snake_str[0].lower() + camel_string[1:]
+
+def get_html_normal(*argv) -> str:
+    if argv is None or len(argv) == 0: 
+        return ""
+
+    my_str = ""
+    for value in argv:
+        if not value:
+            continue
+        if isinstance(value, str):
+            my_str += value
+        else:
+            my_str += str(value)
+    
+    return my_str
+
+def html_normal(value, *argv) -> str:
+    my_str = html.escape(str(value))
+    for value in argv:
+        if isinstance(value, str):
+            my_str += value
+    return my_str
+
+
+def html_mono(value, *argv) -> str:
+    return f"<code>{html.escape(str(value))}</code>" + get_html_normal(*argv)
+
+def html_in_parenthesis(value) -> str:
+    if not value:
+        return ": "
+    return f" ({html.escape(str(value))}): "
+
+def html_bold(value, *argv) -> str:
+    return f"<b>{html.escape(str(value))}</b>" + get_html_normal(*argv)
+
+def html_italic(value, *argv) -> str:
+    return f"<i>{html.escape(str(value))}</i>" + get_html_normal(*argv)
+
+def html_link(value, link: str, *argv) -> str:
+    if not isinstance(link, str) or len(link) == 0:
+        return html_mono(value, *argv)
+    return f"<a href={html.escape(link)}>{html.escape(str(value))}</a>" + get_html_normal(*argv)
+
+def html_code_snippets(value, language: str, *argv):
+    return html_pre(value, language, *argv)
+
+def html_pre(value, language: str, *argv):
+    return f"<pre language={html.escape(language)}>{html.escape(str(value))}</pre>" + get_html_normal(*argv)
+
+def html_spoiler(value, *argv):
+    return f"<spoiler>{html.escape(str(value))}</spoiler>" + get_html_normal(*argv)

trd_utils/tradingview/__init__.py

@@ -0,0 +1,8 @@
+from .tradingview_client import TradingViewClient
+from .tradingview_types import CoinScanInfo
+
+
+__all__ = [
+    "TradingViewClient",
+    "CoinScanInfo",
+]

trd_utils/tradingview/tradingview_client.py

@@ -0,0 +1,128 @@
+import json
+from typing import Optional
+
+from trd_utils.types_helper import new_list
+
+from .tradingview_types import CoinScanInfo
+
+
+class TradingViewClient:
+    """TradingViewClient class to interact with TradingView API."""
+
+    def __init__(self) -> None:
+        pass
+
+    async def get_coin_scan(
+        self,
+        coin_filter: Optional[str] = None,
+        limit: int = 200,
+        offset: int = 0,
+    ) -> list["CoinScanInfo"]:
+        import httpx
+
+        cookies = {
+            "cookiesSettings": '{"analytics":true,"advertising":true}',
+            "cookiePrivacyPreferenceBannerProduction": "accepted",
+        }
+
+        headers = {
+            "accept": "application/json",
+            "accept-language": "en-US,en;q=0.9",
+            "cache-control": "no-cache",
+            "content-type": "text/plain;charset=UTF-8",
+            "origin": "https://www.tradingview.com",
+            "pragma": "no-cache",
+            "priority": "u=1, i",
+            "referer": "https://www.tradingview.com/",
+            "sec-ch-ua": '"Not)A;Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "user-agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                + "(KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
+            ),
+        }
+
+        params = {
+            "label-product": "screener-coin",
+        }
+
+        data = {
+            "columns": [
+                "base_currency",
+                "base_currency_desc",
+                "base_currency_logoid",
+                "update_mode",
+                "type",
+                "typespecs",
+                "exchange",
+                "crypto_total_rank",
+                "Recommend.All",
+                "Recommend.MA",
+                "Recommend.Other",
+                "RSI",
+                "Mom",
+                "pricescale",
+                "minmov",
+                "fractional",
+                "minmove2",
+                "AO",
+                "CCI20",
+                "Stoch.K",
+                "Stoch.D",
+                "profit_addresses_percentage",
+                "sentiment",
+                "socialdominance",
+                "galaxyscore",
+                "social_volume_24h",
+                "altrank",
+                "large_tx_count",
+                "close",
+                "currency",
+                "change_abs",
+                "Volatility.D",
+            ],
+            "ignore_unknown_fields": False,
+            "options": {"lang": "en"},
+            "range": [
+                offset,
+                offset + limit,
+            ],
+            "sort": {"sortBy": "crypto_total_rank", "sortOrder": "asc"},
+            "symbols": {},
+            "markets": ["coin"],
+        }
+
+        if coin_filter:
+            data["filter"] = [
+                {
+                    "left": "base_currency,base_currency_desc",
+                    "operation": "match",
+                    "right": f"{coin_filter}",
+                }
+            ]
+        data = json.dumps(data)
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://scanner.tradingview.com/coin/scan",
+                params=params,
+                cookies=cookies,
+                headers=headers,
+                data=data,
+            )
+
+        j_result = response.json()
+        if not isinstance(j_result, dict) or not j_result.get("data", None):
+            raise Exception("No data found")
+
+        j_data = j_result["data"]
+        all_infos = new_list()
+        for current_data in j_data:
+            if not isinstance(current_data, dict):
+                continue
+            all_infos.append(CoinScanInfo._parse(current_data.get("d", [])))
+
+        return all_infos

trd_utils/tradingview/tradingview_types.py

@@ -0,0 +1,185 @@
+
+from typing import Optional
+
+
+class CoinScanInfo:
+    base_currency: str = ""
+    base_currency_desc: str = ""
+    base_currency_logoid: str = ""
+    update_mode: str = ""
+    type: str = ""
+    typespecs: str = ""
+    exchange: str = ""
+    crypto_total_rank: Optional[int] = None
+    recommend_all: Optional[float] = None
+    recommend_ma: Optional[float] = None
+    recommend_other: Optional[float] = None
+    RSI: Optional[float] = None
+    Mom: Optional[float] = None
+    pricescale: Optional[int] = None
+    minmov: Optional[int] = None
+    fractional: Optional[bool] = None
+    minmove2: Optional[int] = None
+    AO: Optional[float] = None
+    CCI20: Optional[float] = None
+    stoch_k: Optional[float] = None
+    stoch_d: Optional[float] = None
+    profit_addresses_percentage: Optional[float] = None
+    sentiment: Optional[float] = None
+    socialdominance: Optional[float] = None
+    galaxyscore: Optional[int] = None
+    social_volume_24h: Optional[int] = None
+    altrank: Optional[int] = None
+    large_tx_count: Optional[int] = None
+    close_price: Optional[float] = None
+    currency: Optional[str] = None
+    change_abs: Optional[float] = None
+    volatility_d: Optional[float] = None
+
+    def get_tech_rating_str(self) -> str:
+        if self.recommend_all is None:
+            return "N/A"
+
+        is_negative = False
+        emoji = "🟢"
+        if self.recommend_all < 0:
+            is_negative = True
+            self.recommend_all = abs(self.recommend_all)
+            emoji = "🔴"
+
+        if self.recommend_all > 0.5:
+            return f"{emoji} Strong {'Sell' if is_negative else 'Buy'}"
+
+        if self.recommend_all > 0.1:
+            return f"{emoji} {'Sell' if is_negative else 'Buy'}"
+
+        return "Neutral"
+
+    def get_ma_rating_str(self) -> str:
+        if self.recommend_ma is None:
+            return "N/A"
+
+        is_negative = False
+        emoji = "🟢"
+        if self.recommend_ma < 0:
+            is_negative = True
+            self.recommend_ma = abs(self.recommend_ma)
+            emoji = "🔴"
+
+        if self.recommend_ma > 0.5:
+            return f"{emoji} Strong {'Sell' if is_negative else 'Buy'}"
+
+        if self.recommend_ma > 0.1:
+            return f"{emoji} {'Sell' if is_negative else 'Buy'}"
+
+        return "Neutral"
+
+    def get_os_rating_str(self) -> str:
+        if self.recommend_other is None:
+            return "N/A"
+
+        is_negative = False
+        emoji = "🟢"
+        if self.recommend_other < 0:
+            is_negative = True
+            self.recommend_other = abs(self.recommend_other)
+            emoji = "🔴"
+
+        if self.recommend_other > 0.5:
+            return f"{emoji} Strong {'Sell' if is_negative else 'Buy'}"
+
+        if self.recommend_other > 0.1:
+            return f"{emoji} {'Sell' if is_negative else 'Buy'}"
+
+        return "Neutral"
+
+    def get_addresses_in_profit_str(self) -> str:
+        if self.profit_addresses_percentage is None:
+            return "N/A"
+        return f"{self.profit_addresses_percentage:.2f}%"
+
+    def get_sentiment_str(self) -> str:
+        if self.sentiment is None:
+            return "N/A"
+        return f"{self.sentiment:.2f}%"
+
+    def get_socialdominance_str(self) -> str:
+        if self.socialdominance is None:
+            return "N/A"
+        return f"{self.socialdominance:.2f}%"
+
+
+    def parse_as_markdown(self) -> str:
+        text = f"*{self.crypto_total_rank}. {self.base_currency_desc} ({self.base_currency})*:\n"
+        text += f"  *• Tech Rating:* {self.get_tech_rating_str()}\n"
+        text += f"  *• MA Rating:* {self.get_ma_rating_str()}\n"
+        text += f"  *• Os Rating:* {self.get_os_rating_str()}\n"
+
+        if self.profit_addresses_percentage:
+            text += f"  *• In Profit:* {self.get_addresses_in_profit_str()}\n"
+
+        if self.sentiment:
+            text += f"  *• Sentiment:* {self.get_sentiment_str()}\n"
+
+        if self.socialdominance:
+            text += f"  *• Social Dominance:* {self.get_socialdominance_str()}\n"
+
+        if self.galaxyscore:
+            text += f"  *• Galaxy Score:* {self.galaxyscore}\n"
+
+        if self.social_volume_24h:
+            text += f"  *• Social Volume 24h:* {self.social_volume_24h}\n"
+
+        if self.altrank:
+            text += f"  *• AltRank:* {self.altrank}\n"
+
+        if self.large_tx_count:
+            text += f"  *• Large TX Count:* {self.large_tx_count}\n"
+
+        if self.close_price and self.currency:
+            text += f"  *• Price:* `{self.close_price} {self.currency}`"
+            text += f" (`{self.change_abs:+.2f}`)\n"
+
+        if self.volatility_d:
+            text += f"  *• Volatility:* {self.volatility_d:.2f}%\n"
+
+        return text
+
+
+    @staticmethod
+    def _parse(data: list) -> "CoinScanInfo":
+        instance = CoinScanInfo()
+        instance.base_currency = data[0]
+        instance.base_currency_desc = data[1]
+        instance.base_currency_logoid = data[2]
+        instance.update_mode = data[3]
+        instance.type = data[4]
+        instance.typespecs = data[5]
+        instance.exchange = data[6]
+        instance.crypto_total_rank = data[7]
+        instance.recommend_all = data[8]
+        instance.recommend_ma = data[9]
+        instance.recommend_other = data[10]
+        instance.RSI = data[11]
+        instance.Mom = data[12]
+        instance.pricescale = data[13]
+        instance.minmov = data[14]
+        instance.fractional = data[15]
+        instance.minmove2 = data[16]
+        instance.AO = data[17]
+        instance.CCI20 = data[18]
+        instance.stoch_k = data[19]
+        instance.stoch_d = data[20]
+        instance.profit_addresses_percentage = data[21]
+        instance.sentiment = data[22]
+        instance.socialdominance = data[23]
+        instance.galaxyscore = int(data[24] or 0)
+        instance.social_volume_24h = int(data[25] or 0)
+        instance.altrank = int(data[26] or 0)
+        instance.large_tx_count = int(data[27] or 0)
+        instance.close_price = data[28]
+        instance.currency = data[29]
+        instance.change_abs = data[30]
+        instance.volatility_d = data[31]
+
+        return instance

trd_utils/types_helper/__init__.py

@@ -0,0 +1,12 @@
+
+from .ultra_list import UltraList
+from .base_model import BaseModel, new_list
+from .decorators import ignore_json_fields
+
+
+__all__ = [
+    "UltraList",
+    "BaseModel",
+    "new_list",
+    "ignore_json_fields",
+]