pytrilogy 0.0.3.15__tar.gz → 0.0.3.17__tar.gz

{pytrilogy-0.0.3.15/pytrilogy.egg-info → pytrilogy-0.0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pytrilogy
-Version: 0.0.3.15
+Version: 0.0.3.17
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pytrilogy
-Version: 0.0.3.15
+Version: 0.0.3.17
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

pytrilogy-0.0.3.17/tests/test_typing.py

@@ -0,0 +1,145 @@
+from decimal import Decimal
+
+from trilogy import Dialects
+
+
+def test_typing():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type email string;
+
+key customer_id int;
+property customer_id.email string::email;
+
+def is_valid_email(email) -> contains(email, '@');
+
+datasource customers (
+    id:customer_id,
+    email: email
+)
+grain (customer_id)
+query '''
+select 1 as id, 'bright@gmail.com' as email
+union all
+select 2 as id, 'funky@hotmail.com' as email
+''';
+
+
+"""
+    )
+
+    results = env.execute_query(
+        """SELECT
+customer_id,
+@is_valid_email(email)->valid;"""
+    )
+
+    for row in results.fetchall():
+        assert row.valid is True
+
+    assert "email" in env.environment.data_types
+
+    assert env.environment.concepts["email"].datatype.traits == ["email"]
+
+
+def test_typing_aggregate():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type money float;
+
+key revenue float::money;
+key revenue_two float::money;
+key multiplier float;
+
+datasource orders (
+    revenue:revenue,
+    revenue_two:revenue_two,
+    multiplier:multiplier
+)
+grain (revenue)
+query '''
+select 5.0 as revenue, 3.3 as revenue_two, 2.0 as multiplier
+union all
+select 10.0 as revenue, 13.1 as revenue_two, 3.0 as multiplier
+''';
+
+
+"""
+    )
+
+    results = env.execute_query(
+        """SELECT
+sum(revenue)->direct_total,
+sum(revenue*multiplier)->total,
+direct_total-total -> diff;"""
+    )
+
+    for row in results.fetchall():
+        assert row.total == Decimal("40.00")
+
+    assert "money" in env.environment.data_types
+    assert env.environment.concepts["direct_total"].datatype.traits == ["money"]
+    assert env.environment.concepts["total"].datatype.traits == ["money"]
+    assert env.environment.concepts["diff"].datatype.traits == [
+        "money"
+    ], env.environment.concepts["diff"].datatype
+
+    results = env.execute_query(
+        """SELECT
+revenue+revenue_two->add_total,
+revenue-revenue_two->sub_total
+;"""
+    )
+
+    assert "money" in env.environment.data_types
+    assert env.environment.concepts["add_total"].datatype.traits == ["money"]
+    assert env.environment.concepts["sub_total"].datatype.traits == ["money"]
+
+
+def test_custom_function_typing():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type money float;
+
+key revenue float::money;
+
+def revenue_times_2(revenue) -> revenue*2;
+
+def revenue_times_multiplier(revenue, multiplier) -> revenue*multiplier;
+
+datasource orders (
+    revenue:revenue,
+
+)
+grain (revenue)
+query '''
+select 5.0 as revenue, 3.3 as revenue_two, 2.0 as multiplier
+union all
+select 10.0 as revenue, 13.1 as revenue_two, 3.0 as multiplier
+''';
+
+
+"""
+    )
+
+    _ = env.execute_query(
+        """
+with scaled as
+SELECT
+    @revenue_times_2(revenue)->revenue
+;
+        
+SELECT
+sum(
+    round( @revenue_times_multiplier(lag 1 @revenue_times_2(scaled.revenue), 2.0), 2)
+)->total;
+"""
+    )
+
+    assert env.environment.concepts["total"].datatype.traits == ["money"]

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.15"
+__version__ = "0.0.3.17"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/authoring/__init__.py

@@ -40,6 +40,7 @@ from trilogy.core.models.core import (
     MapType,
     StructType,
 )
+from trilogy.core.models.datasource import Datasource, DatasourceMetadata
 from trilogy.core.models.environment import Environment
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
@@ -100,4 +101,6 @@ __all__ = [
     "MultiSelectStatement",
     "PersistStatement",
     "RawSQLStatement",
+    "Datasource",
+    "DatasourceMetadata",
 ]

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/core/functions.py

@@ -29,6 +29,7 @@ from trilogy.core.models.core import (
     MapType,
     NumericType,
     StructType,
+    TraitDataType,
     arg_to_datatype,
     merge_datatypes,
 )
@@ -94,6 +95,10 @@ def get_cast_output_type(
     return args[1]
 
 
+def get_output_type_at_index(args, index: int):
+    return arg_to_datatype(args[index])
+
+
 def validate_case_output(
     args: list[Any],
 ) -> DataType:
@@ -140,6 +145,9 @@ def get_date_trunc_output(
 
 
 FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
+    FunctionType.PARENTHETICAL: FunctionConfig(
+        arg_count=1,
+    ),
     FunctionType.UNNEST: FunctionConfig(
         valid_inputs={
             DataType.ARRAY,
@@ -173,7 +181,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.BOOL,
         },
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.MIN: FunctionConfig(
@@ -186,7 +193,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.TIMESTAMP,
         },
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.SPLIT: FunctionConfig(
@@ -237,7 +243,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     FunctionType.ABS: FunctionConfig(
         valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.COALESCE: FunctionConfig(
@@ -519,7 +524,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.SUBTRACT: FunctionConfig(
@@ -530,7 +534,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.MULTIPLY: FunctionConfig(
@@ -541,7 +544,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.DIVIDE: FunctionConfig(
@@ -552,7 +554,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.MOD: FunctionConfig(
@@ -570,7 +571,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             {DataType.INTEGER},
         ],
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
         arg_count=2,
     ),
     FunctionType.CUSTOM: FunctionConfig(
@@ -621,13 +622,11 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     FunctionType.SUM: FunctionConfig(
         valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.AVG: FunctionConfig(
         valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.UNIX_TO_TIMESTAMP: FunctionConfig(
@@ -641,7 +640,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
 EXCLUDED_FUNCTIONS = {
     FunctionType.CUSTOM,
     FunctionType.ALIAS,
-    FunctionType.PARENTHETICAL,
+    # FunctionType.PARENTHETICAL,
     # Temporary
     FunctionType.DATE_LITERAL,
     FunctionType.DATETIME_LITERAL,
@@ -686,8 +685,10 @@ class FunctionFactory:
             full_args = []
         final_output_type: CONCRETE_TYPES
         if config.output_type_function:
+
             final_output_type = config.output_type_function(full_args)
         elif not base_output_type:
+
             final_output_type = merge_datatypes([arg_to_datatype(x) for x in full_args])
         elif base_output_type:
             final_output_type = base_output_type
@@ -715,7 +716,7 @@ def create_function_derived_concept(
     operator: FunctionType,
     arguments: list[Concept],
     output_type: Optional[
-        DataType | ListType | StructType | MapType | NumericType
+        DataType | ListType | StructType | MapType | NumericType | TraitDataType
     ] = None,
     output_purpose: Optional[Purpose] = None,
 ) -> Concept:

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/core/models/author.py

@@ -1370,7 +1370,7 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
 
 
 def get_basic_type(
-    type: DataType | ListType | StructType | MapType | NumericType,
+    type: DataType | ListType | StructType | MapType | NumericType | TraitDataType,
 ) -> DataType:
     if isinstance(type, ListType):
         return DataType.LIST
@@ -1380,6 +1380,8 @@ def get_basic_type(
         return DataType.MAP
     if isinstance(type, NumericType):
         return DataType.NUMERIC
+    if isinstance(type, TraitDataType):
+        return type.type
     return type
 
 
@@ -1531,7 +1533,9 @@ def get_concept_arguments(expr) -> List["ConceptRef"]:
 class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     operator: FunctionType
     arg_count: int = Field(default=1)
-    output_datatype: DataType | ListType | StructType | MapType | NumericType
+    output_datatype: (
+        DataType | ListType | StructType | MapType | NumericType | TraitDataType
+    )
     output_purpose: Purpose
     valid_inputs: Optional[
         Union[
@@ -1629,23 +1633,30 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         return v
 
     def with_reference_replacement(self, source: str, target: Expr):
+        from trilogy.core.functions import arg_to_datatype, merge_datatypes
+
+        nargs = [
+            (
+                c.with_reference_replacement(
+                    source,
+                    target,
+                )
+                if isinstance(
+                    c,
+                    Mergeable,
+                )
+                else c
+            )
+            for c in self.arguments
+        ]
+        if self.output_datatype == DataType.UNKNOWN:
+            new_output = merge_datatypes([arg_to_datatype(x) for x in nargs])
+        else:
+            new_output = self.output_datatype
         return Function.model_construct(
             operator=self.operator,
-            arguments=[
-                (
-                    c.with_reference_replacement(
-                        source,
-                        target,
-                    )
-                    if isinstance(
-                        c,
-                        Mergeable,
-                    )
-                    else c
-                )
-                for c in self.arguments
-            ],
-            output_datatype=self.output_datatype,
+            arguments=nargs,
+            output_datatype=new_output,
             output_purpose=self.output_purpose,
             valid_inputs=self.valid_inputs,
             arg_count=self.arg_count,
@@ -1777,7 +1788,7 @@ class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel)
         )
 
 
-class FilterItem(Namespaced, ConceptArgs, BaseModel):
+class FilterItem(DataTyped, Namespaced, ConceptArgs, BaseModel):
     content: ConceptRef
     where: "WhereClause"
 
@@ -1837,7 +1848,7 @@ class RowsetLineage(Namespaced, Mergeable, BaseModel):
         )
 
 
-class RowsetItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
+class RowsetItem(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel):
     content: ConceptRef
     rowset: RowsetLineage
 

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/core/models/core.py

@@ -51,7 +51,13 @@ class Addressable(ABC):
 
 
 TYPEDEF_TYPES = Union[
-    "DataType", "MapType", "ListType", "NumericType", "StructType", "DataTyped"
+    "DataType",
+    "MapType",
+    "ListType",
+    "NumericType",
+    "StructType",
+    "DataTyped",
+    "TraitDataType",
 ]
 
 CONCRETE_TYPES = Union[
@@ -60,6 +66,7 @@ CONCRETE_TYPES = Union[
     "ListType",
     "NumericType",
     "StructType",
+    "TraitDataType",
 ]
 
 KT = TypeVar("KT")
@@ -101,6 +108,16 @@ class TraitDataType(BaseModel):
     type: DataType
     traits: list[str]
 
+    def __hash__(self):
+        return hash(self.type)
+
+    def __eq__(self, other):
+        if isinstance(other, DataType):
+            return self.type == other
+        elif isinstance(other, TraitDataType):
+            return self.type == other.type and self.traits == other.traits
+        return False
+
     @property
     def data_type(self):
         return self.type
@@ -312,8 +329,10 @@ def dict_to_map_wrapper(arg):
 
 
 def merge_datatypes(
-    inputs: list[DataType | ListType | StructType | MapType | NumericType],
-) -> DataType | ListType | StructType | MapType | NumericType:
+    inputs: list[
+        DataType | ListType | StructType | MapType | NumericType | TraitDataType
+    ],
+) -> DataType | ListType | StructType | MapType | NumericType | TraitDataType:
     """This is a temporary hack for doing between
     allowable datatype transformation matrix"""
     if len(inputs) == 1:
@@ -348,6 +367,7 @@ def is_compatible_datatype(left, right):
 
 
 def arg_to_datatype(arg) -> CONCRETE_TYPES:
+
     if isinstance(arg, MagicConstants):
         if arg == MagicConstants.NULL:
             return DataType.NULL

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/core/processing/concept_strategies_v3.py

@@ -395,6 +395,7 @@ def generate_node(
             environment=environment,
             parents=[],
             depth=depth + 1,
+            preexisting_conditions=conditions.conditional if conditions else None,
         )
     elif concept.derivation == Derivation.BASIC:
         # this is special case handling for group bys
@@ -786,7 +787,6 @@ def _search_concepts(
         )
         # if anything we need to get is in the filter set and it's a computed value
         # we need to get _everything_ in this loop
-        logger.info(f"{[x.address for x in conditions.row_arguments]}")
         if any(
             [
                 x.derivation not in (Derivation.ROOT, Derivation.CONSTANT)

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -405,6 +405,7 @@ def create_select_node(
             # no partial for constants
             partial_concepts=[],
             force_group=False,
+            preexisting_conditions=conditions.conditional if conditions else None,
         )
 
     datasource: dict[str, BuildDatasource | list[BuildDatasource]] = (
@@ -491,6 +492,7 @@ def gen_select_merge_node(
             depth=depth,
             partial_concepts=[],
             force_group=False,
+            preexisting_conditions=conditions.conditional if conditions else None,
         )
     for attempt in [False, True]:
         pruned_concept_graph = create_pruned_concept_graph(
@@ -542,6 +544,7 @@ def gen_select_merge_node(
                 depth=depth,
                 partial_concepts=[],
                 force_group=False,
+                preexisting_conditions=conditions.conditional if conditions else None,
             )
         )
 

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/core/statements/author.py

@@ -134,7 +134,6 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
         output.grain = output.calculate_grain(environment)
 
         for x in selection:
-
             if x.is_undefined and environment.concepts.fail_on_missing:
                 environment.concepts.raise_undefined(
                     x.concept.address, meta.line_number if meta else None
@@ -158,7 +157,6 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
                 output.local_concepts[x.content.address] = environment.concepts[
                     x.content.address
                 ]  # .set_select_grain(output.grain, environment)
-
         output.validate_syntax(environment)
         return output
 

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/dialect/base.py

@@ -770,7 +770,7 @@ class BaseDialect:
                 grain=cte.grain,
                 limit=cte.limit,
                 comment=cte.comment if CONFIG.show_comments else None,
-                 # some joins may not need to be rendered
+                # some joins may not need to be rendered
                 joins=[
                     j
                     for j in [

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/parsing/common.py

@@ -100,6 +100,8 @@ def process_function_arg(
             concept.metadata.line_number = meta.line
         environment.add_concept(concept, meta=meta)
         return concept
+    elif isinstance(arg, ConceptRef):
+        return environment.concepts[arg.address]
     return arg
 
 
@@ -192,6 +194,8 @@ def concept_is_relevant(
 ) -> bool:
     if isinstance(concept, UndefinedConcept):
 
+        return False
+    if concept.datatype == DataType.UNKNOWN:
         return False
     if isinstance(concept, ConceptRef):
         if environment:

{pytrilogy-0.0.3.15 → pytrilogy-0.0.3.17}/trilogy/parsing/parse_engine.py

@@ -4,7 +4,7 @@ from enum import Enum
 from os.path import dirname, join
 from pathlib import Path
 from re import IGNORECASE
-from typing import List, Optional, Tuple, Union
+from typing import Any, List, Optional, Tuple, Union
 
 from lark import Lark, ParseTree, Transformer, Tree, v_args
 from lark.exceptions import (
@@ -68,6 +68,7 @@ from trilogy.core.models.author import (
     OrderBy,
     OrderItem,
     Parenthetical,
+    RowsetItem,
     SubselectComparison,
     WhereClause,
     Window,
@@ -77,6 +78,7 @@ from trilogy.core.models.author import (
 )
 from trilogy.core.models.core import (
     DataType,
+    DataTyped,
     ListType,
     ListWrapper,
     MapType,
@@ -223,6 +225,52 @@ def unwrap_transformation(
         )
 
 
+def rehydrate_lineage(
+    lineage: Any, environment: Environment, function_factory: FunctionFactory
+) -> Any:
+    """Fix datatype propagation. This is a hack to fix the fact that we don't know the datatypes of functions until we've parsed all concepts"""
+    if isinstance(lineage, Function):
+        rehydrated = [
+            rehydrate_lineage(x, environment, function_factory)
+            for x in lineage.arguments
+        ]
+        return function_factory.create_function(
+            rehydrated,
+            operator=lineage.operator,
+        )
+    elif isinstance(lineage, Parenthetical):
+        lineage.content = rehydrate_lineage(
+            lineage.content, environment, function_factory
+        )
+        return lineage
+    elif isinstance(lineage, WindowItem):
+        lineage.content.datatype = environment.concepts[
+            lineage.content.address
+        ].datatype
+        return lineage
+    elif isinstance(lineage, AggregateWrapper):
+        lineage.function = rehydrate_lineage(
+            lineage.function, environment, function_factory
+        )
+        return lineage
+    elif isinstance(lineage, RowsetItem):
+        lineage.content.datatype = environment.concepts[
+            lineage.content.address
+        ].datatype
+        return lineage
+    else:
+        return lineage
+
+
+def rehydrate_concept_lineage(
+    concept: Concept, environment: Environment, function_factory: FunctionFactory
+) -> Concept:
+    concept.lineage = rehydrate_lineage(concept.lineage, environment, function_factory)
+    if isinstance(concept.lineage, DataTyped):
+        concept.datatype = concept.lineage.output_datatype
+    return concept
+
+
 class ParseToObjects(Transformer):
     def __init__(
         self,
@@ -275,6 +323,25 @@ class ParseToObjects(Transformer):
             v.run_second_parse_pass()
         reparsed = self.transform(self.tokens[self.token_address])
         self.environment.concepts.undefined = {}
+        passed = False
+        passes = 0
+        # output datatypes for functions may have been wrong
+        # as they were derived from not fully understood upstream types
+        # so loop through to recreate function lineage until all datatypes are known
+
+        while not passed:
+            new_passed = True
+            for x, y in self.environment.concepts.items():
+                if y.datatype == DataType.UNKNOWN and y.lineage:
+                    self.environment.concepts[x] = rehydrate_concept_lineage(
+                        y, self.environment, self.function_factory
+                    )
+                    new_passed = False
+            passes += 1
+            if passes > MAX_PARSE_DEPTH:
+                break
+            passed = new_passed
+
         return reparsed
 
     def start(self, args):
@@ -1075,7 +1142,7 @@ class ParseToObjects(Transformer):
         if not select_items:
             raise ValueError("Malformed select, missing select items")
 
-        return SelectStatement.from_inputs(
+        base = SelectStatement.from_inputs(
             environment=self.environment,
             selection=select_items,
             order_by=order_by,
@@ -1084,6 +1151,7 @@ class ParseToObjects(Transformer):
             limit=limit,
             meta=Metadata(line_number=meta.line),
         )
+        return base
 
     @v_args(meta=True)
     def address(self, meta: Meta, args):

pytrilogy-0.0.3.15/tests/test_typing.py

@@ -1,42 +0,0 @@
-from trilogy import Dialects
-
-
-def test_typing():
-    env = Dialects.DUCK_DB.default_executor()
-    env.environment.parse(
-        """
-
-type email string;
-
-key customer_id int;
-property customer_id.email string::email;
-
-def is_valid_email(email) -> contains(email, '@');
-
-datasource customers (
-    id:customer_id,
-    email: email
-)
-grain (customer_id)
-query '''
-select 1 as id, 'bright@gmail.com' as email
-union all
-select 2 as id, 'funky@hotmail.com' as email
-''';
-
-
-"""
-    )
-
-    results = env.execute_query(
-        """SELECT
-customer_id,
-@is_valid_email(email)->valid;"""
-    )
-
-    for row in results.fetchall():
-        assert row.valid is True
-
-    assert "email" in env.environment.data_types
-
-    assert env.environment.concepts["email"].datatype.traits == ["email"]