more validations for UmbIndex

Author: randriu

tests/binary/test_sized_type.py

@@ -67,10 +67,10 @@ class TestSizedTypeValidation:
 
     def test_positive_size_required(self):
         """Test that size must be positive."""
-        with pytest.raises(AssertionError):
+        with pytest.raises(ValueError):
             SizedType(NumericPrimitiveType.UINT, 0)
 
-        with pytest.raises(AssertionError):
+        with pytest.raises(ValueError):
             SizedType(NumericPrimitiveType.UINT, -1)
 
     def test_string_must_be_64_bits(self):
@@ -147,3 +147,50 @@ def test_double_default_size(self):
         """Test default size for DOUBLE."""
         sized_type = SizedType.for_type(NumericPrimitiveType.DOUBLE)
         assert sized_type.size_bits == 64
+
+
+class TestSizedTypeNumericProperties:
+    """Test SizedType numeric classification properties."""
+
+    def test_is_numeric_for_numeric_types(self):
+        """Test is_numeric returns True for numeric types."""
+        assert SizedType(NumericPrimitiveType.INT, 32).is_numeric
+        assert SizedType(NumericPrimitiveType.UINT, 32).is_numeric
+        assert SizedType(NumericPrimitiveType.DOUBLE, 64).is_numeric
+        assert SizedType(NumericPrimitiveType.RATIONAL, 128).is_numeric
+
+    def test_is_numeric_for_primitive_types(self):
+        """Test is_numeric returns False for primitive types."""
+        assert not SizedType(PrimitiveType.BOOL, 1).is_numeric
+        assert not SizedType(PrimitiveType.STRING, 64).is_numeric
+
+    def test_is_discrete_for_discrete_types(self):
+        """Test is_discrete returns True for discrete numeric types."""
+        assert SizedType(NumericPrimitiveType.INT, 32).is_discrete
+        assert SizedType(NumericPrimitiveType.UINT, 32).is_discrete
+        assert SizedType(NumericPrimitiveType.INT, 64).is_discrete
+
+    def test_is_discrete_for_continuous_types(self):
+        """Test is_discrete returns False for continuous numeric types."""
+        assert not SizedType(NumericPrimitiveType.DOUBLE, 64).is_discrete
+        assert not SizedType(NumericPrimitiveType.RATIONAL, 128).is_discrete
+
+    def test_is_discrete_for_primitive_types(self):
+        """Test is_discrete returns False for primitive types."""
+        assert not SizedType(PrimitiveType.BOOL, 1).is_discrete
+        assert not SizedType(PrimitiveType.STRING, 64).is_discrete
+
+    def test_is_continuous_for_continuous_types(self):
+        """Test is_continuous returns True for continuous numeric types."""
+        assert SizedType(NumericPrimitiveType.DOUBLE, 64).is_continuous
+        assert SizedType(NumericPrimitiveType.RATIONAL, 128).is_continuous
+
+    def test_is_continuous_for_discrete_types(self):
+        """Test is_continuous returns False for discrete numeric types."""
+        assert not SizedType(NumericPrimitiveType.INT, 32).is_continuous
+        assert not SizedType(NumericPrimitiveType.UINT, 32).is_continuous
+
+    def test_is_continuous_for_primitive_types(self):
+        """Test is_continuous returns False for primitive types."""
+        assert not SizedType(PrimitiveType.BOOL, 1).is_continuous
+        assert not SizedType(PrimitiveType.STRING, 64).is_continuous

tests/datatypes/test_interval.py

@@ -78,6 +78,44 @@ def test_interval_equal_bounds(self):
         assert interval.left == 5
         assert interval.right == 5
 
