relationalai 0.12.13__py3-none-any.whl → 0.13.0.dev0__py3-none-any.whl

relationalai/semantics/std/__init__.py

@@ -1,54 +1,74 @@
-from __future__ import annotations
-from typing import Any
 
-from relationalai.semantics.internal import internal as i
-from .std import _Date, _DateTime, _Number, _String, _Integer, _make_expr
-from . import datetime, math, strings, decimals, integers, floats, pragmas, constraints, re
+from ..frontend.base import Variable, Literal, Expression
+from ...util.error import warn, exc, source
+from ...util.source import SourcePos
+from decimal import Decimal as PyDecimal
+import datetime as dt
+from typing import Any, Union
 
-def range(*args: _Integer) -> i.Expression:
-    # supports range(stop), range(start, stop), range(start, stop, step)
-    if len(args) == 1:
-        start, stop, step = 0, args[0], 1
-    elif len(args) == 2:
-        start, stop, step = args[0], args[1], 1
-    elif len(args) == 3:
-        start, stop, step = args
-    else:
-        raise ValueError(f"range expects 1, 2, or 3 arguments, got {len(args)}")
-    # unlike Python, Rel's range is 1..stop inclusive, so we need to subtract 1 from stop
-    return _make_expr("range", cast_to_int64(start), cast(i.Int64, stop-1), cast_to_int64(step), i.Int64.ref("res"))
+#------------------------------------------------------
+# Helpers
+#------------------------------------------------------
 
-def hash(*args: Any, type=i.Hash) -> i.Expression:
-    if len(args) == 0:
-        raise ValueError("hash expects at least one argument")
-    return _make_expr("hash", i.TupleArg(args), type.ref("res"))
+def _deprecated_library(library, replacement=None, example=None):
+    replacement_message = ""
+    parts = [source(SourcePos.new())]
+    if replacement is not None:
+        replacement_message = f" Use '{replacement}' instead."
+    if example is not None:
+        parts.append(f'For example: [cyan]{example}[/cyan]')
+    warn("Deprecated library", f"The {library} library is deprecated.{replacement_message}", parts)
 
-def uuid_to_string(arg: _Integer) -> i.Expression:
-    return _make_expr("uuid_to_string", arg, i.String.ref("res"))
+def _deprecated_function(func_name, replacement=None, example=None):
+    replacement_message = ""
+    parts = [source(SourcePos.new())]
+    if replacement is not None:
+        replacement_message = f" Use '{replacement}' instead."
+    if example is not None:
+        parts.append(f'For example: [cyan]{example}[/cyan]')
+    warn("Deprecated function", f"The function '{func_name}' is deprecated.{replacement_message}", parts)
 
-def parse_uuid(arg: _String) -> i.Expression:
-    return _make_expr("parse_uuid", arg, i.Hash.ref("res"))
+def _function_not_implemented(func_name: str):
+    parts = [source(SourcePos.new())]
+    exc("Function not implemented", f"The function '{func_name}' is not yet implemented in PyRel.", parts)
 
-def cast(type: i.Concept, arg: _Date|_DateTime|_Number|_String) -> i.Expression:
-    return _make_expr("cast", i.TypeRef(type), arg, type.ref("res"))
+StringValue = Union[Variable, str]
+IntegerValue = Union[Variable, int]
+DateValue = Union[Variable, dt.date]
+DateTimeValue = Union[Variable, dt.datetime]
+NumberValue = Union[Variable, float, int, PyDecimal]
+FloatValue = Union[Variable, float]
 
-def cast_to_int64(arg: _Number) -> i.Expression:
-    return arg if isinstance(arg, i.ConceptMember) and arg._op == i.Int64 else cast(i.Int64, arg)
+def _get_number_value(value: Any) -> Union[float, int, PyDecimal, None]:
+    """ If the value is a number literal, return its value as a Python number. """
+    if isinstance(value, (float, int, PyDecimal)):
+        return value
+    if isinstance(value, Literal):
+        return _get_number_value(value._value)
+    return None
 
 
+#------------------------------------------------------
+# Libraries
+#------------------------------------------------------
+from . import aggregates, common, datetime, decimals, integers, math, numbers, re, strings, constraints
 __all__ = [
-    "range",
-    "hash",
-    "cast",
+    "aggregates",
+    "common",
+    "constraints",
     "datetime",
-    "math",
-    "strings",
-    "re",
     "decimals",
     "integers",
-    "floats",
-    "pragmas",
-    "constraints",
-    "uuid_to_string",
-    "parse_uuid",
+    "math",
+    "numbers",
+    "re",
+    "strings",
 ]
