fix(model): 🐛 Enhance steps calculation in MainModel class

[SongshGeo]

This commit improves the calculation of the delta value in the MainModel class by explicitly retrieving the previous _steps value from the instance's dictionary. This change enhances clarity and ensures that the logic for advancing time is based on the correct previous state, thereby improving the integrity of the model's state management.

Summary by CodeRabbit

• Refactor
  • Optimized internal attribute access in the core model to improve performance while maintaining full backward compatibility.

[coderabbitai]

Walkthrough

The steps setter in MainModel is refactored to retrieve the previous steps value using direct dictionary access (__dict__.get()) instead of getattr(), while maintaining identical external behavior and logic flow.

Changes

Cohort / File(s)	Summary
MainModel steps setter refactoring abses/core/model.py	Changed internal attribute retrieval mechanism in steps setter from getattr() to direct __dict__ dictionary access for reading the previous _steps value

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~10 minutes

• Specific areas requiring attention:
  • Verify that direct __dict__.get() access doesn't inadvertently bypass any custom descriptors, properties, or metaclass behaviors that getattr() would have invoked
  • Confirm that the behavior is identical for edge cases (e.g., when _steps is not yet initialized, when it contains non-integer values, or during subclass instantiation)

Poem

🐰 Ah, a peek inside the dictionary deep,
Where __dict__ secrets we now keep!
No getattr's veil to intercede,
Direct access fulfills the need. ✨

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately summarizes the main change: using direct dictionary access instead of getattr() in the steps setter for improved state management clarity.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch dev

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 1

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between b50b771 and 9d688e4.

📒 Files selected for processing (1)

• abses/core/model.py (1 hunks)

🧰 Additional context used

📓 Path-based instructions (1)

**/*.py

📄 CodeRabbit inference engine (.cursorrules)

**/*.py: For any Python file, add typing annotations to every function and class, including explicit return types (use None where appropriate)
Add descriptive docstrings to all Python functions and classes; follow PEP 257 conventions and update existing docstrings as needed

Files:

• abses/core/model.py

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (11)

• GitHub Check: Tests 3.13 on windows-latest
• GitHub Check: Tests 3.12 on windows-latest
• GitHub Check: Tests 3.11 on windows-latest
• GitHub Check: Tests 3.11 on macos-latest
• GitHub Check: Tests 3.12 on macos-latest
• GitHub Check: Tests 3.11 on ubuntu-latest
• GitHub Check: Tests 3.13 on ubuntu-latest
• GitHub Check: Tests 3.13 on macos-latest
• GitHub Check: Tests 3.12 on ubuntu-latest
• GitHub Check: nbmake
• GitHub Check: nbmake

🔇 Additional comments (1)

abses/core/model.py (1)

184-185: Document why __dict__.get() is used instead of getattr(), and fix the type validation logic.

The change from getattr() to self.__dict__.get() is actually justified: MainModel inherits from BaseStateManager, which defines a __getattr__ method that delegates to modules or major_layer. Using getattr() could trigger this delegation when reading the old _steps value, causing unintended side effects. Direct dict access avoids this.

However, two issues remain:

1. Undocumented rationale: Add a comment explaining why direct dict access is necessary here to bypass __getattr__ delegation.

2. Type validation issue (lines 186-187): The isinstance(delta, int) check is redundant since steps is already type-hinted as int. If the intent is runtime validation, check steps directly before computing delta, and update the error message to report type(delta) for accuracy.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor

Type validation checks the wrong variable.

The type check validates delta (the computed difference) rather than the steps parameter. Since delta = steps - old_steps, if steps is a non-integer type, either:

1. Line 185 raises TypeError during subtraction (if steps is incompatible), or
2. delta becomes non-int (if steps is float-like), triggering the check on line 186

However, the error message reports type(steps), not type(delta), creating confusion. Validate steps directly before computing delta:

-    old_steps = self.__dict__.get("_steps", 0)
-    delta = steps - old_steps
     if not isinstance(delta, int):
         raise TypeError(f"Steps must be an integer, got {type(steps)}")
+    if not isinstance(steps, int):
+        raise TypeError(f"Steps must be an integer, got {type(steps)}")
+    old_steps = self.__dict__.get("_steps", 0)
+    delta = steps - old_steps
     if delta > 0:
         self.time.go(delta)

Note: The parameter already has a type hint (steps: int), so static type checkers should catch this, but explicit runtime validation at the correct point improves clarity.

Committable suggestion skipped: line range outside the PR's diff.

🤖 Prompt for AI Agents

abses/core/model.py around lines 186-187: the runtime type check currently
validates the computed variable `delta` and then raises an error mentioning
`type(steps)`, which is confusing and occurs too late; instead validate the
incoming `steps` parameter before computing `delta` by checking
isinstance(steps, int) and raise a TypeError that reports the actual type(steps)
if it fails, then compute `delta = steps - old_steps` as before.