fix: lint

Author: naaive

openagent/agent/config.py

@@ -35,12 +35,16 @@ def validate_celery_urls(cls, v, values):
 
 
 class TaskConfig(BaseModel):
-    interval: Optional[int] = Field(default=None, description="Interval in seconds between task executions")
+    interval: Optional[int] = Field(
+        default=None, description="Interval in seconds between task executions"
+    )
     delay_variation: Optional[int] = Field(
         default=0, description="Maximum random delay in seconds to add to the interval"
     )
     query: str
-    cron: Optional[str] = Field(default=None, description="Cron expression for scheduling tasks")
+    cron: Optional[str] = Field(
+        default=None, description="Cron expression for scheduling tasks"
+    )
     schedule: SchedulerConfig = Field(
         default_factory=lambda: SchedulerConfig(type="local"),
         description="Scheduler configuration for this task",

openagent/agent/scheduler.py

@@ -33,6 +33,7 @@ def init_scheduled_tasks(self, tasks_config: dict, task_runner):
             if task_config.schedule.type == "queue":
                 self._init_celery_task(task_id, task_config, task_runner)
             else:
+
                 async def task_wrapper(query, delay_variation):
                     if delay_variation > 0:
                         delay = random.uniform(0, delay_variation)
@@ -48,7 +49,9 @@ async def task_wrapper(query, delay_variation):
                         id=task_id,
                         name=f"Task_{task_id}",
                     )
-                    logger.info(f"Scheduled cron task '{task_id}' with cron expression: {task_config.cron}")
+                    logger.info(
+                        f"Scheduled cron task '{task_id}' with cron expression: {task_config.cron}"
+                    )
                 else:
                     self.scheduler.add_job(
                         func=task_wrapper,

openagent/core/database/engine.py

@@ -1,5 +1,3 @@
-import os
-from typing import Optional, Literal
 from urllib.parse import urlparse
 
 from sqlalchemy import create_engine as sa_create_engine, text as sa_text, Engine
@@ -9,10 +7,10 @@
 def _create_sqlite_engine(db_url: str) -> Engine:
     """
     Create a SQLite engine from a URL.
-    
+
     Args:
         db_url: SQLite database URL (sqlite:///path/to/file.db)
-        
+
     Returns:
         SQLAlchemy engine instance
     """
@@ -23,7 +21,7 @@ def _ensure_postgres_database_exists(db_url: str) -> None:
     """
     Ensure that the PostgreSQL database specified in the URL exists.
     Creates the database if it doesn't exist.
-    
+
     Args:
         db_url: PostgreSQL database URL
     """
@@ -39,10 +37,10 @@ def _ensure_postgres_database_exists(db_url: str) -> None:
     try:
         # Check if database exists
         result = default_conn.execute(
-            sa_text(f"SELECT 1 FROM pg_database WHERE datname = :db_name"), 
-            {"db_name": pg_db_name}
+            sa_text("SELECT 1 FROM pg_database WHERE datname = :db_name"),
+            {"db_name": pg_db_name},
         )
-        
+
         if not result.scalar():
             # Create database if it doesn't exist
             default_conn.execute(sa_text("commit"))
@@ -59,10 +57,10 @@ def _create_postgres_engine(db_url: str) -> Engine:
     """
     Create a PostgreSQL engine from a URL.
     Ensures the database exists before creating the engine.
-    
+
     Args:
         db_url: PostgreSQL database URL
-        
+
     Returns:
         SQLAlchemy engine instance
     """
@@ -74,25 +72,27 @@ def create_engine(db_url: str) -> Engine:
     """
     Create a database engine based on the provided configuration.
     Database type is automatically detected from the URL.
-    
+
     Args:
-        db_url: Database URL. For postgres: postgresql://user:password@host:port/database, 
+        db_url: Database URL. For postgres: postgresql://user:password@host:port/database,
                 for sqlite: sqlite:///path/to/file.db
-            
+
     Returns:
         SQLAlchemy engine instance
-    
+
     Raises:
         ValueError: If an unsupported database type is detected or if db_url is missing
     """
     if not db_url:
         raise ValueError("Database URL is required")
-    
+
     # Auto-detect database type from URL
-    if db_url.startswith('sqlite:'):
+    if db_url.startswith("sqlite:"):
         return _create_sqlite_engine(db_url)
-    elif db_url.startswith('postgresql:'):
+    elif db_url.startswith("postgresql:"):
         return _create_postgres_engine(db_url)
     else:
-        raise ValueError(f"Could not detect database type from URL: {db_url}. "
-                        "Supported URL formats: 'sqlite:///path/to/file.db' or 'postgresql://user:password@host:port/database'") 
+        raise ValueError(
+            f"Could not detect database type from URL: {db_url}. "
+            "Supported URL formats: 'sqlite:///path/to/file.db' or 'postgresql://user:password@host:port/database'"
+        )

openagent/tools/pendle/market_analysis.py

@@ -5,12 +5,11 @@
 from heapq import nlargest
 from typing import Optional, Literal
 
-import httpx
 from pydantic import BaseModel, Field
 from textwrap import dedent
 from loguru import logger
 
-from sqlalchemy import Column, Integer, String, DateTime, text as sa_text
+from sqlalchemy import Column, Integer, String, DateTime
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
 from langchain.prompts import PromptTemplate
@@ -54,13 +53,13 @@ class PendleMarket(Base):
 
 class DatabaseConfig(BaseModel):
     """Database configuration for the tool"""
+
     type: Literal["sqlite", "postgres"] = Field(
-        default="sqlite",
-        description="Type of database to use"
+        default="sqlite", description="Type of database to use"
     )
     url: Optional[str] = Field(
         default=None,
-        description="Database URL. For postgres: postgresql://user:password@host:port/database, for sqlite: sqlite:///path/to/file.db"
+        description="Database URL. For postgres: postgresql://user:password@host:port/database, for sqlite: sqlite:///path/to/file.db",
     )
 
 
@@ -73,7 +72,7 @@ class PendleMarketConfig(BaseModel):
     )
     db_url: Optional[str] = Field(
         default=None,
-        description="Database URL. For postgres: postgresql://user:password@host:port/database, for sqlite: sqlite:///path/to/file.db"
+        description="Database URL. For postgres: postgresql://user:password@host:port/database, for sqlite: sqlite:///path/to/file.db",
     )
 
 