+
+#------------------------------------------------------
+# Deprecated functions
+#------------------------------------------------------
+
+def range(*args: IntegerValue) -> Expression:
+    _deprecated_function("std.range", "common.range")
+    return common.range(*args)

relationalai/semantics/std/aggregates.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+from ..frontend.base import Field, Library, Relationship, Aggregate, Group, TupleVariable, Value, Distinct
+from ..frontend.core import Any, Boolean, Number, String, Integer, TypeVar, ScaledNumber, Numeric, Float
+
+library = Library("aggregates")
+
+AggValue = Value | Distinct
+
+#------------------------------------------------------
+# Aggregates
+#------------------------------------------------------
+
+# TODO - overloads
+_sum = library.Relation("sum", fields=[Field.input("value", Numeric), Field("result", Numeric)],
+                        overloads=[[Number, Number], [Float, Float]])
+_count = library.Relation("count", fields=[Field("result", Integer)])
+_avg = library.Relation("avg", fields=[Field.input("over", Numeric), Field("result", Numeric)],
+                        overloads=[[Number, ScaledNumber], [Float, Float]])
+_min = library.Relation("min", fields=[Field.input("over", TypeVar), Field("result", TypeVar)])
+_max = library.Relation("max", fields=[Field.input("over", TypeVar), Field("result", TypeVar)])
+_string_join = library.Relation("string_join",
+        fields=[Field.input("index", Number), Field.input("sep", String), Field.input("over", String), Field("result", String)])
+
+_sort = library.Relation("sort", fields=[Field.input("limit", Integer), Field.input("args", Any, is_list=True), Field.input("is_asc", Boolean, is_list=True)])
+_rank = library.Relation("rank", fields=[Field.input("args", Any, is_list=True), Field.input("is_asc", Boolean, is_list=True), Field("rank", Integer)])
+_limit = library.Relation("limit", fields=[Field.input("limit", Integer), Field.input("args", Any, is_list=True), Field.input("is_asc", Boolean, is_list=True)])
+
+
+def sum(*args: AggValue) -> Aggregate:
+    return Aggregate(_sum, *args)
+
+def count(*args: AggValue) -> Aggregate:
+    return Aggregate(_count, *args)
+
+def min(*args: AggValue) -> Aggregate:
+    return Aggregate(_min, *args)
+
+def max(*args: AggValue) -> Aggregate:
+    return Aggregate(_max, *args)
+
+def avg(*args: AggValue) -> Aggregate:
+    return Aggregate(_avg, *args)
+
+def string_join(*args: AggValue, sep="", index=1) -> Aggregate:
+    return Aggregate(_string_join, index, sep, *args)
+
+class Ordering:
+    def __init__(self, *values:AggValue, is_asc=True) -> None:
+        self._values = values
+        self._is_asc = is_asc
+
+    @staticmethod
+    def handle_arg(arg: AggValue|Ordering, ordering, ordering_args, is_asc=True) -> bool:
+        has_distinct = False
+        if isinstance(arg, Ordering):
+            for v in arg._values:
+                has_distinct = Ordering.handle_arg(v, ordering, ordering_args, arg._is_asc) or has_distinct
+        elif isinstance(arg, Distinct):
+            has_distinct = True
+            for v in arg._items:
+                Ordering.handle_arg(v, ordering, ordering_args, is_asc)
+        else:
+            ordering.append(is_asc)
+            ordering_args.append(arg)
+        return has_distinct
+
+    @staticmethod
+    def get_ordering_args(args: tuple[AggValue|Ordering, ...]) -> tuple[tuple[AggValue,...], tuple[bool,...], bool]:
+        ordering = []
+        ordering_args = []
+        has_distinct = False
+        for arg in args:
+            has_distinct = Ordering.handle_arg(arg, ordering, ordering_args) or has_distinct
+        return tuple(ordering_args), tuple(ordering), has_distinct
+
+def asc(*args: AggValue) -> Ordering:
+    return Ordering(*args, is_asc=True)
+
+def desc(*args: AggValue) -> Ordering:
+    return Ordering(*args, is_asc=False)
+
+def _sort_agg(limit: int, *args: AggValue|Ordering) -> Aggregate:
+    ordering_args, is_asc, has_distinct = Ordering.get_ordering_args(args)
+    return Aggregate(_sort, limit, TupleVariable(ordering_args), TupleVariable(is_asc), distinct=has_distinct)
+
+def rank(*args: AggValue|Ordering) -> Aggregate:
+    ordering_args, is_asc, has_distinct = Ordering.get_ordering_args(args)
+    return Aggregate(_rank, TupleVariable(ordering_args), TupleVariable(is_asc), distinct=has_distinct)
+
+def limit(limit: int, *args: AggValue|Ordering) -> Aggregate:
+    ordering_args, is_asc, has_distinct = Ordering.get_ordering_args(args)
+    return Aggregate(_limit, limit, TupleVariable(ordering_args), TupleVariable(is_asc), distinct=has_distinct)
+
+def rank_asc(*args: AggValue) -> Aggregate:
+    return Aggregate(_rank, TupleVariable(args), TupleVariable([True for _ in args]))
+
+def rank_desc(*args: AggValue) -> Aggregate:
+    return Aggregate(_rank, TupleVariable(args), TupleVariable([False for _ in args]))
+
+def top(limit: int, *args: AggValue) -> Aggregate:
+    return Aggregate(_limit, limit, TupleVariable(args), TupleVariable([False for _ in args]))
+
+def bottom(limit: int, *args: AggValue) -> Aggregate:
+    return Aggregate(_limit, limit, TupleVariable(args), TupleVariable([True for _ in args]))
+
+#------------------------------------------------------
+# Per
+#------------------------------------------------------
+
+class Per(Group):
+
+    def sum(self, *args: AggValue) -> Aggregate:
+        return sum(*args).per(*self._args)
+
+    def count(self, *args: AggValue) -> Aggregate:
+        return count(*args).per(*self._args)
+
+    def min(self, *args: AggValue) -> Aggregate:
+        return min(*args).per(*self._args)
+
+    def max(self, *args: AggValue) -> Aggregate:
+        return max(*args).per(*self._args)
+
+    def avg(self, *args: AggValue) -> Aggregate:
+        return avg(*args).per(*self._args)
+
+    def string_join(self, *args: AggValue, sep="", index=1) -> Aggregate:
+        return string_join(*args, sep=sep, index=index).per(*self._args)
+
+    def rank(self, *args: AggValue|Ordering) -> Aggregate:
+        return rank(*args).per(*self._args)
+
+    def limit(self, limit_: int, *args: AggValue|Ordering) -> Aggregate:
+        return limit(limit_, *args).per(*self._args)
+
+    def rank_asc(self, *args: AggValue) -> Aggregate:
+        return rank_asc(*args).per(*self._args)
+
+    def rank_desc(self, *args: AggValue) -> Aggregate:
+        return rank_desc(*args).per(*self._args)
+
+    def top(self, limit: int, *args: AggValue) -> Aggregate:
+        return top(limit, *args).per(*self._args)
+
+    def bottom(self, limit: int, *args: AggValue) -> Aggregate:
+        return bottom(limit, *args).per(*self._args)
+
+def per(*args: Value) -> Per:
+    return Per(*args)

