python-skills 1.0.0__py3-none-any.whl

skills/testing/regression_tests.md

@@ -0,0 +1,165 @@
+# Testing: Regression Tests
+
+**Purpose**: Prevent previously fixed bugs from reappearing.
+
+**When to use**: Every bug fix, every behavior change, every refactoring.
+
+---
+
+## Core Rules
+
+### Every Bug Fix = Regression Test
+```python
+# Bug: User creation failed with uppercase email
+# Fix: Normalize email to lowercase
+
+def test_user_creation_normalizes_email(user_service):
+    """Regression: Issue #123 - uppercase email caused duplicate"""
+    user = user_service.create("USER@EXAMPLE.COM", "Test")
+    
+    assert user.email == "user@example.com"
+    
+    # Duplicate should still fail
+    with pytest.raises(ConflictError):
+        user_service.create("user@example.com", "Test 2")
+```
+
+### Regression Test Naming
+```python
+def test_issue_123_email_normalization():
+    ...
+
+def test_cve_2024_xxxx_sql_injection_prevented():
+    ...
+
+def test_fix_memory_leak_in_batch_processor():
+    ...
+
+def test_regression_double_submit_idempotency():
+    ...
+```
+
+### Test Location
+```
+tests/
+├── regression/
+│   ├── test_issue_123_email.py
+│   ├── test_cve_2024_xxxx.py
+│   └── test_pr_456_refactor.py
+```
+
+### Minimal Reproduction
+```python
+# Minimal test that reproduces the exact bug
+def test_issue_456_truncated_unicode():
+    """Regression: PR #456 - unicode truncation corrupted data"""
+    # Exact input that caused bug
+    input_data = "Hello \ud83d\ude00 World"  # Surrogate pair
+    
+    # Should handle gracefully, not corrupt
+    result = process_text(input_data)
+    
+    # Verify no corruption
+    assert "Hello" in result
+    assert "World" in result
+    # Original bug: result contained replacement chars or crashed
+```
+
+### Behavior Change Tests
+```python
+# When intentionally changing behavior
+def test_new_email_validation_allows_plus_tags():
+    """Behavior change: Issue #200 - allow plus tags in email"""
+    # Old behavior: rejected
+    # New behavior: accepts
+    user = create_user("user+tag@example.com", "Test")
+    assert user.email == "user+tag@example.com"
+
+# Document the change
+def test_old_email_validation_rejected_plus_tags():
+    """Old behavior (for reference)"""
+    # This test documents what USED to happen
+    # Keep for history, mark as xfail
+    import pytest
+    pytest.xfail("Old behavior - plus tags now allowed")
+    
+    with pytest.raises(ValidationError):
+        create_user("user+tag@example.com", "Test")
+```
+
+### Refactoring Regression
+```python
+# Before refactoring, capture behavior
+def test_refactor_order_calculation_preserves_results():
+    """Regression: Refactored OrderCalculator must produce identical results"""
+    test_cases = load_golden_master("order_calculator_golden.json")
+    
+    for case in test_cases:
+        result = OrderCalculator().calculate(case["input"])
+        assert result == case["expected"], f"Failed on case: {case['name']}"
+```
+
+---
+
+## Decision Rules
+
+| Trigger | Action |
+|---------|--------|
+| Bug reported | Write failing test, fix, test passes |
+| Security issue | Write test for attack vector |
+| Refactoring | Golden master tests / property tests |
+| Behavior change | Test new behavior, document old |
+| Dependency update | Test integration points |
+
+---
+
+## Preferred Patterns
+
+```python
+# Golden master for complex refactoring
+def test_parser_golden_master():
+    """Regression: Parser refactor must not change output"""
+    inputs = load_test_inputs("parser_inputs.json")
+    expected = load_expected_outputs("parser_expected.json")
+    
+    for inp, exp in zip(inputs, expected):
+        result = parse(inp)
+        assert result == exp, f"Mismatch for input: {inp}"
+
+# Property test as regression
+from hypothesis import given, strategies as st
+
+@given(st.dictionaries(st.text(), st.integers()))
+def test_config_merge_idempotent(config: dict):
+    """Regression: Config merge should be idempotent"""
+    merged_once = merge_configs(config, {})
+    merged_twice = merge_configs(merged_once, {})
+    assert merged_once == merged_twice
+```
+
+---
+
+## Avoid
+
+- Fixing bug without test
+- Deleting regression tests ("it works now")
+- Tests that don't actually reproduce the bug
+- Refactoring without behavior verification
+
+---
+
+## Validation Considerations
+
+- Run regression suite on every PR
+- Tag regression tests for easy filtering: `pytest -m regression`
+- Golden master files version controlled
+- CI fails if regression tests fail
+
+---
+
+## Related Skills
+
+- `testing/organization.md`
+- `testing/edge_cases.md`
+- `refactoring/safe_refactoring.md`
+- `generation/error_handling.md`

