trd-utils 0.0.1__py3-none-any.whl

trd_utils/tradingview/tradingview_client.py

@@ -0,0 +1,130 @@
+
+
+
+import json
+from typing import Optional
+
+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 = []
+        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,4 @@
+from .base_model import BaseModel
+
+
+__all__ = ["BaseModel"]

trd_utils/types_helper/base_model.py

@@ -0,0 +1,150 @@
+import json
+from typing import (
+    Optional,
+    Union,
+    get_type_hints,
+    Any,
+    get_args as get_type_args
+)
+
+from trd_utils.html_utils.html_formats import camel_to_snake
+
+# Whether to use ultra-list instead of normal python list or not.
+# This might be convenient in some cases, but it is not recommended
+# to use it in production code because of the performance overhead.
+ULTRA_LIST_ENABLED: bool = False
+
+# Whether to also set the camelCase attribute names for the model.
+# This is useful when the API returns camelCase attribute names
+# and you want to use them as is in the model; by default, the
+# attribute names are converted to snake_case.
+SET_CAMEL_ATTR_NAMES = False
+
+def get_my_field_types(cls):
+    type_hints = {}
+    for current_cls in cls.__class__.__mro__:
+        if current_cls is object or current_cls is BaseModel:
+            break
+        type_hints.update(get_type_hints(current_cls))
+    return type_hints
+
+def get_real_attr(cls, attr_name):
+    if cls is None:
+        return None
+    
+    if isinstance(cls, dict):
+        return cls.get(attr_name, None)
+
+    if hasattr(cls, attr_name):
+        return getattr(cls, attr_name)
+    
+    return None
+
+class UltraList(list):
+    def __getattr__(self, attr):
+        if len(self) == 0:
+            return None
+        return UltraList([get_real_attr(item, attr) for item in self])
+
+def convert_to_ultra_list(value: Any) -> UltraList:
+    if not value:
+        return UltraList()
+
+    # Go through all fields of the value and convert them to
+    # UltraList if they are lists
+
+    try:
+        if isinstance(value, list):
+            return UltraList([convert_to_ultra_list(item) for item in value])
+        elif isinstance(value, dict):
+            return {k: convert_to_ultra_list(v) for k, v in value.items()}
+        elif isinstance(value, tuple):
+            return tuple(convert_to_ultra_list(v) for v in value)
+        elif isinstance(value, set):
+            return {convert_to_ultra_list(v) for v in value}
+        
+        for attr, attr_value in get_my_field_types(value).items():
+            if isinstance(attr_value, list):
+                setattr(value, attr, convert_to_ultra_list(getattr(value, attr)))
+
+        return value
+    except Exception:
+        return value
+
+class BaseModel:
+    def __init__(self, **kwargs):
+        annotations = get_my_field_types(self)
+        # annotations = self.__annotations__
+        for key, value in kwargs.items():
+            corrected_key = key
+            if key not in annotations:
+                # key does not exist, try converting it to snake_case
+                corrected_key = camel_to_snake(key)
+                if corrected_key not in annotations:
+                    # just ignore and continue
+                    annotations[key] = Any
+                    annotations[corrected_key] = Any
+            
+            expected_type = annotations[corrected_key]
+            if hasattr(self, "_get_" + corrected_key + "_type"):
+                try:
+                    overridden_type = getattr(self, "_get_" + corrected_key + "_type")(kwargs)
+                    if overridden_type:
+                        expected_type = overridden_type
+                except Exception:
+                    pass
+            
+            is_optional_type = getattr(expected_type, '_name', None) == 'Optional'
+            # maybe in the future we can have some other usages for is_optional_type
+            # variable or something like that.
+            if is_optional_type:
+                try:
+                    expected_type = get_type_args(expected_type)[0]
+                except Exception:
+                    # something went wrong, just ignore and continue
+                    expected_type = Any
+            
+            # Handle nested models
+            if isinstance(value, dict) and issubclass(expected_type, BaseModel):
+                value = expected_type(**value)
+            
+            elif isinstance(value, list):
+                type_args = get_type_args(expected_type)
+                if not type_args:
+                    # if it's Any, it means we shouldn't really care about the type
+                    if expected_type != Any:
+                        value = expected_type(value)
+                else:
+                    # Handle list of nested models
+                    nested_type = type_args[0]
+                    if issubclass(nested_type, BaseModel):
+                        value = [nested_type(**item) for item in value]
+                
+                if ULTRA_LIST_ENABLED and isinstance(value, list):
+                    value = convert_to_ultra_list(value)
+            
+            # Type checking
+            elif expected_type != Any and not isinstance(value, expected_type):
+                try:
+                    value = expected_type(value)
+                except Exception:
+                    raise TypeError(f"Field {corrected_key} must be of type {expected_type}," +
+                                    f" but it's {type(value)}")
+            
+            setattr(self, corrected_key, value)
+            if SET_CAMEL_ATTR_NAMES and key != corrected_key:
+                setattr(self, key, value)
+        
+        # Check if all required fields are present
+        # for field in self.__annotations__:
+        #     if not hasattr(self, field):
+        #         raise ValueError(f"Missing required field: {field}")
+    
+    @classmethod
+    def deserialize(cls, json_data: Union[str, dict]):
+        if isinstance(json_data, str):
+            data = json.loads(json_data)
+        else:
+            data = json_data
+        return cls(**data)
+

