superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty-python/tests/test_types.py

@@ -0,0 +1,553 @@
+import pytest
+from inline_snapshot import snapshot
+
+import pydantic_monty
+
+
+def test_none_input():
+    m = pydantic_monty.Monty('x is None', inputs=['x'])
+    assert m.run(inputs={'x': None}) is True
+
+
+def test_none_output():
+    m = pydantic_monty.Monty('None')
+    assert m.run() is None
+
+
+def test_bool_true():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': True})
+    assert result is True
+    assert type(result) is bool
+
+
+def test_bool_false():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': False})
+    assert result is False
+    assert type(result) is bool
+
+
+def test_int():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': 42}) == snapshot(42)
+    assert m.run(inputs={'x': -100}) == snapshot(-100)
+    assert m.run(inputs={'x': 0}) == snapshot(0)
+
+
+def test_float():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': 3.14}) == snapshot(3.14)
+    assert m.run(inputs={'x': -2.5}) == snapshot(-2.5)
+    assert m.run(inputs={'x': 0.0}) == snapshot(0.0)
+
+
+def test_string():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': 'hello'}) == snapshot('hello')
+    assert m.run(inputs={'x': ''}) == snapshot('')
+    assert m.run(inputs={'x': 'unicode: éè'}) == snapshot('unicode: éè')
+
+
+def test_bytes():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': b'hello'}) == snapshot(b'hello')
+    assert m.run(inputs={'x': b''}) == snapshot(b'')
+    assert m.run(inputs={'x': b'\x00\x01\x02'}) == snapshot(b'\x00\x01\x02')
+
+
+def test_list():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': [1, 2, 3]}) == snapshot([1, 2, 3])
+    assert m.run(inputs={'x': []}) == snapshot([])
+    assert m.run(inputs={'x': ['a', 'b']}) == snapshot(['a', 'b'])
+
+
+def test_tuple():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': (1, 2, 3)}) == snapshot((1, 2, 3))
+    assert m.run(inputs={'x': ()}) == snapshot(())
+    assert m.run(inputs={'x': ('a',)}) == snapshot(('a',))
+
+
+def test_dict():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': {'a': 1, 'b': 2}}) == snapshot({'a': 1, 'b': 2})
+    assert m.run(inputs={'x': {}}) == snapshot({})
+
+
+def test_set():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': {1, 2, 3}}) == snapshot({1, 2, 3})
+    assert m.run(inputs={'x': set()}) == snapshot(set())
+
+
+def test_frozenset():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    assert m.run(inputs={'x': frozenset([1, 2, 3])}) == snapshot(frozenset({1, 2, 3}))
+    assert m.run(inputs={'x': frozenset()}) == snapshot(frozenset())
+
+
+def test_ellipsis_input():
+    m = pydantic_monty.Monty('x is ...', inputs=['x'])
+    assert m.run(inputs={'x': ...}) is True
+
+
+def test_ellipsis_output():
+    m = pydantic_monty.Monty('...')
+    assert m.run() is ...
+
+
+def test_nested_list():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    nested = [[1, 2], [3, [4, 5]]]
+    assert m.run(inputs={'x': nested}) == snapshot([[1, 2], [3, [4, 5]]])
+
+
+def test_nested_dict():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    nested = {'a': {'b': {'c': 1}}}
+    assert m.run(inputs={'x': nested}) == snapshot({'a': {'b': {'c': 1}}})
+
+
+def test_mixed_nested():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    mixed = {'list': [1, 2], 'tuple': (3, 4), 'nested': {'set': {5, 6}}}
+    result = m.run(inputs={'x': mixed})
+    assert result['list'] == snapshot([1, 2])
+    assert result['tuple'] == snapshot((3, 4))
+    assert result['nested']['set'] == snapshot({5, 6})
+
+
+def test_list_output():
+    m = pydantic_monty.Monty('[1, 2, 3]')
+    assert m.run() == snapshot([1, 2, 3])
+
+
+def test_dict_output():
+    m = pydantic_monty.Monty("{'a': 1, 'b': 2}")
+    assert m.run() == snapshot({'a': 1, 'b': 2})
+
+
+def test_tuple_output():
+    m = pydantic_monty.Monty('(1, 2, 3)')
+    assert m.run() == snapshot((1, 2, 3))
+
+
+def test_set_output():
+    m = pydantic_monty.Monty('{1, 2, 3}')
+    assert m.run() == snapshot({1, 2, 3})
+
+
+# === Exception types ===
+
+
+def test_exception_input():
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    exc = ValueError('test error')
+    result = m.run(inputs={'x': exc})
+    assert isinstance(result, ValueError)
+    assert str(result) == snapshot('test error')
+
+
+def test_exception_output():
+    m = pydantic_monty.Monty('ValueError("created")')
+    result = m.run()
+    assert isinstance(result, ValueError)
+    assert str(result) == snapshot('created')
+
+
+@pytest.mark.parametrize('exc_class', [ValueError, TypeError, RuntimeError, AttributeError], ids=repr)
+def test_exception_roundtrip(exc_class: type[Exception]):
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    exc = exc_class('message')
+    result = m.run(inputs={'x': exc})
+    assert type(result) is exc_class
+    assert str(result) == snapshot('message')
+
+
+def test_exception_subclass_input():
+    """Custom exception subtypes are converted to their nearest supported base."""
+
+    class MyError(ValueError):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    exc = MyError('custom')
+    result = m.run(inputs={'x': exc})
+    # Custom exception becomes ValueError (nearest supported type)
+    assert type(result) is ValueError
+    assert str(result) == snapshot('custom')
+
+
+# === Subtype coercion ===
+# Monty converts Python subclasses to their base types since it doesn't
+# have Python's class system.
+
+
+def test_int_subclass_input():
+    class MyInt(int):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': MyInt(42)})
+    assert type(result) is int
+    assert result == snapshot(42)
+
+
+def test_str_subclass_input():
+    class MyStr(str):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': MyStr('hello')})
+    assert type(result) is str
+    assert result == snapshot('hello')
+
+
+def test_list_subclass_input():
+    class MyList(list[int]):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': MyList([1, 2, 3])})
+    assert type(result) is list
+    assert result == snapshot([1, 2, 3])
+
+
+def test_dict_subclass_input():
+    class MyDict(dict[str, int]):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': MyDict({'a': 1})})
+    assert type(result) is dict
+    assert result == snapshot({'a': 1})
+
+
+def test_tuple_subclass_input():
+    class MyTuple(tuple[int, ...]):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': MyTuple((1, 2))})
+    assert type(result) is tuple
+    assert result == snapshot((1, 2))
+
+
+def test_set_subclass_input():
+    class MySet(set[int]):
+        pass
+
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': MySet({1, 2})})
+    assert type(result) is set
+    assert result == snapshot({1, 2})
+
+
+def test_bool_preserves_type():
+    """Bool is a subclass of int but should be preserved as bool."""
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': True})
+    assert type(result) is bool
+    assert result is True
+
+
+def test_return_int():
+    m = pydantic_monty.Monty('x = 4\ntype(x)')
+    result = m.run()
+    assert result is int
+
+    m = pydantic_monty.Monty('int')
+    result = m.run()
+    assert result is int
+
+
+def test_return_exception():
+    m = pydantic_monty.Monty('x = ValueError()\ntype(x)')
+    result = m.run()
+    assert result is ValueError
+
+    m = pydantic_monty.Monty('ValueError')
+    result = m.run()
+    assert result is ValueError
+
+
+def test_return_builtin():
+    m = pydantic_monty.Monty('len')
+    result = m.run()
+    assert result is len
+
+
+# === BigInt (arbitrary precision integers) ===
+
+
+def test_bigint_input():
+    """Passing a large integer (> i64::MAX) as input."""
+    big = 2**100
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': big})
+    assert result == big
+    assert type(result) is int
+
+
+def test_bigint_output():
+    """Returning a large integer computed inside Monty."""
+    m = pydantic_monty.Monty('2**100')
+    result = m.run()
+    assert result == 2**100
+    assert type(result) is int
+
+
+def test_bigint_negative_input():
+    """Passing a large negative integer as input."""
+    big_neg = -(2**100)
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': big_neg})
+    assert result == big_neg
+    assert type(result) is int
+
+
+def test_int_overflow_to_bigint():
+    """Small int input that overflows to bigint during computation."""
+    max_i64 = 9223372036854775807
+    m = pydantic_monty.Monty('x + 1', inputs=['x'])
+    result = m.run(inputs={'x': max_i64})
+    assert result == max_i64 + 1
+    assert type(result) is int
+
+
+def test_bigint_arithmetic():
+    """BigInt arithmetic operations."""
+    big = 2**100
+    m = pydantic_monty.Monty('x * 2 + y', inputs=['x', 'y'])
+    result = m.run(inputs={'x': big, 'y': big})
+    assert result == big * 2 + big
+    assert type(result) is int
+
+
+def test_bigint_comparison():
+    """Comparing bigints with regular ints."""
+    big = 2**100
+    m = pydantic_monty.Monty('x > y', inputs=['x', 'y'])
+    assert m.run(inputs={'x': big, 'y': 42}) is True
+    assert m.run(inputs={'x': 42, 'y': big}) is False
+
+
+def test_bigint_in_collection():
+    """BigInts inside collections."""
+    big = 2**100
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': [big, 42, big * 2]})
+    assert result == [big, 42, big * 2]
+    assert type(result[0]) is int
+
+
+def test_bigint_as_dict_key():
+    """BigInt as dictionary key."""
+    big = 2**100
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result = m.run(inputs={'x': {big: 'value'}})
+    assert result == {big: 'value'}
+    assert big in result
+
+
+def test_bigint_hash_consistency_small_values():
+    """Hash of small values computed as BigInt must match regular int hash.
+
+    This is critical for dict key lookups: inserting with int and looking up
+    with a computed BigInt (or vice versa) must work correctly.
+    """
+    # Value 42 computed via BigInt arithmetic
+    big = 2**100
+    m = pydantic_monty.Monty('(x - x) + 42', inputs=['x'])
+    computed_42 = m.run(inputs={'x': big})
+
+    # Hash must match
+    assert hash(computed_42) == hash(42), 'hash of computed int must match literal'
+
+    # Dict lookup must work both ways
+    d = {42: 'value'}
+    assert d[computed_42] == 'value', 'lookup with computed bigint finds int key'
+
+    d2 = {computed_42: 'value'}
+    assert d2[42] == 'value', 'lookup with int finds computed bigint key'
+
+
+def test_bigint_hash_consistency_boundary():
+    """Hash consistency at i64 boundary values."""
+    max_i64 = 9223372036854775807
+
+    # Compute MAX_I64 via BigInt arithmetic
+    m = pydantic_monty.Monty('(x - 1)', inputs=['x'])
+    computed_max = m.run(inputs={'x': max_i64 + 1})
+
+    assert hash(computed_max) == hash(max_i64), 'hash at MAX_I64 boundary must match'
+
+
+def test_bigint_hash_consistency_large_values():
+    """Equal large BigInts must hash the same."""
+    big1 = 2**100
+    big2 = 2**100
+
+    # Verify they hash the same in Python first
+    assert hash(big1) == hash(big2), 'precondition: equal bigints hash same in Python'
+
+    # Verify hashes match after round-trip through Monty
+    m = pydantic_monty.Monty('x', inputs=['x'])
+    result1 = m.run(inputs={'x': big1})
+    result2 = m.run(inputs={'x': big2})
+
+    assert hash(result1) == hash(result2), 'equal bigints from Monty must hash same'
+
+    # Dict lookup must work
+    d = {result1: 'value'}
+    assert d[result2] == 'value', 'lookup with equal bigint works'
+
+
+# === NamedTuple output ===
+
+
+def test_namedtuple_sys_version_info():
+    """sys.version_info returns a proper namedtuple with attribute access."""
+    m = pydantic_monty.Monty('import sys; sys.version_info')
+    result = m.run()
+
+    # Should have named attribute access
+    assert hasattr(result, 'major')
+    assert hasattr(result, 'minor')
+    assert hasattr(result, 'micro')
+    assert hasattr(result, 'releaselevel')
+    assert hasattr(result, 'serial')
+
+    # Values should match Monty's Python version (3.14)
+    assert result.major == snapshot(3)
+    assert result.minor == snapshot(14)
+    assert result.micro == snapshot(0)
+    assert result.releaselevel == snapshot('final')
+    assert result.serial == snapshot(0)
+
+
+def test_namedtuple_sys_version_info_index_access():
+    """sys.version_info supports both index and attribute access."""
+    m = pydantic_monty.Monty('import sys; sys.version_info')
+    result = m.run()
+
+    # Index access should work
+    assert result[0] == result.major
+    assert result[1] == result.minor
+    assert result[2] == result.micro
+
+
+def test_namedtuple_sys_version_info_tuple_comparison():
+    """sys.version_info can be compared to tuples."""
+    m = pydantic_monty.Monty('import sys; (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)')
+    result = m.run()
+    assert result == snapshot((3, 14, 0))
+
+
+# === User-defined NamedTuple input ===
+
+
+def test_namedtuple_custom_input_attribute_access():
+    """User-defined NamedTuple with custom field names can be accessed by attribute."""
+    from typing import NamedTuple
+
+    class Person(NamedTuple):
+        name: str
+        age: int
+
+    m = pydantic_monty.Monty('p.name', inputs=['p'])
+    assert m.run(inputs={'p': Person(name='Alice', age=30)}) == snapshot('Alice')
+
+    m = pydantic_monty.Monty('p.age', inputs=['p'])
+    assert m.run(inputs={'p': Person(name='Alice', age=30)}) == snapshot(30)
+
+
+def test_namedtuple_custom_input_index_access():
+    """User-defined NamedTuple supports both attribute and index access."""
+    from typing import NamedTuple
+
+    class Point(NamedTuple):
+        x: int
+        y: int
+
+    m = pydantic_monty.Monty('p[0] + p[1]', inputs=['p'])
+    assert m.run(inputs={'p': Point(x=10, y=20)}) == snapshot(30)
+
+
+def test_namedtuple_custom_input_multiple_fields():
+    """NamedTuple with multiple custom field names works correctly."""
+    from typing import NamedTuple
+
+    class Config(NamedTuple):
+        host: str
+        port: int
+        debug: bool
+        timeout: float
+
+    m = pydantic_monty.Monty("f'{c.host}:{c.port}'", inputs=['c'])
+    result = m.run(inputs={'c': Config(host='localhost', port=8080, debug=True, timeout=30.0)})
+    assert result == snapshot('localhost:8080')
+
+    m = pydantic_monty.Monty('c.debug', inputs=['c'])
+    result = m.run(inputs={'c': Config(host='localhost', port=8080, debug=True, timeout=30.0)})
+    assert result is True
+
+
+def test_namedtuple_custom_input_repr():
+    """User-defined NamedTuple has correct repr with fully-qualified type name."""
+    from typing import NamedTuple
+
+    class Item(NamedTuple):
+        name: str
+        price: float
+
+    m = pydantic_monty.Monty('repr(item)', inputs=['item'])
+    result = m.run(inputs={'item': Item(name='widget', price=9.99)})
+    # Monty uses the full qualified name (module.ClassName) for the type
+    assert result == snapshot("test_types.Item(name='widget', price=9.99)")
+
+
+def test_namedtuple_custom_input_len():
+    """User-defined NamedTuple supports len()."""
+    from typing import NamedTuple
+
+    class Triple(NamedTuple):
+        a: int
+        b: int
+        c: int
+
+    m = pydantic_monty.Monty('len(t)', inputs=['t'])
+    assert m.run(inputs={'t': Triple(a=1, b=2, c=3)}) == snapshot(3)
+
+
+def test_namedtuple_custom_input_roundtrip():
+    """User-defined NamedTuple can be passed through and returned."""
+    from typing import NamedTuple
+
+    class Pair(NamedTuple):
+        first: int
+        second: int
+
+    m = pydantic_monty.Monty('p', inputs=['p'])
+    result = m.run(inputs={'p': Pair(first=1, second=2)})
+    # Returns a namedtuple-like object (not the same Python class)
+    assert result[0] == snapshot(1)
+    assert result[1] == snapshot(2)
+    assert result.first == snapshot(1)
+    assert result.second == snapshot(2)
+
+
+def test_namedtuple_custom_missing_attr_error():
+    """Accessing non-existent attribute on custom NamedTuple raises AttributeError."""
+    from typing import NamedTuple
+
+    class Simple(NamedTuple):
+        value: int
+
+    m = pydantic_monty.Monty('s.nonexistent', inputs=['s'])
+    with pytest.raises(pydantic_monty.MontyRuntimeError) as exc_info:
+        m.run(inputs={'s': Simple(value=42)})
+    # Monty uses the full qualified name (module.ClassName) for the type
+    assert "AttributeError: 'test_types.Simple' object has no attribute 'nonexistent'" in str(exc_info.value)