+
+class TestIntervalTypeClassification:
+    """Test IntervalType classification properties."""
+
+    def test_is_discrete_for_int_interval(self):
+        """Test that int-interval is discrete."""
+        it = IntervalType(NumericPrimitiveType.INT)
+        assert it.is_discrete
+
+    def test_is_discrete_for_uint_interval(self):
+        """Test that uint-interval is discrete."""
+        it = IntervalType(NumericPrimitiveType.UINT)
+        assert it.is_discrete
+
+    def test_is_discrete_for_continuous_intervals(self):
+        """Test that double-interval and rational-interval are not discrete."""
+        double_it = IntervalType(NumericPrimitiveType.DOUBLE)
+        rational_it = IntervalType(NumericPrimitiveType.RATIONAL)
+        assert not double_it.is_discrete
+        assert not rational_it.is_discrete
+
+    def test_is_continuous_for_double_interval(self):
+        """Test that double-interval is continuous."""
+        it = IntervalType(NumericPrimitiveType.DOUBLE)
+        assert it.is_continuous
+
+    def test_is_continuous_for_rational_interval(self):
+        """Test that rational-interval is continuous."""
+        it = IntervalType(NumericPrimitiveType.RATIONAL)
+        assert it.is_continuous
+
+    def test_is_continuous_for_discrete_intervals(self):
+        """Test that int-interval and uint-interval are not continuous."""
+        int_it = IntervalType(NumericPrimitiveType.INT)
+        uint_it = IntervalType(NumericPrimitiveType.UINT)
+        assert not int_it.is_continuous
+        assert not uint_it.is_continuous
+
     def test_interval_str_repr(self):
         """Test Interval string representation."""
         interval = Interval(1, 5)

tests/datatypes/test_numeric_primitive.py

@@ -52,6 +52,36 @@ def test_bool_not_numeric_primitive(self):
         assert numeric_primitive_type_of(True) == NumericPrimitiveType.INT
 
 
+class TestNumericPrimitiveTypeClassification:
+    """Test numeric type classification properties."""
+
+    def test_is_discrete_for_int(self):
+        """Test that INT is discrete."""
+        assert NumericPrimitiveType.INT.is_discrete
+
+    def test_is_discrete_for_uint(self):
+        """Test that UINT is discrete."""
+        assert NumericPrimitiveType.UINT.is_discrete
+
+    def test_is_discrete_for_continuous_types(self):
+        """Test that DOUBLE and RATIONAL are not discrete."""
+        assert not NumericPrimitiveType.DOUBLE.is_discrete
+        assert not NumericPrimitiveType.RATIONAL.is_discrete
+
+    def test_is_continuous_for_double(self):
+        """Test that DOUBLE is continuous."""
+        assert NumericPrimitiveType.DOUBLE.is_continuous
+
+    def test_is_continuous_for_rational(self):
+        """Test that RATIONAL is continuous."""
+        assert NumericPrimitiveType.RATIONAL.is_continuous
+
+    def test_is_continuous_for_discrete_types(self):
+        """Test that INT and UINT are not continuous."""
+        assert not NumericPrimitiveType.INT.is_continuous
+        assert not NumericPrimitiveType.UINT.is_continuous
+
+
 class TestNumericPrimitivePromotionType:
     """Test numeric_primitive_promotion_type function."""
 

umbi/__main__.py

@@ -3,6 +3,7 @@
 import click
 
 import umbi
+import umbi.umb
 
 logger = logging.getLogger(__name__)
 
@@ -36,9 +37,9 @@ def main(log_level, import_umb, import_ats, export):
             raise ValueError("--export specified, but nothing to export")
         if umb is not None and ats is not None:
             raise ValueError("cannot specify both --import-umb and --import-ats when using --export")
-        if import_umb is not None:
+        if umb is not None:
             umbi.umb.write(umb, export)
-        if import_ats is not None:
+        if ats is not None:
             umbi.ats.write(ats, export)
 
 

umbi/binary/sized_type.py

@@ -9,6 +9,7 @@
     IntervalType,
     NumericPrimitive,
     NumericPrimitiveType,
+    NumericType,
     Primitive,
     PrimitiveType,
     Scalar,
@@ -38,7 +39,8 @@ def __post_init__(self):
         self.validate()
 
     def validate(self):
-        assert self.size_bits > 0, "size must be positive"
+        if self.size_bits <= 0:
+            raise ValueError("size must be positive")
         validate_scalar_type_size(self.type, self.size_bits)
 
     @property
@@ -49,6 +51,18 @@ def is_byte_aligned(self) -> bool:
     def size_bytes(self) -> int:
         return (self.size_bits + 7) // 8  # ceiling division
 