skills/variables_types.md

@@ -0,0 +1,107 @@
+# Core: Variables and Types
+
+**Purpose**: Fundamental Python variable and type knowledge for code generation.
+
+**When to use**: Always active. Foundation for all Python code generation.
+
+---
+
+## Core Rules
+
+### Variable Assignment
+- Variables are references to objects
+- Assignment binds a name to an object
+- Multiple assignment: `a = b = 1` (same object), `a, b = 1, 2` (tuple unpacking)
+- No declaration needed — assignment creates the variable
+
+### Primitive Types
+| Type | Literal | Immutable | Use For |
+|------|---------|-----------|---------|
+| `int` | `42`, `0b101`, `0x2A` | Yes | Whole numbers, arbitrary precision |
+| `float` | `3.14`, `1e-5` | Yes | Decimal numbers (IEEE 754) |
+| `bool` | `True`, `False` | Yes | Logic (subclass of `int`) |
+| `str` | `"text"`, `'text'`, `"""multiline"""` | Yes | Text (Unicode) |
+| `bytes` | `b"data"` | Yes | Binary data |
+| `None` | `None` | Yes | Absence of value |
+
+### Type Identity vs Equality
+- `is` — identity (same object in memory)
+- `==` — equality (value comparison)
+- Use `is` only for `None`, `True`, `False`, sentinel objects
+- Never use `is` for strings, numbers, or custom objects
+
+### Mutable vs Immutable
+**Immutable**: `int`, `float`, `bool`, `str`, `bytes`, `tuple`, `frozenset`, `None`
+**Mutable**: `list`, `dict`, `set`, `bytearray`, custom objects
+
+**Critical**: Mutable objects as default arguments create shared state (see anti-patterns)
+
+### Type Inspection
+```python
+type(obj)           # Exact type
+isinstance(obj, T)  # Type check (supports unions, inheritance)
+hasattr(obj, attr)  # Attribute existence
+```
+
+---
+
+## Decision Rules
+
+| Situation | Choice |
+|-----------|--------|
+| Need arbitrary precision integer | `int` (native) |
+| Need exact decimal arithmetic | `decimal.Decimal` |
+| Need fraction arithmetic | `fractions.Fraction` |
+| Text data | `str` |
+| Binary data / protocols | `bytes` |
+| Fixed collection of heterogeneous items | `tuple` or `NamedTuple` / `dataclass` |
+| Ordered, mutable collection | `list` |
+| Key-value mapping | `dict` |
+| Unique items, membership testing | `set` |
+| Immutable unique items | `frozenset` |
+
+---
+
+## Preferred Patterns
+
+```python
+# Type annotation for clarity (optional but recommended)
+count: int = 0
+name: str = "default"
+items: list[str] = []
+mapping: dict[str, int] = {}
+
+# Sentinel for "not provided" (not None)
+_SENTINEL = object()
+
+def func(arg=_SENTINEL):
+    if arg is _SENTINEL:
+        arg = compute_default()
+```
+
+---
+
+## Avoid
+
+- Using `is` for string/number comparison
+- Treating mutable objects as immutable
+- Assuming `bool` is only `True`/`False` (it's subclass of `int`)
+- Type inspection via `type(obj) == SomeClass` (use `isinstance`)
+- Chained assignment for mutable objects: `a = b = []` (both reference same list)
+
+---
+
+## Validation Considerations
+
+- Type checkers catch many primitive type errors
+- Runtime `isinstance` checks for external input
+- `mypy --strict` catches implicit `Any`
+
+---
+
+## Related Skills
+
+- `core/data_structures.md`
+- `core/functions.md` (mutable defaults)
+- `generation/type_hints.md`
+- `anti_patterns/index.md` (mutable defaults)