strideutils 0.7.8__tar.gz → 0.7.10__tar.gz

{strideutils-0.7.8 → strideutils-0.7.10}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.7.8
+current_version = 0.7.10
 commit = False
 tag = False
 

{strideutils-0.7.8 → strideutils-0.7.10}/.github/workflows/publish.yml

@@ -23,7 +23,7 @@ jobs:
       - name: setup 
         run: |
             python -m pip install -U pip
-            pip install --upgrade build setuptools twine wheel bump2version toml-cli 
+            pip install --upgrade build setuptools twine wheel bump2version toml-cli mypy
             git config user.name "GitHub Actions"
             git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
 
@@ -55,5 +55,7 @@ jobs:
           TWINE_USERNAME: "__token__"
           TWINE_PASSWORD: "${{ secrets.PYPI_TOKEN }}"
         run: |
+            stubgen -m strideutils -o ./strideutils
+            echo "include strideutils/*.pyi" >> MANIFEST.in
             python -m build
-            twine upload dist/*
+            twine upload dist/*

{strideutils-0.7.8 → strideutils-0.7.10}/.github/workflows/test.yml

@@ -12,6 +12,8 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
+    env:
+      ENV: DEV
     steps:
       - uses: actions/checkout@v3
 
@@ -26,4 +28,4 @@ jobs:
           pip install -e .[dev]
 
       - name: Run tests
-        run: pytest tests -v
+        run: pytest tests -v

strideutils-0.7.10/MANIFEST.in

@@ -0,0 +1 @@
+include strideutils/*.pyi

{strideutils-0.7.8 → strideutils-0.7.10}/Makefile

@@ -21,9 +21,6 @@ format:
 
 tidy: lint type-check format
 
-stub-gen:
-	$(PYTHON) run stubgen -p strideutils -o pyi
-
 test:
 	@echo "Running unit tests..."
 	@$(VENV_BIN)/pytest . -v

{strideutils-0.7.8 → strideutils-0.7.10}/PKG-INFO

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

{strideutils-0.7.8 → strideutils-0.7.10}/pyproject.toml

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

strideutils-0.7.10/strideutils/exec_tx.py

@@ -0,0 +1,62 @@
+import json
+import re
+import subprocess
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+from strideutils import stride_requests
+from strideutils.stride_config import config
+
+
+@dataclass
+class TxResponse:
+    stdout: dict
+    stderr: str
+    tx_hash: str = ""
+    success: bool = False
+    code: Optional[int] = None
+    tx_response: Optional[dict] = None
+    raw_log: Optional[str] = None
+
+
+def execute_tx(command: str, api_endpoint: str = config.stride.api_endpoint) -> TxResponse:
+    """
+    Execute a tx and query the tx hash
+    """
+    # Tack on the auto-confirm if it's not already in the command and capture the output as JSON
+    if "-y" not in command:
+        command += " -y"
+    command += " --output json"
+
+    # Run the command in the shell and store the response
+    output = subprocess.run(command, shell=True, capture_output=True, text=True)
+
+    # If there was stderr, return the response as failed
+    if not output.stdout or output.stderr:
+        return TxResponse(stdout={}, stderr=output.stderr, raw_log=output.stderr)
+
+    # Cast the stdout and build the response
+    response = TxResponse(stdout=json.loads(output.stdout), stderr=output.stderr)
+
+    # Get the tx hash or return an error if one was not generated
+    response.tx_hash = response.stdout.get("txhash", "")
+    if response.tx_hash == "":
+        response.raw_log = "Tx hash not found after running tx"
+        return response
+
+    # Poll the tx hash for the codeID and raw log
+    for _ in range(30):
+        response_data = stride_requests.get_tx(response.tx_hash, api_endpoint=api_endpoint)
+        if not response_data.get("tx_response"):
+            time.sleep(2)
+            continue
+
+        response.code = int(response_data["tx_response"]["code"])
+        response.raw_log = response_data["tx_response"]["raw_log"]
+        response.success = response.code == 0
+        return response
+
+    # If the tx was never found on chain, return an error
+    response.raw_log = "Transaction not found on chain after one minute"
+    return response

{strideutils-0.7.8 → strideutils-0.7.10}/strideutils/redis_connector.py

@@ -63,37 +63,31 @@ ALL_DATABASE_NAMES = list(DATABASE_ENVIRONMENT_CONFIGS.keys())
 
 
 class RedisClient:
-    """Singleton client used to interact with Redis databases."""
+    """Redis client to connect to multiple databases at once"""
 
-    _instance = None
+    # Mapping of database name to redis client
     _dbs: Dict[str, redis.Redis] = {}
 
-    def __new__(cls, db_names: Optional[List[str] | str] = None):
-        if cls._instance is None:
-            cls._instance = super(RedisClient, cls).__new__(cls)
-            cls._instance.__init__(db_names)
-        return cls._instance
-
-    def __init__(self, db_names: Optional[List[str] | str] = None):
-        if len(self._dbs) == 0:
-            self._init_dbs(db_names)
-
-    def _init_dbs(self, db_name_or_names: Optional[List[str] | str] = None):
+    def __init__(self, db_name_or_names: Optional[List[str] | str] = None):
         """
         Initializes Redis database connections.
 
         Args:
-            db_names: Optional database name or list of database names to initialize.
-                      If None, initializes all databases.
+            db_name_or_names: Optional database name or list of database names to initialize.
+                          If None, initializes all databases.
 
         Raises:
-            ValueError: If db_names is an empty list or contains invalid database names.
+            ValueError: If db_name_or_names is an empty list or contains invalid database names.
         """
-        db_names = [db_name_or_names] if type(db_name_or_names) is str else db_name_or_names
+        self._dbs: Dict[str, redis.Redis] = {}
+
+        db_names = [db_name_or_names] if isinstance(db_name_or_names, str) else db_name_or_names
+
         if db_names is not None and len(db_names) == 0:
-            raise ValueError("db_names cannot be an empty list")
+            raise ValueError("db_name_or_names cannot be an empty list")
 
         db_names = db_names or ALL_DATABASE_NAMES
+
         invalid_db_names = [name for name in db_names if name not in ALL_DATABASE_NAMES]
         if invalid_db_names:
             raise ValueError(f"Invalid Redis database names: {invalid_db_names}")

{strideutils-0.7.8 → strideutils-0.7.10}/strideutils/stride_config.py

@@ -218,9 +218,6 @@ class Config(ConfigObj):
     ENV: str
     timezone: str = "US/Eastern"
 
-    # Gsheets - loads from str env var in PROD
-    PUBLICSHEETS_AUTH: Union[str, ConfigDict] = field(default_factory=ConfigDict)
-
     # Coingecko
     COINGECKO_API_TOKEN: str = ""
 
@@ -231,15 +228,6 @@ class Config(ConfigObj):
     alerts_playbook: str = ""
     slack_channels: ConfigDict = field(default_factory=ConfigDict)
 
-    # Upstash
-    UPSTASH_PUBLIC_PASSWORD: str = ""
-    UPSTASH_STRIDE_FRONTEND_PASSWORD: str = ""
-    UPSTASH_STRIDE_BACKEND_PASSWORD: str = ""
-    UPSTASH_STRIDE_DYDX_PUBLIC_PASSWORD: str = ""
-    UPSTASH_STRIDE_DYDX_AIRDROP_PASSWORD: str = ""
-    UPSTASH_STRIDE_SAGA_AIRDROP_PASSWORD: str = ""
-    UPSTASH_STRIDE_MILESTONES_PASSWORD: str = ""
-
     # Stride internal secrets
     SLACK_BEARER_TOKEN: str = ""
     SLACK_SUCCESS_CHANNEL_ID: str = ""

{strideutils-0.7.8 → strideutils-0.7.10}/strideutils.egg-info/PKG-INFO

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

{strideutils-0.7.8 → strideutils-0.7.10}/strideutils.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 .bumpversion.cfg
 .gitignore
 LICENSE
+MANIFEST.in
 Makefile
 README.md
 pyproject.toml
@@ -30,6 +31,7 @@ strideutils.egg-info/requires.txt
 strideutils.egg-info/top_level.txt
 strideutils/config_examples/env.local.example
 strideutils/config_examples/strideutils_config.yaml.example
+strideutils/strideutils/__init__.pyi
 tests/test_config.py
 tests/test_encryption.py
 tests/test_redis_connector.py

{strideutils-0.7.8 → strideutils-0.7.10}/tests/test_redis_connector.py

@@ -4,9 +4,7 @@ from strideutils.redis_connector import RedisClient
 
 @pytest.fixture(autouse=True)
 def reset_redis_client():
-    RedisClient._reset()
     yield
-    RedisClient._reset()
 
 @pytest.fixture
 def mock_redis():
@@ -36,10 +34,18 @@ def redis_client(mock_redis, mock_env_vars):
     client = RedisClient()
     return client
 
-def test_redis_client_singleton():
-    client1 = RedisClient()
-    client2 = RedisClient()
-    assert client1 is client2
+
+def test_redis_client_non_singleton():
+    """Test that each RedisClient instance is independent"""
+    client1 = RedisClient(['public'])
+    client2 = RedisClient(['frontend'])
+
+    # Different instances
+    assert client1 is not client2
+
+    # Different database connections
+    assert set(client1._dbs.keys()) == {'public'}
+    assert set(client2._dbs.keys()) == {'frontend'}
 
 def test_init_with_specific_dbs():
     client = RedisClient(['public', 'frontend'])

{strideutils-0.7.8 → strideutils-0.7.10}/tests/test_sheets_connector.py

@@ -58,7 +58,7 @@ def test_sheets_write_sheet_new_worksheet(sheets_client):
     df = pd.DataFrame({'A': [1, 3], 'B': [2, 4]})
     sheets_client.write_sheet(df, 'sheet_id', 'new_sheet')
 
-    mock_spreadsheet.add_worksheet.assert_called_once_with(title='new_sheet', rows="1", cols="1")
+    mock_spreadsheet.add_worksheet.assert_called_once_with(title='new_sheet', rows=1, cols=1)
 
 def test_sheets_reorder_sheet(sheets_client):
     mock_spreadsheet = MagicMock()

strideutils-0.7.10/tests/test_twilio_connector.py

@@ -0,0 +1,92 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from twilio.rest import Client as TwilioRestClient
+from strideutils.twilio_connector import TwilioClient
+from strideutils.stride_config import Environment as e
+
+@pytest.fixture(autouse=True)
+def reset_twilio_client():
+    TwilioClient._instance = None
+    yield
+    TwilioClient._instance = None
+
+@pytest.fixture
+def mock_twilio_rest_client():
+    with patch('strideutils.twilio_connector.Client') as mock:
+        mock_instance = MagicMock()
+        mock.return_value = mock_instance
+        yield mock_instance
+
+@pytest.fixture(autouse=True)
+def mock_env_vars():
+    with patch('strideutils.twilio_connector.get_env_or_raise') as mock_get_env:
+        def side_effect(arg):
+            if arg == e.TWILIO_ACCOUNT_ID:
+                return 'fake_account_id'
+            elif arg == e.TWILIO_API_TOKEN:
+                return 'fake_api_token'
+            elif arg == e.TWILIO_ALERTS_NUMBER:
+                return 'fake_alert_numbers'
+            return 'dummy_value'
+        mock_get_env.side_effect = side_effect
+        yield mock_get_env
+
+@pytest.fixture
+def twilio_client(mock_twilio_rest_client, mock_env_vars):
+    client = TwilioClient()
+    return client
+
+def test_twilio_client_singleton():
+    client1 = TwilioClient()
+    client2 = TwilioClient()
+    assert client1 is client2
+
+def test_twilio_client_initialization(twilio_client, mock_env_vars):
+    assert twilio_client.account_id == 'fake_account_id'
+    assert twilio_client.api_token == 'fake_api_token'
+    assert twilio_client.alert_numbers == 'fake_alert_numbers'
+    assert isinstance(twilio_client.client, MagicMock)
+
+def test_call_single_recipient(twilio_client, mock_twilio_rest_client):
+    with patch('strideutils.twilio_connector.config') as mock_config:
+        mock_config.PHONE_NUMBERS = {'recipient': '+12223334444'}
+        mock_config.TWILIO_ALERTS_NUMBER = '+15556667777'
+
+        twilio_client.call("Test message", "recipient")
+
+        expected_twiml = "<Response><Say>Test message</Say></Response>"
+        mock_twilio_rest_client.calls.create.assert_called_once_with(
+            to='+12223334444',
+            from_='+15556667777',
+            twiml=expected_twiml
+        )
+
+def test_call_multiple_recipients(twilio_client, mock_twilio_rest_client):
+    with patch('strideutils.twilio_connector.config') as mock_config:
+        mock_config.PHONE_NUMBERS = {
+            'recipient1': '+12223334444',
+            'recipient2': '+13334445555'
+        }
+        mock_config.TWILIO_ALERTS_NUMBER = '+15556667777'
+
+        twilio_client.call("Test message", ["recipient1", "recipient2"])
+
+        expected_twiml = "<Response><Say>Test message</Say></Response>"
+        assert mock_twilio_rest_client.calls.create.call_count == 2
+        mock_twilio_rest_client.calls.create.assert_any_call(
+            to='+12223334444',
+            from_='+15556667777',
+            twiml=expected_twiml
+        )
+        mock_twilio_rest_client.calls.create.assert_any_call(
+            to='+13334445555',
+            from_='+15556667777',
+            twiml=expected_twiml
+        )
+
+def test_call_invalid_recipient(twilio_client, mock_twilio_rest_client):
+    with patch('strideutils.twilio_connector.config') as mock_config:
+        mock_config.PHONE_NUMBERS = {}
+
+        with pytest.raises(KeyError):
+            twilio_client.call("Test message", "invalid_recipient")

strideutils-0.7.8/strideutils/exec_tx.py

@@ -1,62 +0,0 @@
-import re
-import subprocess
-import time
-from dataclasses import dataclass
-from typing import Optional
-
-from strideutils import stride_requests
-from strideutils.stride_config import config
-
-
-@dataclass
-class TxResponse:
-    stdout: str
-    stderr: str
-    tx_response: Optional[dict] = None
-    tx_hash: Optional[str] = None
-    success: bool = False
-    raw_log: Optional[str] = None
-
-
-def execute_tx(command: str, api_endpoint: str = config.stride.api_endpoint, verbose=False) -> TxResponse:
-    """
-    Execute a tx and query the tx hash
-    """
-    output = subprocess.run(command, shell=True, capture_output=True)
-    standard_out = re.sub(r'\x1b\[[0-9;]*[mGKH]', '', output.stdout.decode('utf-8'))
-    error_out = re.sub(r'\x1b\[[0-9;]*[mGKH]', '', output.stderr.decode('utf-8'))
-    if verbose:
-        print("Standard Out: ", standard_out)
-        print("Error Out: ", error_out)
-    tx_hash = ""
-    for output_line in standard_out.split('\n'):
-        if 'txhash' in output_line:
-            tx_hash = output_line.split(': ')[-1]
-
-    tx_response = None
-    response_success = False
-    raw_log = "Transaction not found on chain after one minute"  # default message
-    if not error_out:
-        event_filters = [(f"tx.hash='{tx_hash}'")]
-        for _ in range(30):
-            time.sleep(2)
-            tx_response = stride_requests.get_txs(event_filters, api_endpoint)
-            if tx_response.get('tx_responses'):
-                try:
-                    response_code = tx_response['tx_responses'][0]['code']
-                    raw_log = tx_response['tx_responses'][0]['raw_log']
-                    response_success = response_code == 0
-                except KeyError:
-                    response_success = False
-                break
-
-    success = response_success and not error_out
-    response = TxResponse(
-        stdout=standard_out,
-        stderr=error_out,
-        tx_response=tx_response,
-        success=success,
-        tx_hash=tx_hash,
-        raw_log=raw_log,
-    )
-    return response

strideutils-0.7.8/tests/test_twilio_connector.py

@@ -1,80 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-from twilio.rest import Client as TwilioRestClient
-
-from strideutils.twilio_connector import TwilioClient
-
-@pytest.fixture
-def mock_twilio_client():
-    with patch('strideutils.twilio_connector.Client') as mock_client:
-        yield mock_client.return_value
-
-@pytest.fixture
-def twilio_client(mock_twilio_client):
-    with patch('strideutils.twilio_connector.get_env_or_raise') as mock_get_env:
-        mock_get_env.side_effect = ['fake_account_id', 'fake_api_token', 'fake_alert_numbers']
-        client = TwilioClient()
-        client.client = mock_twilio_client  # Replaced the real Twilio client with a mock, to not send to the real.
-        yield client
-
-def test_twilio_client_singleton():
-    with patch('strideutils.twilio_connector.Client'):
-        with patch('strideutils.twilio_connector.get_env_or_raise'):
-            client1 = TwilioClient()
-            client2 = TwilioClient()
-            assert client1 is client2
-
-def test_call_single_recipient(twilio_client, mock_twilio_client):
-    with patch('strideutils.twilio_connector.config') as mock_config:
-        mock_config.PHONE_NUMBERS = {'recipient': '+12223334444'}
-        mock_config.TWILIO_ALERTS_NUMBER = '+15556667777'
-
-        twilio_client.call("Test message", "recipient")
-
-        expected_twiml = "<Response><Say>Test message</Say></Response>"
-        mock_twilio_client.calls.create.assert_called_once_with(
-            to='+12223334444',
-            from_='+15556667777',
-            twiml=expected_twiml
-        )
-
-def test_call_multiple_recipients(twilio_client, mock_twilio_client):
-    with patch('strideutils.twilio_connector.config') as mock_config:
-        mock_config.PHONE_NUMBERS = {
-            'recipient1': '+12223334444',
-            'recipient2': '+13334445555'
-        }
-        mock_config.TWILIO_ALERTS_NUMBER = '+15556667777'
-
-        twilio_client.call("Test message", ["recipient1", "recipient2"])
-
-        expected_twiml = "<Response><Say>Test message</Say></Response>"
-        assert mock_twilio_client.calls.create.call_count == 2
-        mock_twilio_client.calls.create.assert_any_call(
-            to='+12223334444',
-            from_='+15556667777',
-            twiml=expected_twiml
-        )
-        mock_twilio_client.calls.create.assert_any_call(
-            to='+13334445555',
-            from_='+15556667777',
-            twiml=expected_twiml
-        )
-
-def test_call_invalid_recipient(twilio_client, mock_twilio_client):
-    with patch('strideutils.twilio_connector.config') as mock_config:
-        mock_config.PHONE_NUMBERS = {}
-
-        with pytest.raises(KeyError):
-            twilio_client.call("Test message", "invalid_recipient")
-
-@patch('strideutils.twilio_connector.get_env_or_raise')
-def test_twilio_client_initialization(mock_get_env):
-    mock_get_env.side_effect = ['fake_account_id', 'fake_api_token', 'fake_alert_numbers']  # just dummy values, so this should fail.
-
-    client = TwilioClient()
-
-    assert client.account_id == 'fake_account_id'
-    assert client.api_token == 'fake_api_token'
-    assert client.alert_numbers == 'fake_alert_numbers'
-    assert isinstance(client.client, TwilioRestClient)