strideutils 0.8.4__tar.gz → 0.8.6__tar.gz

{strideutils-0.8.4 → strideutils-0.8.6}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.8.4
+current_version = 0.8.6
 commit = False
 tag = False
 

{strideutils-0.8.4 → strideutils-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strideutils
-Version: 0.8.4
+Version: 0.8.6
 Summary: Utility functions for monitoring the Stride blockchain
 Author-email: Stride Labs <hello@stridelabs.co>
 License: MIT License

{strideutils-0.8.4 → strideutils-0.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "strideutils"
-version = "0.8.4"
+version = "0.8.6"
 authors = [
     {name = "Stride Labs", email = "hello@stridelabs.co"},
 ]

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils/exec_tx.py

@@ -8,7 +8,7 @@ from typing import Optional
 from strideutils import stride_requests
 from strideutils.stride_config import config
 
-WALLET_SETUP_COMMAND = "echo {mnemonic} | {binary} keys add {wallet_name} --recover --keyring-backend=test"
+WALLET_SETUP_COMMAND = "echo {mnemonic} | {binary} keys add {account_name} --recover --keyring-backend=test"
 
 
 @dataclass
@@ -22,7 +22,7 @@ class TxResponse:
     raw_log: Optional[str] = None
 
 
-def restore_wallet(wallet_name: str = "wallet", mnemonic_var: str = "MNEMONIC", binary: str = "strided"):
+def restore_wallet(account_name: str = "wallet", mnemonic_var: str = "MNEMONIC", binary: str = "strided"):
     """
     Restores a wallet in the keyring, using the mnemonic under the specified environment variable
     """
@@ -30,7 +30,7 @@ def restore_wallet(wallet_name: str = "wallet", mnemonic_var: str = "MNEMONIC",
     if not mnemonic:
         raise EnvironmentError(f"{mnemonic_var} must be set")
 
-    os.system(WALLET_SETUP_COMMAND.format(mnemonic=mnemonic, binary=binary, wallet_name=wallet_name))
+    os.system(WALLET_SETUP_COMMAND.format(mnemonic=mnemonic, binary=binary, account_name=account_name))
 
 
 def execute_tx(command: str, api_endpoint: str = config.stride.api_endpoint) -> TxResponse:

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils/exec_tx.pyi

@@ -14,5 +14,5 @@ class TxResponse:
     tx_response: dict | None = ...
     raw_log: str | None = ...
 
-def restore_wallet(wallet_name: str = 'wallet', mnemonic_var: str = 'MNEMONIC', binary: str = 'strided'): ...
+def restore_wallet(account_name: str = 'wallet', mnemonic_var: str = 'MNEMONIC', binary: str = 'strided'): ...
 def execute_tx(command: str, api_endpoint: str = ...) -> TxResponse: ...

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils/sheets_connector.py

@@ -12,7 +12,7 @@ publicsheets@stride-nodes.iam.gserviceaccount.com can access will be readable by
 
 import json
 import warnings
-from typing import Dict, List, Tuple
+from typing import Any, Dict, List, Tuple
 
 import gspread  # type: ignore
 import pandas as pd
@@ -139,7 +139,40 @@ class GoogleSheetsClient:
         # Write the new values with update (which will override an existing sheet).
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore")
-            worksheet.update(values=columns + rows, range_name=range_name)
+            worksheet.update(values=columns + rows, range_name=range_name)  # type: ignore
+
+    def write_cell(
+        self,
+        value: List[List[Any]],
+        range_name: str,
+        sheet_id: str,
+        sheet_name: str,
+    ) -> None:
+        """
+        Writes a value to a specified Google Sheet.
+
+        Please note: value must be a list of lists, where each inner list represents a row.
+        If you're only passing in a value for one cell, then `value=[[your_value]]`.
+
+        Args:
+            value: The value to write in the sheet. This is a List of Lists.
+            range_name: The range to write the value to, e.g. "B3:C4"
+            sheet_id: The ID of the Sheet (found in the URL)
+            sheet_name: The name of the worksheet to write to
+
+        Raises:
+            gspread.exceptions.APIError: If there's an error accessing the sheet
+        """
+        # Fetch the worksheet if it exists, otherwise create a new worksheet.
+        spreadsheet = self.client.open_by_key(sheet_id)
+        try:
+            worksheet = spreadsheet.worksheet(sheet_name)
+        except WorksheetNotFound:
+            worksheet = spreadsheet.add_worksheet(title=sheet_name, rows=1, cols=1)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore")
+            worksheet.update(values=value, range_name=range_name)
 
     def reorder_sheet(
         self,

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils/sheets_connector.pyi

@@ -1,6 +1,7 @@
 import gspread
 import pandas as pd
 from strideutils.stride_config import get_env_or_raise as get_env_or_raise
+from typing import Any
 
 SCOPES: tuple[str, str, str]
 
@@ -11,5 +12,6 @@ class GoogleSheetsClient:
     def __init__(self, cache_enabled: bool = False) -> None: ...
     def grab_sheet(self, sheet_id: str, sheet_name: str, columns_labeled: bool = True) -> pd.DataFrame: ...
     def write_sheet(self, df: pd.DataFrame, sheet_id: str, sheet_name: str) -> None: ...
+    def write_cell(self, value: list[list[Any]], range_name: str, sheet_id: str, sheet_name: str) -> None: ...
     def reorder_sheet(self, sheet_id: str, sheet_name: str, new_location: int = 0) -> None: ...
     def get_sheet_names(self, sheet_id: str) -> list[str]: ...

strideutils-0.8.6/strideutils/slack_connector.py

@@ -0,0 +1,183 @@
+import datetime
+import os
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Union
+
+from slack_sdk import WebClient
+from slack_sdk.socket_mode import SocketModeClient
+from slack_sdk.socket_mode.client import BaseSocketModeClient
+from slack_sdk.socket_mode.request import SocketModeRequest
+from slack_sdk.socket_mode.response import SocketModeResponse
+
+from strideutils.stride_config import Environment as e
+from strideutils.stride_config import get_env_or_raise
+
+
+@dataclass
+class SlackMessage:
+    timestamp: datetime.datetime
+    timestamp_id: str
+    thread_ts: Optional[str]
+    sender: str
+    text: str
+
+    @classmethod
+    def from_dict(cls, message: dict):
+        thread_ts = message.get("thread_ts", None)
+        return cls(
+            timestamp=datetime.datetime.fromtimestamp(float(message["ts"])),
+            timestamp_id=message["ts"],
+            thread_ts=thread_ts,
+            sender=message["user"],
+            text=message["text"],
+        )
+
+
+class SlackClient:
+    """
+    Singleton client used to post messages to slack
+    """
+
+    _instance = None
+
+    def __new__(cls):
+        # Creates a new instance if one does not already exist
+        if cls._instance is None:
+            cls._instance = super(SlackClient, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # Prevent re-initialization if a client has already been created
+        if hasattr(self, "client"):
+            return
+
+        self.api_token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
+        self.client = WebClient(token=self.api_token)
+        self.socket_mode_client: SocketModeClient | None = None
+
+    def setup_for_listening(self):
+        """
+        Sets up the client for listening to slack messages using SocketMode.
+        Without calling this function, a Socket Mode client will not be created.
+
+        We don't create the client in the constructor to avoid unnecessary overhead,
+        as not all processes will want to initiate socket connections.
+        """
+        self.app_token = get_env_or_raise(e.STRIDEBOT_APP_TOKEN)
+        socket_mode_client = SocketModeClient(app_token=self.app_token, web_client=self.client)
+        print("Socket mode client created")
+        self.socket_mode_client = socket_mode_client
+
+    def post_message(
+        self,
+        message: Union[str, List[str]],
+        channel: str,
+        botname: Optional[str] = None,
+        thread_ts: Optional[str] = None,
+    ):
+        """
+        Posts a slack message to the given channel
+        If the message is an array, this will post each element of the array as a thread
+
+        Returns the thread_ts to allow chaining messages
+        """
+        # Allow optional channel overrides via an environment variable
+        channel = os.environ.get(e.SLACK_CHANNEL_OVERRIDE, default=channel)
+
+        # Listify
+        messages = [message] if type(message) is str else message
+
+        # Post each message, threading with the previous
+        thread_ts = None or thread_ts
+        for msg in messages:
+            response = self.client.chat_postMessage(
+                channel=channel,
+                text=msg,
+                thread_ts=thread_ts,
+                username=botname,
+            )
+            if thread_ts is None:  # API advises to use parent IDs instead of child's
+                thread_ts = response["ts"]
+
+        return thread_ts
+
+    def upload_file(self, file_name: str, content: str) -> str:
+        """
+        This uploads a file and returns a link that can be used to embed a file in slack
+        Ex:
+            url = upload_file("test.txt", "Hello World")
+            post_msg(f"<{url}|This is a file>", channel="#alerts-debug")
+        """
+        slack_file = self.client.files_upload_v2(filename=file_name, content=content)
+        file_link = slack_file["file"]["permalink"]
+        return file_link
+
+    def listen_to_channel(
+        self, message_callback: Callable[[BaseSocketModeClient, dict], None], target_channel: str
+    ) -> None:
+        """
+        Starts a listener for slack messages in the specified channel using SocketMode.
+        Calls `message_callback` with the event data when a message is received.
+        """
+        if not self.socket_mode_client:
+            self.setup_for_listening()
+        assert self.socket_mode_client is not None, "Failed to initialize socket mode client"
+
+        def handle_message(client: BaseSocketModeClient, req: SocketModeRequest):
+            if req.type == "events_api":
+                # ack the request immediately
+                response = SocketModeResponse(envelope_id=req.envelope_id)
+                if req.payload["event"]["channel"] == target_channel:
+                    client.send_socket_mode_response(response)
+                    message_callback(client, req.payload["event"])
+
+        self.socket_mode_client.socket_mode_request_listeners.append(handle_message)
+        self.socket_mode_client.connect()
+
+    def get_prior_messages_in_channel(self, channel: str, limit: int = 200, max_age=-1) -> List[List[SlackMessage]]:
+        """
+        Fetch the most recent messages from a Slack channel.
+        Args:
+            channel (str): ID of the Slack channel.
+            limit (int): Maximum number of messages to fetch (default: 100).
+            max_age (int): Maximum age in seconds of messages to fetch (default: -1, fetch all messages).
+        Returns:
+            List[List[SlackMessages]]: A list of list of message objects.
+                Each element in the array is a list of messages in that thread.
+        """
+        # fetch message history
+        response = self.client.conversations_history(channel=channel, limit=limit)
+
+        raw_messages = response.get("messages", [])
+        channel_messages: list[list[SlackMessage]] = []
+        now_time = datetime.datetime.now()
+        for raw_message in raw_messages:
+            # check if message is too old
+            if max_age > 0:
+                message_time = datetime.datetime.fromtimestamp(float(raw_message["ts"]))
+                if (now_time - message_time).total_seconds() > max_age:
+                    continue
+
+            if 'thread_ts' in raw_message:
+                # make sure we haven't processed this thread already.
+                # This happens when multiple messages from the same thread are returned in `response`.
+                # After we process the first message, because we call `conversations_replies` below,
+                # we will have already processed the whole thread.
+                thread_ts = raw_message['thread_ts']
+                if thread_ts in [msg[0].thread_ts for msg in channel_messages]:
+                    continue
+
+                # this is a thread, fetch the full thread
+                thread_replies = self.client.conversations_replies(channel=channel, ts=thread_ts)
+                thread_msgs = []
+                for reply in thread_replies["messages"]:
+                    thread_msg = SlackMessage.from_dict(reply)
+                    thread_msgs.append(thread_msg)
+                channel_messages.append(thread_msgs)
+
+            else:
+                # this is not a thread
+                slack_msg = SlackMessage.from_dict(raw_message)
+                channel_messages.append([slack_msg])
+
+        return channel_messages

strideutils-0.8.6/strideutils/slack_connector.pyi

@@ -0,0 +1,29 @@
+import datetime
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from slack_sdk.socket_mode.client import BaseSocketModeClient
+from strideutils.stride_config import get_env_or_raise as get_env_or_raise
+from typing import Callable
+
+@dataclass
+class SlackMessage:
+    timestamp: datetime.datetime
+    timestamp_id: str
+    thread_ts: str | None
+    sender: str
+    text: str
+    @classmethod
+    def from_dict(cls, message: dict): ...
+
+class SlackClient:
+    def __new__(cls): ...
+    api_token: Incomplete
+    client: Incomplete
+    socket_mode_client: Incomplete
+    def __init__(self) -> None: ...
+    app_token: Incomplete
+    def setup_for_listening(self) -> None: ...
+    def post_message(self, message: str | list[str], channel: str, botname: str | None = None, thread_ts: str | None = None): ...
+    def upload_file(self, file_name: str, content: str) -> str: ...
+    def listen_to_channel(self, message_callback: Callable[[BaseSocketModeClient, dict], None], target_channel: str) -> None: ...
+    def get_prior_messages_in_channel(self, channel: str, limit: int = 200, max_age: int = -1) -> list[list[SlackMessage]]: ...

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils/stride_config.py

@@ -2,10 +2,9 @@
 This file loads and provide an object `config` to access all secrets, configs, and chain info
 """
 
-import itertools
 import os
 from dataclasses import dataclass, field, fields
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, cast
 
 import yaml
 from dotenv import load_dotenv
@@ -33,6 +32,7 @@ class Environment:
     TWILIO_API_TOKEN = "TWILIO_API_TOKEN"
 
     STRIDEBOT_API_TOKEN = "STRIDEBOT_API_TOKEN"
+    STRIDEBOT_APP_TOKEN = "STRIDEBOT_APP_TOKEN"
     SLACK_CHANNEL_OVERRIDE = "SLACK_CHANNEL_OVERRIDE"
 
     PUBLICSHEETS_AUTH = "PUBLICSHEETS_AUTH"
@@ -191,6 +191,10 @@ class Config(ConfigObj):
     def app_chains(self) -> List[ChainConfig]:
         return [app_chain for app_chain in self._app_chains.values()]
 
+    @property
+    def chains(self) -> List[ChainConfig]:
+        return self.host_zones + self.app_chains
+
     @property
     def host_zone_names(self) -> List[str]:
         return [host_zone for host_zone in self._host_zones.keys()]
@@ -199,55 +203,33 @@ class Config(ConfigObj):
     def app_chain_names(self) -> List[str]:
         return [app_chain for app_chain in self._app_chains.keys()]
 
-    def _create_mappings(self) -> None:
-        """
-        Create a reverse map from attributes to ChainConfig if id, ticker, and denom are set.
-        """
-        name_to_zone = ConfigDict()
-        id_to_zone = ConfigDict()
-        ticker_to_zone = ConfigDict()
-        denom_to_zone = ConfigDict()
-        denom_on_stride_to_zone = ConfigDict()
-
-        # Map host zones and app chains.
-        for chain_info in itertools.chain(self._host_zones.values(), self._app_chains.values()):
-            try:
-                name_to_zone[chain_info.name] = chain_info
-            except AttributeError:
-                pass
-
-            try:
-                id_to_zone[chain_info.id] = chain_info
-            except AttributeError:
-                pass
-
-            try:
-                ticker_to_zone[chain_info.ticker] = chain_info
-                ticker_to_zone[chain_info.ticker.upper()] = chain_info
-                ticker_to_zone[chain_info.ticker.lower()] = chain_info
-                ticker_to_zone[chain_info.denom] = chain_info
-            except AttributeError:
-                pass
-
-            try:
-                denom_to_zone[chain_info.denom] = chain_info
-            except AttributeError:
-                pass
-
-            if isinstance(chain_info, HostChainConfig):
-                try:
-                    denom_on_stride_to_zone[chain_info.denom_on_stride] = chain_info
-                except AttributeError:
-                    pass
-
-        self._name_to_zone = name_to_zone
-        self._id_to_zone = id_to_zone
-        self._ticker_to_zone = ticker_to_zone
-        self._denom_to_zone = denom_to_zone
-        self._denom_on_stride_to_zone = denom_on_stride_to_zone
-
-    def __post_init__(self):
-        self._create_mappings()
+    def _evaluate_chain_match(
+        self,
+        chain: ChainConfig,
+        name: Optional[str],
+        id: Optional[str],
+        ticker: Optional[str],
+        denom: Optional[str],
+        denom_on_stride: Optional[str],
+    ) -> bool:
+        if name is not None:
+            return chain.name == name
+
+        if id is not None:
+            return chain.id == id
+
+        if ticker is not None:
+            chain_tickers = [chain.ticker, chain.ticker.upper(), chain.ticker.lower(), chain.denom]
+            return ticker in chain_tickers
+
+        if denom is not None:
+            return chain.denom == denom
+
+        if denom_on_stride is not None:
+            if isinstance(chain, HostChainConfig):
+                return chain.denom_on_stride == denom_on_stride
+
+        return False
 
     def get_chain(
         self,
@@ -256,7 +238,7 @@ class Config(ConfigObj):
         ticker: Optional[str] = None,
         denom: Optional[str] = None,
         denom_on_stride: Optional[str] = None,
-    ) -> Union[ChainConfig, StrideChainConfig, HostChainConfig]:
+    ) -> ChainConfig:
         """
         Fetch info about a host zone by name, id, ticker, denom, or token hash.
 
@@ -274,22 +256,18 @@ class Config(ConfigObj):
         ):
             return self.stride
 
-        try:
-            if name:
-                return self._name_to_zone[name]
-            elif id:
-                return self._id_to_zone[id]
-            elif ticker:
-                return self._ticker_to_zone[ticker]
-            elif denom:
-                return self._denom_to_zone[denom]
-            elif denom_on_stride:
-                return self._denom_on_stride_to_zone[denom_on_stride]
-        except KeyError:
-            raise KeyError("No chain found for the given parameter")
-
-        # This line should never be reached due to the initial check and the try-except block.
-        raise KeyError("Unexpected error in get_chain method")
+        for chain in self.chains:
+            if self._evaluate_chain_match(
+                chain=chain,
+                name=name,
+                id=id,
+                ticker=ticker,
+                denom=denom,
+                denom_on_stride=denom_on_stride,
+            ):
+                return chain
+
+        raise KeyError("No chain found for the given parameter")
 
     def get_host_chain(
         self,
@@ -306,16 +284,21 @@ class Config(ConfigObj):
             KeyError if a valid host chain doesn't exist or if multiple parameters are specified
             TypeError if the found chain is not a host chain
         """
-        chain_config = self.get_chain(
-            name=name,
-            id=id,
-            ticker=ticker,
-            denom=denom,
-            denom_on_stride=denom_on_stride,
-        )
-        if not isinstance(chain_config, HostChainConfig):
-            raise TypeError(f"Chain {chain_config.name} is not a host zone")
-        return chain_config
+        if sum(map(bool, [name, id, ticker, denom, denom_on_stride])) != 1:
+            raise KeyError("Exactly one of name, id, ticker, denom, or token hash must be specified.")
+
+        for chain in self.host_zones:
+            if self._evaluate_chain_match(
+                chain=chain,
+                name=name,
+                id=id,
+                ticker=ticker,
+                denom=denom,
+                denom_on_stride=denom_on_stride,
+            ):
+                return chain
+
+        raise KeyError("No host chain found for the given parameter")
 
 
 def _load_raw_config() -> dict[str, Any]:

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils/stride_config.pyi

@@ -14,6 +14,7 @@ class Environment:
     TWILIO_ACCOUNT_ID = ...
     TWILIO_API_TOKEN = ...
     STRIDEBOT_API_TOKEN = ...
+    STRIDEBOT_APP_TOKEN = ...
     SLACK_CHANNEL_OVERRIDE = ...
     PUBLICSHEETS_AUTH = ...
     COINGECKO_API_TOKEN = ...
@@ -80,11 +81,12 @@ class Config(ConfigObj):
     @property
     def app_chains(self) -> list[ChainConfig]: ...
     @property
+    def chains(self) -> list[ChainConfig]: ...
+    @property
     def host_zone_names(self) -> list[str]: ...
     @property
     def app_chain_names(self) -> list[str]: ...
-    def __post_init__(self) -> None: ...
-    def get_chain(self, name: str | None = None, id: str | None = None, ticker: str | None = None, denom: str | None = None, denom_on_stride: str | None = None) -> ChainConfig | StrideChainConfig | HostChainConfig: ...
+    def get_chain(self, name: str | None = None, id: str | None = None, ticker: str | None = None, denom: str | None = None, denom_on_stride: str | None = None) -> ChainConfig: ...
     def get_host_chain(self, name: str | None = None, id: str | None = None, ticker: str | None = None, denom: str | None = None, denom_on_stride: str | None = None) -> HostChainConfig: ...
 
 config: Config

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils-stubs/exec_tx.pyi

@@ -15,5 +15,5 @@ class TxResponse:
     tx_response: dict | None = ...
     raw_log: str | None = ...
 
-def restore_wallet(wallet_name: str = 'wallet', mnemonic_var: str = 'MNEMONIC', binary: str = 'strided'): ...
+def restore_wallet(account_name: str = 'wallet', mnemonic_var: str = 'MNEMONIC', binary: str = 'strided'): ...
 def execute_tx(command: str, api_endpoint: str = ...) -> TxResponse: ...

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils-stubs/sheets_connector.pyi

@@ -1,3 +1,5 @@
+from typing import Any
+
 import gspread
 import pandas as pd
 
@@ -12,5 +14,6 @@ class GoogleSheetsClient:
     def __init__(self, cache_enabled: bool = False) -> None: ...
     def grab_sheet(self, sheet_id: str, sheet_name: str, columns_labeled: bool = True) -> pd.DataFrame: ...
     def write_sheet(self, df: pd.DataFrame, sheet_id: str, sheet_name: str) -> None: ...
+    def write_cell(self, value: list[list[Any]], range_name: str, sheet_id: str, sheet_name: str) -> None: ...
     def reorder_sheet(self, sheet_id: str, sheet_name: str, new_location: int = 0) -> None: ...
     def get_sheet_names(self, sheet_id: str) -> list[str]: ...

strideutils-0.8.6/strideutils-stubs/slack_connector.pyi

@@ -0,0 +1,37 @@
+import datetime
+from dataclasses import dataclass
+from typing import Callable
+
+from _typeshed import Incomplete
+from slack_sdk.socket_mode.client import BaseSocketModeClient
+
+from strideutils.stride_config import get_env_or_raise as get_env_or_raise
+
+@dataclass
+class SlackMessage:
+    timestamp: datetime.datetime
+    timestamp_id: str
+    thread_ts: str | None
+    sender: str
+    text: str
+    @classmethod
+    def from_dict(cls, message: dict): ...
+
+class SlackClient:
+    def __new__(cls): ...
+    api_token: Incomplete
+    client: Incomplete
+    socket_mode_client: Incomplete
+    def __init__(self) -> None: ...
+    app_token: Incomplete
+    def setup_for_listening(self) -> None: ...
+    def post_message(
+        self, message: str | list[str], channel: str, botname: str | None = None, thread_ts: str | None = None
+    ): ...
+    def upload_file(self, file_name: str, content: str) -> str: ...
+    def listen_to_channel(
+        self, message_callback: Callable[[BaseSocketModeClient, dict], None], target_channel: str
+    ) -> None: ...
+    def get_prior_messages_in_channel(
+        self, channel: str, limit: int = 200, max_age: int = -1
+    ) -> list[list[SlackMessage]]: ...

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils-stubs/stride_config.pyi

@@ -14,6 +14,7 @@ class Environment:
     TWILIO_ACCOUNT_ID = ...
     TWILIO_API_TOKEN = ...
     STRIDEBOT_API_TOKEN = ...
+    STRIDEBOT_APP_TOKEN = ...
     SLACK_CHANNEL_OVERRIDE = ...
     PUBLICSHEETS_AUTH = ...
     COINGECKO_API_TOKEN = ...
@@ -79,10 +80,11 @@ class Config(ConfigObj):
     @property
     def app_chains(self) -> list[ChainConfig]: ...
     @property
+    def chains(self) -> list[ChainConfig]: ...
+    @property
     def host_zone_names(self) -> list[str]: ...
     @property
     def app_chain_names(self) -> list[str]: ...
-    def __post_init__(self) -> None: ...
     def get_chain(
         self,
         name: str | None = None,
@@ -90,7 +92,7 @@ class Config(ConfigObj):
         ticker: str | None = None,
         denom: str | None = None,
         denom_on_stride: str | None = None,
-    ) -> ChainConfig | StrideChainConfig | HostChainConfig: ...
+    ) -> ChainConfig: ...
     def get_host_chain(
         self,
         name: str | None = None,

{strideutils-0.8.4 → strideutils-0.8.6}/strideutils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strideutils
-Version: 0.8.4
+Version: 0.8.6
 Summary: Utility functions for monitoring the Stride blockchain
 Author-email: Stride Labs <hello@stridelabs.co>
 License: MIT License

{strideutils-0.8.4 → strideutils-0.8.6}/tests/test_config.py

@@ -222,13 +222,13 @@ class TestParseConfig:
         assert isinstance(host_chain, HostChainConfig)
 
         # Test looking up stride (should fail)
-        with pytest.raises(TypeError, match="Chain stride is not a host zone"):
+        with pytest.raises(KeyError, match="No host chain found for the given parameter"):
             config.get_host_chain(name="stride")
 
         # Test looking up an app chain (should fail)
-        with pytest.raises(TypeError, match="Chain neutron is not a host zone"):
+        with pytest.raises(KeyError, match="No host chain found for the given parameter"):
             config.get_host_chain(name="neutron")
 
         # Test looking up non-existent chain
-        with pytest.raises(KeyError, match="No chain found for the given parameter"):
-            config.get_host_chain(name="non-existent")
+        with pytest.raises(KeyError, match="No host chain found for the given parameter"):
+            config.get_host_chain(name="no-exist")

strideutils-0.8.4/strideutils/slack_connector.py

@@ -1,147 +0,0 @@
-import os
-import traceback
-from typing import List, Optional, Union
-
-from slack_sdk import WebClient
-from slack_sdk.errors import SlackApiError
-
-from strideutils.stride_config import Environment as e
-from strideutils.stride_config import config, get_env_or_raise
-
-
-class SlackClient:
-    """
-    Singleton client used to post messages to slack
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        # Creates a new instance if one does not already exist
-        if cls._instance is None:
-            cls._instance = super(SlackClient, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        # Prevent re-initialization if a client has already been created
-        if hasattr(self, "client"):
-            return
-
-        self.api_token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
-        self.client = WebClient(token=self.api_token)
-
-    def post_message(
-        self,
-        message: Union[str, List[str]],
-        channel: str,
-        botname: Optional[str] = None,
-        thread_ts: Optional[str] = None,
-    ):
-        """
-        Posts a slack message to the given channel
-        If the message is an array, this will post each element of the array as a thread
-
-        Returns the thread_ts to allow chaining messages
-        """
-        # Allow optional channel overrides via an environment variable
-        channel = os.environ.get(e.SLACK_CHANNEL_OVERRIDE, default=channel)
-
-        # Listify
-        messages = [message] if type(message) is str else message
-
-        # Post each message, threading with the previous
-        thread_ts = None or thread_ts
-        for msg in messages:
-            response = self.client.chat_postMessage(
-                channel=channel,
-                text=msg,
-                thread_ts=thread_ts,
-                username=botname,
-            )
-            if thread_ts is None:  # API advises to use parent IDs instead of child's
-                thread_ts = response["ts"]
-
-        return thread_ts
-
-    def upload_file(self, file_name: str, content: str) -> str:
-        """
-        This uploads a file and returns a link that can be used to embed a file in slack
-        Ex:
-            url = upload_file("test.txt", "Hello World")
-            post_msg(f"<{url}|This is a file>", channel="#alerts-debug")
-        """
-        slack_file = self.client.files_upload_v2(filename=file_name, content=content)
-        file_link = slack_file["file"]["permalink"]
-        return file_link
-
-
-# TODO: Remove after all launchpad instances are removed
-def post_msg(
-    txt: Union[str, List[str]],
-    channel: str,
-    botname: Optional[str] = None,
-    unfurl_links: bool = False,
-    unfurl_media: bool = False,
-    thread_ts: Optional[str] = None,
-):
-    """
-    DEPRECATED: Use slack client instead
-
-    Posts a slack message to the given channel, e.g.
-
-        post_msg('hello world', 'general')
-
-    if txt is an array, this will post each element of the array as a thread
-
-    Args:
-      username: Rename stridebot
-    """
-    token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
-    client = WebClient(token=token)
-    channel = config.slack_channels.get(channel.replace('#', ''), channel)
-    channel = os.environ.get('SLACK_CHANNEL_OVERRIDE', default=channel)
-
-    # Listify
-    messages = [txt] if type(txt) is str else txt
-
-    # thread ts keeps track of the latest thread ID so we can keep replying in-thread
-    thread_ts = None or thread_ts
-    for msg in messages:
-        try:
-            response = client.chat_postMessage(
-                channel=channel,
-                text=msg,
-                thread_ts=thread_ts,
-                username=botname,
-                unfurl_links=unfurl_links,
-                unfurl_media=unfurl_media,
-            )
-            if thread_ts is None:  # API advises to use parent IDs instead of child's
-                thread_ts = response['ts']
-        except SlackApiError as error:
-            print("Error sending message: ", error)
-            raise
-    return thread_ts
-
-
-def upload_file(file_name: str, content: str) -> str:
-    """
-    DEPRECATED: Use slack client instead
-
-    This uploads a file called "file_name" with the string contents "content"
-
-    This will return a link that can be used to embed a file in slack.
-    For example:
-        url = upload_file("test.txt", "Hello World")
-        post_msg(f"<{url}|This is a file>", channel="#alerts-debug")
-    """
-    token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
-    client = WebClient(token=token)
-    try:
-        slack_file = client.files_upload_v2(filename=file_name, content=content)
-    except Exception as error:
-        print(f"Error uploading file to slack: {error}")
-        traceback.print_exc()
-        raise ValueError(f"Error uploading file to slack: {error}")
-    file_link = slack_file['file']['permalink']
-    return file_link

strideutils-0.8.4/strideutils/slack_connector.pyi

@@ -1,13 +0,0 @@
-from _typeshed import Incomplete
-from strideutils.stride_config import config as config, get_env_or_raise as get_env_or_raise
-
-class SlackClient:
-    def __new__(cls): ...
-    api_token: Incomplete
-    client: Incomplete
-    def __init__(self) -> None: ...
-    def post_message(self, message: str | list[str], channel: str, botname: str | None = None, thread_ts: str | None = None): ...
-    def upload_file(self, file_name: str, content: str) -> str: ...
-
-def post_msg(txt: str | list[str], channel: str, botname: str | None = None, unfurl_links: bool = False, unfurl_media: bool = False, thread_ts: str | None = None): ...
-def upload_file(file_name: str, content: str) -> str: ...

strideutils-0.8.4/strideutils-stubs/slack_connector.pyi

@@ -1,24 +0,0 @@
-from _typeshed import Incomplete
-
-from strideutils.stride_config import config as config
-from strideutils.stride_config import get_env_or_raise as get_env_or_raise
-
-class SlackClient:
-    def __new__(cls): ...
-    api_token: Incomplete
-    client: Incomplete
-    def __init__(self) -> None: ...
-    def post_message(
-        self, message: str | list[str], channel: str, botname: str | None = None, thread_ts: str | None = None
-    ): ...
-    def upload_file(self, file_name: str, content: str) -> str: ...
-
-def post_msg(
-    txt: str | list[str],
-    channel: str,
-    botname: str | None = None,
-    unfurl_links: bool = False,
-    unfurl_media: bool = False,
-    thread_ts: str | None = None,
-): ...
-def upload_file(file_name: str, content: str) -> str: ...