package/ref-monty/crates/monty-type-checking/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "monty_type_checking"
+readme = "../../README.md"
+version = { workspace = true }
+rust-version = { workspace = true }
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+description = { workspace = true }
+keywords = { workspace = true }
+categories = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+
+[lib]
+name = "monty_type_checking"
+path = "src/lib.rs"
+
+[dependencies]
+monty_typeshed = { path = "../monty-typeshed" }
+ruff_python_ast = { workspace = true }
+ruff_db = { workspace = true }
+ruff_text_size = { workspace = true }
+ty_python_semantic = { workspace = true }
+ty_module_resolver = { workspace = true }
+salsa = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }
+
+[lints]
+workspace = true

package/ref-monty/crates/monty-type-checking/src/db.rs

@@ -0,0 +1,116 @@
+use std::{fmt, sync::Arc};
+
+use ruff_db::{
+    Db as SourceDb,
+    files::{File, Files},
+    system::{DbWithTestSystem, System, TestSystem},
+    vendored::VendoredFileSystem,
+};
+use ruff_python_ast::PythonVersion;
+use ty_module_resolver::{Db as ModuleResolverDb, SearchPaths};
+use ty_python_semantic::{
+    AnalysisSettings, Db, Program, default_lint_registry,
+    lint::{LintRegistry, RuleSelection},
+};
+
+/// Very simple in-memory salsa/ty database.
+///
+/// Mostly taken from
+/// https://github.com/astral-sh/ruff/blob/7bacca9b625c2a658470afd99a0bf0aa0b4f1dbb/crates/ty_python_semantic/src/db.rs#L51
+#[salsa::db]
+#[derive(Clone)]
+pub(crate) struct MemoryDb {
+    storage: salsa::Storage<Self>,
+    files: Files,
+    system: TestSystem,
+    vendored: VendoredFileSystem,
+    rule_selection: Arc<RuleSelection>,
+    analysis_settings: Arc<AnalysisSettings>,
+}
+
+impl fmt::Debug for MemoryDb {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TypeCheckingFailure")
+            .field("files", &self.files)
+            .field("system", &self.system)
+            .field("vendored", &self.vendored)
+            .field("rule_selection", &self.rule_selection)
+            .field("analysis_settings", &self.analysis_settings)
+            .finish_non_exhaustive()
+    }
+}
+
+impl MemoryDb {
+    pub fn new() -> Self {
+        Self {
+            storage: salsa::Storage::new(None),
+            system: TestSystem::default(),
+            vendored: monty_typeshed::file_system().clone(),
+            files: Files::default(),
+            rule_selection: Arc::new(RuleSelection::from_registry(default_lint_registry())),
+            analysis_settings: AnalysisSettings::default().into(),
+        }
+    }
+}
+
+impl DbWithTestSystem for MemoryDb {
+    fn test_system(&self) -> &TestSystem {
+        &self.system
+    }
+
+    fn test_system_mut(&mut self) -> &mut TestSystem {
+        &mut self.system
+    }
+}
+
+#[salsa::db]
+impl SourceDb for MemoryDb {
+    fn vendored(&self) -> &VendoredFileSystem {
+        &self.vendored
+    }
+
+    fn system(&self) -> &dyn System {
+        &self.system
+    }
+
+    fn files(&self) -> &Files {
+        &self.files
+    }
+
+    fn python_version(&self) -> PythonVersion {
+        PythonVersion::PY314
+    }
+}
+
+#[salsa::db]
+impl Db for MemoryDb {
+    fn should_check_file(&self, file: File) -> bool {
+        !file.path(self).is_vendored_path()
+    }
+
+    fn rule_selection(&self, _file: File) -> &RuleSelection {
+        &self.rule_selection
+    }
+
+    fn lint_registry(&self) -> &LintRegistry {
+        default_lint_registry()
+    }
+
+    fn analysis_settings(&self, _file: File) -> &AnalysisSettings {
+        &self.analysis_settings
+    }
+
+    fn verbose(&self) -> bool {
+        false
+    }
+}
+
+#[salsa::db]
+impl ModuleResolverDb for MemoryDb {
+    fn search_paths(&self) -> &SearchPaths {
+        Program::get(self).search_paths(self)
+    }
+}
+
+#[salsa::db]
+impl salsa::Database for MemoryDb {}

package/ref-monty/crates/monty-type-checking/src/lib.rs

@@ -0,0 +1,4 @@
+mod db;
+mod type_check;
+
+pub use crate::type_check::{SourceFile, TypeCheckingDiagnostics, type_check};