Bump ty to 0.0.25 and fix all type checker errors (jaredlockhart#860)

ty 0.0.25 introduced stricter checking. Changes:

- Replace `**kwargs: object` with `**kwargs: Any` in agent subclasses
  (HistoryAgent, ThinkingAgent, NotifyAgent, ScheduleExecutor)
- Narrow `raise last_error` with assert in OllamaClient retry loops
- Add assert narrowing for optional command_registry and SQLModel IDs
- Fix dict.get type errors in search.py quota error detection
- Downgrade unresolved-attribute to warn in ty config (SQLModel column
  descriptor methods like .desc()/.asc()/.in_() are false positives)
- Add ty: ignore for SQLModel order_by() false positives
- Remove 37 stale `# type: ignore[unresolved-attribute]` comments from
  database stores (now handled by ty rule config)

Co-authored-by: Jared Lockhart <119884+jaredlockhart@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 3 people

penny-team/pyproject.toml

@@ -22,7 +22,7 @@ packages = []
 [dependency-groups]
 dev = [
     "ruff>=0.8.0",
-    "ty>=0.0.1,<0.0.25",
+    "ty>=0.0.25",
     "pytest>=8.0.0",
 ]
 

penny/penny/agents/history.py

@@ -10,6 +10,7 @@
 
 import logging
 from datetime import UTC, datetime, timedelta
+from typing import Any
 
 from pydantic import BaseModel
 from pydantic import Field as PydanticField
@@ -77,9 +78,9 @@ class HistoryAgent(Agent):
     def get_max_steps(self) -> int:
         return PennyConstants.HISTORY_MAX_STEPS
 
-    def __init__(self, **kwargs: object) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         kwargs["system_prompt"] = Prompt.SUMMARIZE_TO_BULLETS
-        super().__init__(**kwargs)  # type: ignore[arg-type]
+        super().__init__(**kwargs)
 
     async def _build_system_prompt(self, user: str) -> str:
         """Instructions only — no identity, profile, history, thoughts, or dislikes.
@@ -433,8 +434,9 @@ def _handle_dedup_match(
             if matched.id in already_bumped:
                 logger.debug("Skipping already-bumped preference: '%s'", matched.content[:50])
                 return
-            self.db.preferences.increment_mention_count(matched.id)  # type: ignore[arg-type]
-            already_bumped.add(matched.id)  # type: ignore[arg-type]
+            assert matched.id is not None
+            self.db.preferences.increment_mention_count(matched.id)
+            already_bumped.add(matched.id)
             logger.info(
                 "Preference '%s' mention count incremented (matches '%s')",
                 topic[:50],

penny/penny/agents/notify.py

@@ -16,7 +16,7 @@
 import random
 import re
 from datetime import UTC, datetime
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, Field
 
@@ -275,8 +275,8 @@ def get_max_steps(self) -> int:
         """Read from config so /config changes take effect immediately."""
         return int(self.config.runtime.MESSAGE_MAX_STEPS)
 
-    def __init__(self, **kwargs: object) -> None:
-        super().__init__(**kwargs)  # type: ignore[arg-type]
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self._boot_time = datetime.now(UTC).replace(tzinfo=None)
         self._channel: MessageChannel | None = None
         self._pending_thought: Thought | None = None

penny/penny/agents/thinking.py

@@ -9,6 +9,7 @@
 
 import logging
 import random
+from typing import Any
 
 from penny.agents.base import Agent
 from penny.agents.models import ChatMessage, MessageRole
@@ -50,9 +51,9 @@ class ThinkingAgent(Agent):
 
     name = "inner_monologue"
 
-    def __init__(self, **kwargs: object) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         kwargs["system_prompt"] = Prompt.THINKING_SYSTEM_PROMPT
-        super().__init__(**kwargs)  # type: ignore[arg-type]
+        super().__init__(**kwargs)
         self._keep_tools_on_final_step = True
         self._seed_topic: str | None = None
         self._seed_pref_id: int | None = None

penny/penny/channels/base.py

@@ -499,14 +499,16 @@ async def _execute_command(
         self, message: IncomingMessage, command_name: str, command_args: str
     ) -> None:
         """Execute a known command with typing indicator and send the result."""
-        command = self._command_registry.get(command_name)  # type: ignore[union-attr]
+        assert self._command_registry is not None
+        command = self._command_registry.get(command_name)
         typing_task = asyncio.create_task(self._typing_loop(message.sender))
         try:
             context = self._command_context
             context.user = message.sender
             context.message = message
 
-            result = await command.execute(command_args, context)  # type: ignore[union-attr]
+            assert command is not None
+            result = await command.execute(command_args, context)
             response = result.text
 
             prepared = self.prepare_outgoing(response) if response else ""

penny/penny/commands/preference_base.py

@@ -104,7 +104,8 @@ def _delete_preference(
             )
 
         to_delete = prefs[position - 1]
-        context.db.preferences.delete(to_delete.id)  # type: ignore[arg-type]
+        assert to_delete.id is not None
+        context.db.preferences.delete(to_delete.id)
 
         remaining = [p for p in prefs if p.id != to_delete.id]
         label = self.valence_config.label

penny/penny/commands/schedule.py

@@ -53,7 +53,7 @@ async def _list_schedules(self, context: CommandContext) -> CommandResult:
         with Session(context.db.engine) as session:
             schedules = list(
                 session.exec(
-                    select(Schedule).where(Schedule.user_id == context.user).order_by(Schedule.id)  # type: ignore[arg-type]
+                    select(Schedule).where(Schedule.user_id == context.user).order_by(Schedule.id)  # ty: ignore[invalid-argument-type]
                 )
             )
 

penny/penny/commands/unschedule.py

@@ -32,7 +32,7 @@ async def execute(self, args: str, context: CommandContext) -> CommandResult:
         with Session(context.db.engine) as session:
             schedules = list(
                 session.exec(
-                    select(Schedule).where(Schedule.user_id == context.user).order_by(Schedule.id)  # type: ignore[arg-type]
+                    select(Schedule).where(Schedule.user_id == context.user).order_by(Schedule.id)  # ty: ignore[invalid-argument-type]
                 )
             )
 

penny/penny/database/history_store.py

@@ -60,7 +60,7 @@ def get_latest(self, user: str, duration: str) -> ConversationHistory | None:
                     ConversationHistory.user == user,
                     ConversationHistory.duration == duration,
                 )
-                .order_by(ConversationHistory.period_start.desc())  # type: ignore[unresolved-attribute]
+                .order_by(ConversationHistory.period_start.desc())
                 .limit(1)
             ).first()
 
@@ -74,7 +74,7 @@ def get_recent(self, user: str, duration: str, limit: int = 14) -> list[Conversa
                         ConversationHistory.user == user,
                         ConversationHistory.duration == duration,
                     )
-                    .order_by(ConversationHistory.period_start.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(ConversationHistory.period_start.desc())
                     .limit(limit)
                 ).all()
             )
@@ -133,7 +133,7 @@ def get_in_range(
                         ConversationHistory.period_start >= start,
                         ConversationHistory.period_start < end,
                     )
-                    .order_by(ConversationHistory.period_start.asc())  # type: ignore[unresolved-attribute]
+                    .order_by(ConversationHistory.period_start.asc())
                 ).all()
             )
             return entries

penny/penny/database/message_store.py

@@ -185,7 +185,7 @@ def find_outgoing_by_content(self, content: str) -> MessageLog | None:
                     MessageLog.direction == PennyConstants.MessageDirection.OUTGOING,
                     MessageLog.content.startswith(content),
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
             ).first()
 
     # --- Thread context ---
@@ -234,9 +234,7 @@ def _walk_thread(self, message_id: int, limit: int = 20) -> list[MessageLog]:
     def get_conversation_leaves(self) -> list[MessageLog]:
         """Get outgoing leaf messages eligible for spontaneous continuation."""
         with self._session() as session:
-            has_child = select(MessageLog.parent_id).where(
-                MessageLog.parent_id.isnot(None)  # type: ignore[unresolved-attribute]
-            )
+            has_child = select(MessageLog.parent_id).where(MessageLog.parent_id.isnot(None))
             incoming_ids = select(MessageLog.id).where(
                 MessageLog.direction == PennyConstants.MessageDirection.INCOMING
             )
@@ -245,10 +243,10 @@ def get_conversation_leaves(self) -> list[MessageLog]:
                     select(MessageLog)
                     .where(
                         MessageLog.direction == PennyConstants.MessageDirection.OUTGOING,
-                        MessageLog.id.notin_(has_child),  # type: ignore[unresolved-attribute]
-                        MessageLog.parent_id.in_(incoming_ids),  # type: ignore[unresolved-attribute]
+                        MessageLog.id.notin_(has_child),
+                        MessageLog.parent_id.in_(incoming_ids),
                     )
-                    .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp.desc())
                 ).all()
             )
 
@@ -262,7 +260,7 @@ def get_user_messages(self, sender: str, limit: int = 100) -> list[MessageLog]:
                         MessageLog.sender == sender,
                         MessageLog.direction == PennyConstants.MessageDirection.INCOMING,
                     )
-                    .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp.desc())
                     .limit(limit)
                 ).all()
             )
@@ -289,7 +287,7 @@ def _get_recent_incoming(self, session: Any, sender: str, limit: int) -> list[Me
                     MessageLog.direction == PennyConstants.MessageDirection.INCOMING,
                     MessageLog.is_reaction == False,  # noqa: E712
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
                 .limit(limit)
             ).all()
         )
@@ -303,7 +301,7 @@ def _get_threaded_replies(self, session: Any, incoming: list[MessageLog]) -> lis
             session.exec(
                 select(MessageLog).where(
                     MessageLog.direction == PennyConstants.MessageDirection.OUTGOING,
-                    MessageLog.parent_id.in_(incoming_ids),  # type: ignore[unresolved-attribute]
+                    MessageLog.parent_id.in_(incoming_ids),
                 )
             ).all()
         )
@@ -320,7 +318,7 @@ def _get_autonomous_outgoing(
                     MessageLog.parent_id == None,  # noqa: E711
                     MessageLog.recipient == recipient,
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
                 .limit(limit)
             ).all()
         )
@@ -345,7 +343,7 @@ def get_messages_in_range(
                         MessageLog.timestamp >= start,
                         MessageLog.timestamp < end,
                     )
-                    .order_by(MessageLog.timestamp)  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp)  # ty: ignore[invalid-argument-type]
                 ).all()
             )
 
@@ -364,7 +362,7 @@ def get_reactions_in_range(
                         MessageLog.timestamp >= start,
                         MessageLog.timestamp < end,
                     )
-                    .order_by(MessageLog.timestamp)  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp)  # ty: ignore[invalid-argument-type]
                 ).all()
             )
 
@@ -382,7 +380,7 @@ def get_messages_since(
                         MessageLog.is_reaction == False,  # noqa: E712
                         MessageLog.timestamp >= since,
                     )
-                    .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp.desc())
                     .limit(limit)
                 ).all()
             )
@@ -396,7 +394,7 @@ def get_messages_since(
                         MessageLog.recipient == sender,
                         MessageLog.timestamp >= since,
                     )
-                    .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp.desc())
                     .limit(limit)
                 ).all()
             )
@@ -416,7 +414,7 @@ def get_unprocessed(self, sender: str, limit: int) -> list[MessageLog]:
                         MessageLog.is_reaction == False,  # noqa: E712
                         MessageLog.processed == False,  # noqa: E712
                     )
-                    .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp.desc())
                     .limit(limit)
                 ).all()
             )
@@ -433,7 +431,7 @@ def get_user_reactions(self, sender: str, limit: int) -> list[MessageLog]:
                         MessageLog.is_reaction == True,  # noqa: E712
                         MessageLog.processed == False,  # noqa: E712
                     )
-                    .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                    .order_by(MessageLog.timestamp.desc())
                     .limit(limit)
                 ).all()
             )
@@ -468,11 +466,9 @@ def count_active_threads(self) -> int:
         with self._session() as session:
             from sqlalchemy import func
 
-            has_child = select(MessageLog.parent_id).where(
-                MessageLog.parent_id.isnot(None)  # type: ignore[unresolved-attribute]
-            )
+            has_child = select(MessageLog.parent_id).where(MessageLog.parent_id.isnot(None))
             return session.exec(
-                select(func.count()).select_from(MessageLog).where(MessageLog.id.notin_(has_child))  # type: ignore[unresolved-attribute]
+                select(func.count()).select_from(MessageLog).where(MessageLog.id.notin_(has_child))
             ).one()
 
     def get_latest_incoming_time(self, sender: str) -> datetime | None:
@@ -485,7 +481,7 @@ def get_latest_incoming_time(self, sender: str) -> datetime | None:
                     MessageLog.direction == PennyConstants.MessageDirection.INCOMING,
                     MessageLog.is_reaction == False,  # noqa: E712
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
                 .limit(1)
             ).first()
 
@@ -499,7 +495,7 @@ def get_latest_autonomous_outgoing_time(self, recipient: str) -> datetime | None
                     MessageLog.parent_id == None,  # noqa: E711
                     MessageLog.recipient == recipient,
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
                 .limit(1)
             ).first()
 
@@ -533,10 +529,10 @@ def get_last_checkin_time(self, prompt_text: str, hours: int = 48) -> datetime |
             return session.exec(
                 select(PromptLog.timestamp)
                 .where(
-                    PromptLog.messages.contains(prompt_text),  # type: ignore[unresolved-attribute]
+                    PromptLog.messages.contains(prompt_text),
                     PromptLog.timestamp >= cutoff,
                 )
-                .order_by(PromptLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(PromptLog.timestamp.desc())
                 .limit(1)
             ).first()
 
@@ -553,7 +549,7 @@ def get_recent_outgoing_content(
                     MessageLog.recipient == recipient,
                     MessageLog.timestamp >= cutoff,
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
                 .limit(limit)
             ).all()
             return [m for m in messages if m]
@@ -577,7 +573,7 @@ def get_latest_message_time_in_range(
                     MessageLog.timestamp >= start,
                     MessageLog.timestamp < end,
                 )
-                .order_by(MessageLog.timestamp.desc())  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp.desc())
                 .limit(1)
             ).first()
 
@@ -591,6 +587,6 @@ def get_first_message_time(self, sender: str) -> datetime | None:
                     MessageLog.direction == PennyConstants.MessageDirection.INCOMING,
                     MessageLog.is_reaction == False,  # noqa: E712
                 )
-                .order_by(MessageLog.timestamp)  # type: ignore[unresolved-attribute]
+                .order_by(MessageLog.timestamp)  # ty: ignore[invalid-argument-type]
                 .limit(1)
             ).first()