trd_utils-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ALi.w
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trd_utils-0.0.1.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: trd_utils
+Version: 0.0.1
+Summary: Common Basic Utils for Python3. By ALiwoto.
+Home-page: https://github.com/ALiwoto/trd_utils
+Keywords: utils,trd_utils,basic-utils,common-utils
+Author: ALiwoto
+Author-email: aminnimaj@gmail.com
+Requires-Python: >=3.7
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: cryptography (>=41.0.7)
+Requires-Dist: httpx (>=0.21.0)
+Description-Content-Type: text/markdown
+
+# Trd Utils
+
+Basic common utils for Python.
+

trd_utils-0.0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+trd_utils/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+trd_utils/bx_ultra/__init__.py,sha256=8Ssy-eOemQR32Nv1-FoPHm87nRqRO4Fm2PU5GHEFKfQ,80
+trd_utils/bx_ultra/bx_types.py,sha256=fILyRGxdPyQOwqMiVOJK9GtVD5eV116GrADKfnye6OI,19414
+trd_utils/bx_ultra/bx_ultra_client.py,sha256=w2ajrBLDrSeRAPXCPV4lkUkR-r1PqE1Kwu2bxbJUy7A,15876
+trd_utils/bx_ultra/common_utils.py,sha256=aHvtaGelyUB10p0FWMX5y-snO0ZuKYrAW2rqNzyxEUw,1392
+trd_utils/cipher/__init__.py,sha256=V05KNuzQwCic-ihMVHlC8sENaJGc3I8MCb4pg4849X8,1765
+trd_utils/html_utils/__init__.py,sha256=1WWs8C7JszRjTkmzIRLHpxWECHur_DrulTPGIeX88oM,426
+trd_utils/html_utils/html_formats.py,sha256=unKsvOiiDmYTTaM0DYZEUNLEUzWQKKrqASJXvY54kvU,2299
+trd_utils/tradingview/__init__.py,sha256=H0QYb-O5qvy7qC3yswtlcSWLmeBnaS6oJ3JtjvmaV_Y,154
+trd_utils/tradingview/tradingview_client.py,sha256=iiNSLSKr5PnDcGiVFn515gsnGtqm5Htu99IwShHr2wM,4007
+trd_utils/tradingview/tradingview_types.py,sha256=z21MXPVdWHAduEl3gSeMIRhxtBN9yK-jPYHfZSMIbSA,6144
+trd_utils/types_helper/__init__.py,sha256=SB9_5bQkuxV059AKC4cXYwsLPT3lM4LOu2m8LpMhZlQ,60
+trd_utils/types_helper/base_model.py,sha256=J3SdOB9UNgw0cI8gaG8zjnfqa1qiVmlpz4o3aBxHqas,5631
+trd_utils-0.0.1.dist-info/LICENSE,sha256=msfwzd8S06fL8ORRneycnonTKmyuXzfeBT0V2figir8,1062
+trd_utils-0.0.1.dist-info/METADATA,sha256=efwVikXUz2_0VeUw8f184Fh28tAQ3w-vpvdosENtuqI,975
+trd_utils-0.0.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+trd_utils-0.0.1.dist-info/RECORD,,

trd_utils-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any