+    @property
+    def is_numeric(self) -> bool:
+        return isinstance(self.type, NumericType)
+
+    @property
+    def is_discrete(self) -> bool:
+        return self.is_numeric and self.type.is_discrete  # type: ignore[union-attr]
+
+    @property
+    def is_continuous(self) -> bool:
+        return self.is_numeric and self.type.is_continuous  # type: ignore[union-attr]
+
 
 # Default bitsizes for types
 

umbi/datatypes/interval.py

@@ -32,6 +32,16 @@ def from_string(cls, s: str) -> "IntervalType":
         base_type = NumericPrimitiveType(base_type_string)
         return cls(base_type)
 
+    @property
+    def is_discrete(self) -> bool:
+        """Check if the interval type is discrete."""
+        return self.base_type.is_discrete
+
+    @property
+    def is_continuous(self) -> bool:
+        """Check if the interval type is continuous."""
+        return self.base_type.is_continuous
+
 
 @dataclass(frozen=False)
 class Interval:

umbi/datatypes/numeric_primitive.py

@@ -14,6 +14,16 @@ class NumericPrimitiveType(str, enum.Enum):
     DOUBLE = "double"
     RATIONAL = "rational"
 
+    @property
+    def is_discrete(self) -> bool:
+        """Check if the type is discrete."""
+        return self in {NumericPrimitiveType.INT, NumericPrimitiveType.UINT}
+
+    @property
+    def is_continuous(self) -> bool:
+        """Check if the type is continuous."""
+        return self in {NumericPrimitiveType.DOUBLE, NumericPrimitiveType.RATIONAL}
+
 
 #: Primitive numeric values (integers, floats, or rational numbers).
 NumericPrimitive: TypeAlias = int | float | Fraction

umbi/umb/explicit_umb.py

@@ -11,9 +11,12 @@
 class ExplicitUmb:
     """Explicit representation of a umbfile using Python collections."""
 
+    #: UMB index file
     index: UmbIndex = field(default_factory=UmbIndex)
 
+    #: for each state, whether it is an initial state
     state_is_initial: list[bool] = field(default_factory=list)
+    #: for each state, the choices available
     state_to_choices: list[int] | None = None
     state_to_player: list[int] | None = None
 

umbi/umb/index/__init__.py

@@ -1,9 +1,7 @@
-"""
-umbi.umb.index: handling the .umb index json file.
-"""
+"""umbi.umb.index: in-memory representation of the .umb index json file."""
 
 from .annotations import AnnotationDescription
-from .file_data import FileData, umbi_file_data
+from .file_data import FileData, umbi_file_data, unix_timestamp
 from .model_data import ModelData
 from .transition_system import TransitionSystem
 from .umb_index import UmbIndex
@@ -12,6 +10,7 @@
 __all__ = [
     "ModelData",
     "FileData",
+    "unix_timestamp",
     "umbi_file_data",
     "AnnotationDescription",
     "TransitionSystem",

umbi/umb/index/file_data.py

@@ -1,6 +1,4 @@
-"""
-File data schemas and classes.
-"""
+"""File data schemas and classes."""
 
 import time
 from dataclasses import dataclass
@@ -32,23 +30,36 @@ def schema_class(cls) -> type:
 
 @dataclass
 class FileData(JsonSchemaResult):
-    """File data class."""
+    """File data class.
 
+    Information about how this file was created (for reproducibility purposes).
+    """
+
+    #: the tool used to create this model (strongly encouraged)
     tool: str | None = None
+    #: the tool's version
     tool_version: str | None = None
+    #: export date (Unix timestamp)
     creation_date: int | None = None
+    #: the tool parameters (e.g. string or list of command-line arguments) used
     parameters: umbi.datatypes.JsonLike | None = None
 
     @classmethod
     def class_schema(cls) -> type:
         return FileDataSchema
 
 
+def unix_timestamp() -> int:
+    """Get the current Unix timestamp."""
+    return int(time.time())
+
+
 def umbi_file_data() -> FileData:
     """Generate file data for use in umbfiles created by umbi."""
     return FileData(
         tool=umbi.version.__toolname__,
         tool_version=umbi.version.__version__,
-        creation_date=int(time.time()),
+        creation_date=unix_timestamp(),
+        # TODO include parameters
         # parameters=parameters,
     )