relationalai/semantics/std/common.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from . import StringValue, IntegerValue, DateValue, DateTimeValue, math
+from ..frontend.base import Aggregate, Library, Concept, NumberConcept, Expression, Field, Literal, TupleVariable, Variable, Value
+from ..frontend.core import Any, Int128, Number, String, Integer, Date, DateTime, Hash
+
+from typing import Union, Literal
+import datetime as dt
+
+# the front-end library object
+library = Library("common")
+
+
+_range = library.Relation("range", [Field.input("start", Integer), Field.input("stop", Integer), Field.input("step", Integer), Field("value", Integer)])
+
+def range(*args: IntegerValue) -> Expression:
+    """ Generate a range of integers.
+
+    Supports range(stop), range(start, stop), range(start, stop, step).
+
+    Start is inclusive and defaults to 0.
+    Stop is exclusive.
+    Step defaults to 1.
+    """
+    if len(args) == 1:
+        start, stop, step = 0, args[0], 1
+    elif len(args) == 2:
+        start, stop, step = args[0], args[1], 1
+    elif len(args) == 3:
+        start, stop, step = args
+    else:
+        raise ValueError(f"range expects 1, 2, or 3 arguments, got {len(args)}")
+
+    return _range(start, stop, step)
+
+_hash = library.Relation("hash", [Field.input("args", Any, is_list=True), Field("hash", Hash)])
+def hash(*args: Value) -> Expression:
+    """ Compute a hash value for the given arguments. """
+    return _hash(TupleVariable(args))
+
+_uuid_to_string = library.Relation("uuid_to_string", [Field.input("uuid", Hash), Field("str", String)])
+def uuid_to_string(uuid: Value) -> Expression:
+    """ Convert a UUID (Hash) to its string representation. """
+    return _uuid_to_string(uuid)