@@ -91,7 +90,9 @@ def _init_database(self, db_url: Optional[str]) -> None:
         """Initialize database connection based on configuration"""
         # Set default configuration if not provided
         if not db_url:
-            db_url = 'sqlite:///' + os.path.join(os.getcwd(), "storage", f"{self.name}.db")
+            db_url = "sqlite:///" + os.path.join(
+                os.getcwd(), "storage", f"{self.name}.db"
+            )
 
         # Create engine using the database module's create_engine function
         engine = create_engine(db_url)
@@ -233,16 +234,22 @@ def _process_market_data(results: dict) -> PendleMarketSnapshot:
         new_markets = [market for market in markets if market.isNewPool]
         existing_markets = [market for market in markets if not market.isNewPool]
 
-        def get_top_markets(markets: list[PendleMarketData], key_attr: str, n: int = 3) -> list[PendleMarketData]:
+        def get_top_markets(
+            markets: list[PendleMarketData], key_attr: str, n: int = 3
+        ) -> list[PendleMarketData]:
             """Helper function to get top n markets based on a specific attribute"""
-            filtered_markets = [m for m in markets if m and getattr(m, key_attr) is not None]
+            filtered_markets = [
+                m for m in markets if m and getattr(m, key_attr) is not None
+            ]
             return nlargest(n, filtered_markets, key=lambda x: getattr(x, key_attr))
 
         # Get top markets for both liquidity and APY
-        liquidity_increase = get_top_markets(existing_markets, 'liquidityChange24h')
-        new_market_liquidity_increase = get_top_markets(new_markets, 'liquidityChange24h')
-        apy_increase = get_top_markets(existing_markets, 'impliedApyChange24h')
-        new_market_apy_increase = get_top_markets(new_markets, 'impliedApyChange24h')
+        liquidity_increase = get_top_markets(existing_markets, "liquidityChange24h")
+        new_market_liquidity_increase = get_top_markets(
+            new_markets, "liquidityChange24h"
+        )
+        apy_increase = get_top_markets(existing_markets, "impliedApyChange24h")
+        new_market_apy_increase = get_top_markets(new_markets, "impliedApyChange24h")
 
         # Extract symbols from sorted markets in one step
         liquidity_increase_top_symbols = {
@@ -258,10 +265,10 @@ def get_top_markets(markets: list[PendleMarketData], key_attr: str, n: int = 3)
 
         # Combine all relevant symbols
         relevant_symbols = (
-                liquidity_increase_top_symbols
-                | new_market_liquidity_increase_symbols
-                | apy_increase_symbols
-                | new_market_apy_increase_symbols
+            liquidity_increase_top_symbols
+            | new_market_liquidity_increase_symbols
+            | apy_increase_symbols
+            | new_market_apy_increase_symbols
         )
 
         # Filter markets to include only those in the relevant symbols set

openagent/tools/pendle/voter_apy_analysis.py

@@ -3,7 +3,6 @@
 from textwrap import dedent
 from typing import Optional
 
-import httpx
 from langchain.chat_models import init_chat_model
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import StrOutputParser
@@ -47,7 +46,7 @@ def __init__(self, core_model=None):
         self.core_model = core_model
         self.tool_model = None
         self.tool_prompt = None
-        db_url = 'sqlite:///' + os.path.join(os.getcwd(), "storage", f"{self.name}.db")
+        db_url = "sqlite:///" + os.path.join(os.getcwd(), "storage", f"{self.name}.db")
         self.engine = create_engine(db_url)
         Base.metadata.create_all(self.engine)
         session = sessionmaker(bind=self.engine)
@@ -182,7 +181,9 @@ def extract_pool_info(item: dict) -> dict:
             change_direction = (
                 "increased"
                 if last_epoch_change > 0
-                else "decreased" if last_epoch_change < 0 else "unchanged"
+                else "decreased"
+                if last_epoch_change < 0
+                else "unchanged"
             )
 
             # Convert to percentage strings, use absolute value for lastEpochChange

openagent/tools/twitter/feed.py

@@ -80,7 +80,7 @@ def __init__(self):
         self.retry_delay = 1
 
         # Initialize database
-        db_url = 'sqlite:///' + os.path.join(os.getcwd(), "storage", f"{self.name}.db")
+        db_url = "sqlite:///" + os.path.join(os.getcwd(), "storage", f"{self.name}.db")
         self.engine = create_engine(db_url)
         Base.metadata.create_all(self.engine)
         Session = sessionmaker(bind=self.engine)
@@ -99,7 +99,7 @@ async def setup(self, config: TwitterFeedConfig) -> None:
         self.config = config
 
     async def _fetch_single_handle(
-            self, client: httpx.AsyncClient, handle: str
+        self, client: httpx.AsyncClient, handle: str
     ) -> List[dict]:
         """Fetch tweets for a single handle with retry logic"""
         params = {"limit": self.config.limit if self.config else 50}

test/tools/test_pendle_market.py

@@ -1,20 +1,15 @@
 import asyncio
 
-from sqlalchemy.testing.config import db_url
 
 from openagent.agent.config import ModelConfig
-from openagent.tools.pendle.market_analysis import PendleMarketTool, PendleMarketConfig, DatabaseConfig
+from openagent.tools.pendle.market_analysis import PendleMarketTool, PendleMarketConfig
 
 
 async def test_pendle_market():
     # Initialize configuration
     config = PendleMarketConfig(
-        model=ModelConfig(
-            provider="openai",
-            name="gpt-4",
-            temperature=0.7
-        ),
-        db_url='sqlite:///storage/test_pendle_market.db'
+        model=ModelConfig(provider="openai", name="gpt-4", temperature=0.7),
+        db_url="sqlite:///storage/test_pendle_market.db",
     )
 
     # Initialize the tool
@@ -30,12 +25,8 @@ async def test_pendle_market():
 async def test_pendle_market_postgres():
     # Initialize configuration with PostgreSQL
     config = PendleMarketConfig(
-        model=ModelConfig(
-            provider="openai",
-            name="gpt-4",
-            temperature=0.7
-        ),
-        db_url='postgresql://postgres:password@localhost:5434/pendle_market_test'
+        model=ModelConfig(provider="openai", name="gpt-4", temperature=0.7),
+        db_url="postgresql://postgres:password@localhost:5434/pendle_market_test",
     )
 
     # Initialize the tool