relationalai 1.0.0a1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

relationalai/semantics/frontend/base.py

@@ -432,6 +432,9 @@ class Table(Concept):
         for col_name, col_type_name in schema.items():
             col_type = _find_concept(self._model, col_type_name, default=CoreConcepts["Any"])
             col_rel = self._dot(col_name, with_type=col_type)
+            col_rel._short_name = col_name
+            if col_type is not None:
+                col_rel._fields[1].type = col_type
             self._known_columns.append(col_rel)
         return self._known_columns
 

relationalai/semantics/frontend/front_compiler.py

@@ -225,8 +225,11 @@ def handle_concept_expression(compiler:FrontCompiler, ctx:Context, expr:Expressi
 
             # Update identity and non-identity attributes
             for k, v in kwargs.items():
-                rel = passed_concept._dot(k)
-                ctx.add_update(rel, [root_id, compiler.lookup(ctx, v)], source=source)
+                with ctx.subcontext():
+                    rel = passed_concept._dot(k)
+                    ctx.add_update(rel, [root_id, compiler.lookup(ctx, v)], source=source)
+                    nodes = tuple(ctx.nodes)
+                ctx.add(Logical(nodes, source=source, optional=True))
 
             ctx.construct_handled.add(expr)
 

relationalai/semantics/metamodel/builtins.py

@@ -35,6 +35,7 @@ class CoreLibrary:
     Date: mm.ScalarType
     DateTime: mm.ScalarType
     Float: mm.ScalarType
+    Hash: mm.ScalarType
     # type aliases
     Integer: mm.NumberType
     DefaultNumber: mm.NumberType
@@ -155,7 +156,7 @@ def is_number(t: mm.Type) -> bool:
     """ True if the type is a number type. """
     # note that builtins.core.Number is a ScalarType that represents "any number type",
     # whereas concrete numbers are represented by NumberType instances.
-    return isinstance(t, mm.NumberType) or t == builtins.core.Number
+    return isinstance(t, mm.NumberType) or t == builtins.core.Number or t == builtins.core.ScaledNumber
 
 def is_numeric(t: mm.Type) -> bool:
     """ True if the type is numeric (Number or Float). """

relationalai/semantics/metamodel/metamodel.py

@@ -56,6 +56,11 @@ class Node():
         changes["id"] = self.id
         return replace(self, **changes)
 
+    def replace(self: Self, **changes) -> Self:
+        """Convenience to return a modified copy, with a new id."""
+        changes["id"] = _next_id()
+        return replace(self, **changes)
+
 #-----------------------------------------------------------------------------
 # Capabilities, Reasoners
 #-----------------------------------------------------------------------------
@@ -172,28 +177,51 @@ class NumberType(ScalarType):
     scale: int = 14
 
     def __hash__(self) -> int:
-        return hash(self.id)
+        return hash((self.precision, self.scale))
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, NumberType):
+            return False
+        return self.precision == other.precision and self.scale == other.scale
 
 @dataclass(repr=False, frozen=True, slots=True)
 class UnionType(TypeNode):
     types: ISeq[TypeNode] = field(default=())
 
+    def __post_init__(self):
+        object.__setattr__(self, "types", tuple(sorted(self.types, key=lambda t: hash(t))))
+
     def __hash__(self) -> int:
-        return hash(self.id)
+        return hash(self.types)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, UnionType):
+            return False
+        return len(self.types) == len(other.types) and all(any(t1 == t2 for t2 in other.types) for t1 in self.types)
 
 @dataclass(repr=False, frozen=True, slots=True)
 class ListType(TypeNode):
     element_type: TypeNode = field(default_factory=TypeNode)
 
     def __hash__(self) -> int:
-        return hash(self.id)
+        return hash((self.element_type))
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, ListType):
+            return False
+        return self.element_type == other.element_type
 
 @dataclass(repr=False, frozen=True, slots=True)
 class TupleType(TypeNode):
     element_types: ISeq[TypeNode] = field(default=())
 
     def __hash__(self) -> int:
-        return hash(self.id)
+        return hash(self.element_types)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, TupleType):
+            return False
+        return self.element_types == other.element_types
 
 # Type alias to mirror the spec's union
 Type = TypeNode

relationalai/semantics/metamodel/pprint.py

@@ -340,7 +340,7 @@ class Printer():
             )
             return
 
-        yield _indent_line(indent, repr(task))
+        yield _indent_line(indent, object.__repr__(task))
 
     def _render_model(self, model: Model, indent: int = 0) -> Iterable[str]:
         summary_parts: List[str] = []
@@ -370,7 +370,7 @@ class Printer():
         if isinstance(model.root, Task):
             yield from self._render_task(model.root, indent + 2)
         else:
-            yield _indent_line(indent + 2, repr(model.root))
+            yield _indent_line(indent + 2, object.__repr__(model.root))
 
     def format_task(self, task: Task, indent: Optional[int] = None) -> str:
         start_indent = 0 if indent is None else indent
@@ -398,8 +398,10 @@ class Printer():
             return "List\n" + "\n".join(self.format(n, start_indent+1) for n in node)
         elif isinstance(node, Field):
             return self.value(node)
+        elif isinstance(node, Annotation):
+            return self.annotation(node)
         else:
-            return repr(node)
+            return object.__repr__(node)
 
 
 def format(node: Node|list|tuple, indent: Optional[int] = None) -> str: