Support generalised annotations and uniqueness (#293)

## What is the goal of this PR?

We update the Typedb Protocol and TypeQL to the latest versions, which support the uniqueness annotation and generalised `Type` APIs. These generalised APIs allow querying by a set of annotations, rather than just boolean = `true|false`.

For example, the API: `AttributeType.get_owners(onlyKey: boolean)`, has become: `AttributeType.get_owners(annotations: Set["Annotation"])`

All usages of boolean flags to indicate key-ness should be replaced by a set of `ThingType.AnnotationEnum.KEY`. The new `@unique` annotation is available as `ThingType.AnnotationEnum.KEY`, and also usable within the APIs that accept annotations.


## What are the changes implemented in this PR?

* Update dependencies to include generalised annotations in the language and protocol. We also pull the `behaviour` repository to include tests for generalised annotations
* We reflect the changes to the behaviour test steps in the implementation of BDD steps, in particular with extensions for generalised annotations
* Update Concept API methods to remove the `*_key` boolean and replace it with a set of flags from `ThingType.Annotation`


Related protocol changes: typedb/typedb-protocol#182 and typedb/typedb-protocol@de4f5b4

Related core changes: typedb/typedb#6775 , typedb/typedb@e24cfa9 , and typedb/typedb@b16cdb0

Author: flyingsilverfin

dependencies/vaticle/artifacts.bzl

@@ -29,7 +29,7 @@ def vaticle_typedb_artifacts():
         artifact_name = "typedb-server-{platform}-{version}.{ext}",
         tag_source = deployment["artifact.release"],
         commit_source = deployment["artifact.snapshot"],
-        commit = "c36d4deeb6a7f9b53dced92002e57c1df9963f7a",
+        commit = "0f43f6654dff206d168711d90785d12df4c98b5e",
     )
 
 def vaticle_typedb_cluster_artifacts():
@@ -39,5 +39,5 @@ def vaticle_typedb_cluster_artifacts():
         artifact_name = "typedb-cluster-all-{platform}-{version}.{ext}",
         tag_source = deployment_private["artifact.release"],
         commit_source = deployment_private["artifact.snapshot"],
-        commit = "230757ad05e2b1a8cf78a3cb67d90d759de64a19",
+        commit = "9b70d31b54ed0162ce5df6ac4ab6180229bd7cb9",
     )

dependencies/vaticle/repositories.bzl

@@ -39,5 +39,5 @@ def vaticle_typedb_behaviour():
     git_repository(
         name = "vaticle_typedb_behaviour",
         remote = "https://github.com/vaticle/typedb-behaviour",
-        commit = "fbba9fc19042460760b852b765d356c9b3f4ebf0" # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_behaviour
+        commit = "aa675d9052046b1a4ffd45f444854d8735028702" # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_behaviour
     )

requirements.txt

@@ -35,6 +35,7 @@
 
 ## Dependencies
 
-typedb-protocol==2.17.0
+typedb-protocol==2.18.0.dev0
 grpcio>=1.43.0,<2
-protobuf>=3.15.5,<4
+protobuf>=3.15.6,<4
+parse==1.18.0

tests/behaviour/concept/thing/thing_steps.py

@@ -85,14 +85,14 @@ def step_impl(context: Context, var1: str, var2: str):
 @step("attribute {var1:Var} get keys contain: {var2:Var}")
 @step("relation {var1:Var} get keys contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_has(only_key=True), has_item(context.get(var2).as_attribute()))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(annotations={Annotations.KEY}), has_item(context.get(var2).as_attribute()))
 
 
 @step("entity {var1:Var} get keys do not contain: {var2:Var}")
 @step("attribute {var1:Var} get keys do not contain: {var2:Var}")
 @step("relation {var1:Var} get keys do not contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_has(only_key=True), not_(has_item(context.get(var2).as_attribute())))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(annotations={Annotations.KEY}), not_(has_item(context.get(var2).as_attribute())))
 
 
 @step("entity {var1:Var} get attributes contain: {var2:Var}")

tests/behaviour/concept/type/attributetype/attribute_type_steps.py

@@ -113,74 +113,82 @@ def step_impl(context: Context, type_label: str, value_type):
     assert_that(attribute_type.as_remote(context.tx()).get_regex(), is_(None))
 
 
-@step("attribute({type_label}) get key owners contain")
-def step_impl(context: Context, type_label: str):
+def attribute_get_owners_with_annotations_contain(context: Context, type_label: str, annotations: Set["Annotation"]):
     owner_labels = [parse_label(s) for s in parse_list(context.table)]
     attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(only_key=True)))
+    actuals = list(
+        map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(annotations=annotations)))
     for owner_label in owner_labels:
         assert_that(actuals, has_item(owner_label))
 
 