relationalai/semantics/std/constraints.py

@@ -1,43 +1,37 @@
-from __future__ import annotations
-
-from relationalai.semantics.internal import internal as b
-
-def unique(*args: b.RelationshipFieldRef|b.Relationship|b.RelationshipRef|b.RelationshipReading, model:b.Model|None=None) -> tuple[b.Expression, ...]:
-    if not args:
-        raise ValueError("unique expects at least 1 argument")
-    if len(args) > 1:
-        if not all(isinstance(a, b.RelationshipFieldRef) for a in args):
-            raise TypeError("Not all items are relationship fields")
-        uc = b.Unique(*args, model=model) # type: ignore
-    else:
-        assert args
-        if isinstance(args[0], b.RelationshipFieldRef):
-            uc = b.Unique(*args) # type: ignore
-        elif isinstance(args[0], (b.Relationship, b.RelationshipRef, b.RelationshipReading)):
-            rel = args[0]._relationship if isinstance(args[0], b.RelationshipRef) else args[0]
-            if rel._arity() != 2:
-                raise ValueError("Only binary relationships are allowed")
-            uc = b.Unique(rel[1], model=model)
-        else:
-            raise TypeError("Unexpected argument type. Only relationship fields or relationships are allowed")
-    return uc.to_expressions()
-
-def exclusive(*args: b.Concept|b.Ref, model:b.Model|None=None) -> tuple[b.Expression, ...]:
-    return b.Exclusive(*_extract_concepts(*args), model=model).to_expressions()
-
-def anyof(*args: b.Concept|b.Ref, model:b.Model|None=None) -> tuple[b.Expression, ...]:
-    return b.Anyof(*_extract_concepts(*args), model=model).to_expressions()
-
-def oneof(*args: b.Concept | b.Ref, model: b.Model | None = None) -> tuple[b.Expression, ...]:
-    return exclusive(*args, model=model) + anyof(*args, model=model)
-
-def _extract_concepts(*args: b.Concept|b.Ref) -> list[b.Concept]:
-    concepts = []
-    for arg in args:
-        c = arg
-        if isinstance(c, b.Ref):
-            c = c._thing
-            if not isinstance(c, b.Concept):
-                raise TypeError("Only concepts and concept's ref are allowed as arguments")
-        concepts.append(arg)
-    return concepts
+
+from ..frontend.base import FieldRef, Fragment, Library, Expression, Field, Value, TupleVariable, Variable, Concept, Ref, MetaRef
+from ..frontend import core
+
+# the front-end library object
+library = Library("constraints")
+
+#------------------------------------------------------
+# Constraint Relations
+#------------------------------------------------------
+
+_unique = library.Relation("unique", [Field.input("values", core.Any, is_list=True)])
+_unique_fields = library.Relation("unique_fields", [Field.input("fields", core.Field, is_list=True)])
+_exclusive = library.Relation("exclusive", [Field.input("concepts", core.Relation, is_list=True)])
+_anyof =library.Relation("anyof", [Field.input("concepts", core.Relation, is_list=True)])
+
+#------------------------------------------------------
+# API
+#------------------------------------------------------
+
+def unique(*args: Variable) -> Expression:
+    if all(isinstance(arg, FieldRef) for arg in args):
+        fields = [MetaRef(arg._resolved) for arg in args] # type: ignore - we know these are FieldRefs from the all above
+        return _unique_fields(TupleVariable(fields))
+    return _unique(TupleVariable(args))
+
+def exclusive(*args: Concept|Ref) -> Expression:
+    concepts = [arg._to_concept() for arg in args]
+    return _exclusive(TupleVariable(concepts))
+
+def anyof(*args: Concept|Ref) -> Expression:
+    concepts = [arg._to_concept() for arg in args]
+    return _anyof(TupleVariable(concepts))
+
+def oneof(*args: Concept | Ref) -> Fragment:
+    model = args[0]._model
+    return model.where(anyof(*args), exclusive(*args))