-@step("attribute({type_label}) get key owners do not contain")
-def step_impl(context: Context, type_label: str):
-    owner_labels = [parse_label(s) for s in parse_list(context.table)]
-    attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(only_key=True)))
-    for owner_label in owner_labels:
-        assert_that(actuals, not_(has_item(owner_label)))
+@step("attribute({type_label}) get owners, with annotations: {annotations:Annotations}; contain")
+def step_impl(context: Context, type_label: str, annotations: Set["Annotation"]):
+    attribute_get_owners_with_annotations_contain(context, type_label, annotations)
 
-@step("attribute({type_label}) get key owners explicit contain")
+
+@step("attribute({type_label}) get owners contain")
 def step_impl(context: Context, type_label: str):
-    owner_labels = [parse_label(s) for s in parse_list(context.table)]
-    attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(
-        map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=True)))
-    for owner_label in owner_labels:
-        assert_that(actuals, has_item(owner_label))
+    attribute_get_owners_with_annotations_contain(context, type_label, set())
 
 
-@step("attribute({type_label}) get key owners explicit do not contain")
-def step_impl(context: Context, type_label: str):
+def attribute_get_owners_with_annotations_do_not_contain(context: Context, type_label: str,
+                                                         annotations: Set["Annotation"]):
     owner_labels = [parse_label(s) for s in parse_list(context.table)]
     attribute_type = context.tx().concepts().get_attribute_type(type_label)
     actuals = list(
-        map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=True)))
+        map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(annotations=annotations)))
     for owner_label in owner_labels:
         assert_that(actuals, not_(has_item(owner_label)))
 
 
-@step("attribute({type_label}) get attribute owners contain")
+@step("attribute({type_label}) get owners, with annotations: {annotations:Annotations}; do not contain")
+def step_impl(context: Context, type_label: str, annotations: Set["Annotation"]):
+    attribute_get_owners_with_annotations_do_not_contain(context, type_label, annotations)
+
+
+@step("attribute({type_label}) get owners do not contain")
 def step_impl(context: Context, type_label: str):
+    attribute_get_owners_with_annotations_do_not_contain(context, type_label, set())
+
+
+def attribute_get_owners_explicit_with_annotations_contain(context: Context, type_label: str,
+                                                           annotations: Set["Annotation"]):
     owner_labels = [parse_label(s) for s in parse_list(context.table)]
     attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(only_key=False)))
+    actuals = list(
+        map(lambda tt: tt.get_label(),
+            attribute_type.as_remote(context.tx()).get_owners_explicit(annotations=annotations)))
     for owner_label in owner_labels:
         assert_that(actuals, has_item(owner_label))
 
 
-@step("attribute({type_label}) get attribute owners do not contain")
+@step("attribute({type_label}) get owners explicit, with annotations: {annotations:Annotations}; contain")
+def step_impl(context: Context, type_label: str, annotations: Set["Annotation"]):
+    attribute_get_owners_explicit_with_annotations_contain(context, type_label, annotations)
+
+
+@step("attribute({type_label}) get owners explicit contain")
 def step_impl(context: Context, type_label: str):
+    attribute_get_owners_explicit_with_annotations_contain(context, type_label, set())
+
+
+def attribute_get_owners_explicit_with_annotations_do_not_contain(context: Context, type_label: str,
+                                                                  annotations: Set["Annotation"]):
     owner_labels = [parse_label(s) for s in parse_list(context.table)]
     attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners(only_key=False)))
+    actuals = list(
+        map(lambda tt: tt.get_label(),
+            attribute_type.as_remote(context.tx()).get_owners_explicit(annotations=annotations)))
     for owner_label in owner_labels:
         assert_that(actuals, not_(has_item(owner_label)))
 
 
-@step("attribute({type_label}) get attribute owners explicit contain")
-def step_impl(context: Context, type_label: str):
-    owner_labels = [parse_label(s) for s in parse_list(context.table)]
-    attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=False)))
-    for owner_label in owner_labels:
-        assert_that(actuals, has_item(owner_label))
+@step("attribute({type_label}) get owners explicit, with annotations: {annotations:Annotations}; do not contain")
+def step_impl(context: Context, type_label: str, annotations: Set["Annotation"]):
+    attribute_get_owners_explicit_with_annotations_do_not_contain(context, type_label, annotations)
 
 
-@step("attribute({type_label}) get attribute owners explicit do not contain")
+@step("attribute({type_label}) get owners explicit do not contain")
 def step_impl(context: Context, type_label: str):
-    owner_labels = [parse_label(s) for s in parse_list(context.table)]
-    attribute_type = context.tx().concepts().get_attribute_type(type_label)
-    actuals = list(map(lambda tt: tt.get_label(), attribute_type.as_remote(context.tx()).get_owners_explicit(only_key=False)))
-    for owner_label in owner_labels:
-        assert_that(actuals, not_(has_item(owner_label)))
+    attribute_get_owners_explicit_with_annotations_do_not_contain(context, type_label, set())