Add concept cast methods, and add all Concept types to typedb.client (#229)

## What is the goal of this PR?

We added methods to cast concept types to each other: for example `concept.as_attribute()` will now cast a `Concept` to an `Attribute`, throwing an exception if it is not actually an `Attribute`. This aids type checking systems.

Also, all the `Concept` types are now importable from `typedb.client` directly.

## What are the changes implemented in this PR?

Add concept cast methods, and add all Concept types to typedb.client

Author: alexjpwalker

dependencies/vaticle/artifacts.bzl

@@ -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 = "25e45df9512604812f800218066b0f93435e44d2"
+        commit = "8059e3aadaa46de8de0ccf57580dd0a3a61d06a4"
     )

tests/behaviour/background/cluster/environment.py

@@ -20,8 +20,7 @@
 #
 import os
 
-from typedb.api.connection.credential import TypeDBCredential
-from typedb.client import TypeDB
+from typedb.client import *
 from tests.behaviour.background import environment_base
 from tests.behaviour.context import Context
 

tests/behaviour/background/core/environment.py

@@ -20,7 +20,7 @@
 #
 
 from tests.behaviour.background import environment_base
-from typedb.client import TypeDB
+from typedb.client import *
 from tests.behaviour.context import Context
 
 

tests/behaviour/background/environment_base.py

@@ -18,11 +18,12 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-from behave import *
 from behave.model_core import Status
 
+from typedb.client import *
+
 from tests.behaviour.config.parameters import RootLabel
-from tests.behaviour.context import Context, ThingSubtype
+from tests.behaviour.context import Context
 
 import time
 
@@ -47,7 +48,7 @@ def before_scenario(context: Context, scenario):
     context.clear_answers = lambda: _clear_answers_impl(context)
 
 
-def _put_impl(context: Context, variable: str, thing: ThingSubtype):
+def _put_impl(context: Context, variable: str, thing: Thing):
     context.things[variable] = thing
 
 

tests/behaviour/concept/thing/attribute/attribute_steps.py

@@ -23,8 +23,7 @@
 from behave import *
 from hamcrest import *
 
-from typedb.api.concept.type.attribute_type import AttributeType
-from typedb.common.exception import TypeDBClientException
+from typedb.client import *
 from tests.behaviour.context import Context
 
 
@@ -40,17 +39,17 @@ def step_impl(context: Context, type_label: str):
 
 @step("attribute {var1:Var} get owners contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var2), is_in(context.get(var1).as_remote(context.tx()).get_owners()))
+    assert_that(context.get(var2), is_in(context.get(var1).as_attribute().as_remote(context.tx()).get_owners()))
 
 
 @step("attribute {var1:Var} get owners do not contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var2), not_(is_in(context.get(var1).as_remote(context.tx()).get_owners())))
+    assert_that(context.get(var2), not_(is_in(context.get(var1).as_attribute().as_remote(context.tx()).get_owners())))
 
 
 @step("attribute {var:Var} has value type: {value_type:ValueType}")
 def step_impl(context: Context, var: str, value_type: AttributeType.ValueType):
-    assert_that(context.get(var).get_type().get_value_type(), is_(value_type))
+    assert_that(context.get(var).as_attribute().get_type().get_value_type(), is_(value_type))
 
 
 @step("attribute({type_label}) as(boolean) put: {value:Bool}; throws exception")
@@ -130,24 +129,24 @@ def step_impl(context: Context, var: str, type_label: str, value: datetime):
 
 @step("attribute {var:Var} has boolean value: {value:Bool}")
 def step_impl(context: Context, var: str, value: bool):
-    assert_that(context.get(var).get_value(), is_(value))
+    assert_that(context.get(var).as_attribute().get_value(), is_(value))
 
 
 @step("attribute {var:Var} has long value: {value:Int}")
 def step_impl(context: Context, var: str, value: int):
-    assert_that(context.get(var).get_value(), is_(value))
+    assert_that(context.get(var).as_attribute().get_value(), is_(value))
 
 
 @step("attribute {var:Var} has double value: {value:Float}")
 def step_impl(context: Context, var: str, value: float):
-    assert_that(context.get(var).get_value(), is_(value))
+    assert_that(context.get(var).as_attribute().get_value(), is_(value))
 
 
 @step("attribute {var:Var} has string value: {value}")
 def step_impl(context: Context, var: str, value: str):
-    assert_that(context.get(var).get_value(), is_(value))
+    assert_that(context.get(var).as_attribute().get_value(), is_(value))
 
 
 @step("attribute {var:Var} has datetime value: {value:DateTime}")
 def step_impl(context: Context, var: str, value: datetime):
-    assert_that(context.get(var).get_value(), is_(value))
+    assert_that(context.get(var).as_attribute().get_value(), is_(value))

tests/behaviour/concept/thing/entity/entity_steps.py

@@ -22,8 +22,7 @@
 from behave import *
 from hamcrest import *
 
-from typedb.common.exception import TypeDBClientException
-from typedb.common.label import Label
+from typedb.client import *
 from tests.behaviour.context import Context
 
 

tests/behaviour/concept/thing/relation/relation_steps.py

@@ -23,8 +23,7 @@
 from behave import *
 from hamcrest import *
 
-from typedb.common.exception import TypeDBClientException
-from typedb.common.label import Label
+from typedb.client import *
 from tests.behaviour.config.parameters import parse_dict, parse_var
 from tests.behaviour.context import Context
 
@@ -71,12 +70,14 @@ def step_impl(context: Context, type_label: str):
 
 @step("relation {var1:Var} add player for role({role_label}): {var2:Var}")
 def step_impl(context: Context, var1: str, role_label: str, var2: str):
-    context.get(var1).as_remote(context.tx()).add_player(context.get(var1).get_type().as_remote(context.tx()).get_relates(role_label), context.get(var2))
+    relation = context.get(var1).as_relation()
+    relation.as_remote(context.tx()).add_player(relation.get_type().as_remote(context.tx()).get_relates(role_label), context.get(var2))
 
 
 @step("relation {var1:Var} remove player for role({role_label}): {var2:Var}")
 def step_impl(context: Context, var1: str, role_label: str, var2: str):
-    context.get(var1).as_remote(context.tx()).remove_player(context.get(var1).get_type().as_remote(context.tx()).get_relates(role_label), context.get(var2))
+    relation = context.get(var1).as_relation()
+    relation.as_remote(context.tx()).remove_player(relation.get_type().as_remote(context.tx()).get_relates(role_label), context.get(var2))
 
 
 @step("relation {var1:Var} add player for role({role_label}): {var2:Var}; throws exception")
@@ -85,9 +86,10 @@ def step_impl(context: Context, var1: str, role_label: str, var2: str):
 
 
 def adding_player_throws_exception(context: Context, var1: str, role_label: str, var2: str):
+    relation = context.get(var1).as_relation()
     try:
-        context.get(var1).as_remote(context.tx()).add_player(
-            context.get(var1).get_type().as_remote(context.tx()).get_relates(role_label),
+        relation.as_remote(context.tx()).add_player(
+            relation.get_type().as_remote(context.tx()).get_relates(role_label),
             context.get(var2))
         assert False;
     except TypeDBClientException:
@@ -97,7 +99,7 @@ def adding_player_throws_exception(context: Context, var1: str, role_label: str,
 @step("relation {var:Var} get players contain")
 def step_impl(context: Context, var: str):
     players = parse_dict(context.table)
-    relation = context.get(var)
+    relation = context.get(var).as_relation()
     players_by_role_type = relation.as_remote(context.tx()).get_players_by_role_type()
     for (role_label, var2) in players.items():
         assert_that(players_by_role_type.get(relation.get_type().as_remote(context.tx()).get_relates(role_label)), has_item(context.get(parse_var(var2))))
@@ -106,31 +108,31 @@ def step_impl(context: Context, var: str):
 @step("relation {var:Var} get players do not contain")
 def step_impl(context: Context, var: str):
     players = parse_dict(context.table)
-    relation = context.get(var)
+    relation = context.get(var).as_relation()
     players_by_role_type = relation.as_remote(context.tx()).get_players_by_role_type()
     for (role_label, var2) in players.items():
         assert_that(players_by_role_type.get(relation.get_type().as_remote(context.tx()).get_relates(role_label)), not_(has_item(context.get(parse_var(var2)))))
 
 
 @step("relation {var1:Var} get players contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_players(), has_item(context.get(var2)))
+    assert_that(context.get(var1).as_relation().as_remote(context.tx()).get_players(), has_item(context.get(var2)))
 
 
 @step("relation {var1:Var} get players do not contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_players(), not_(has_item(context.get(var2))))
+    assert_that(context.get(var1).as_relation().as_remote(context.tx()).get_players(), not_(has_item(context.get(var2))))
 
 
 @step("relation {var1:Var} get players for role({role_label}) contain: {var2:Var}")
 def step_impl(context: Context, var1: str, role_label: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_players(
-        role_types=[context.get(var1).get_type().as_remote(context.tx()).get_relates(role_label)]),
+    relation = context.get(var1).as_relation()
+    assert_that(relation.as_remote(context.tx()).get_players(role_types=[relation.get_type().as_remote(context.tx()).get_relates(role_label)]),
         has_item(context.get(var2)))
 
 
 @step("relation {var1:Var} get players for role({role_label}) do not contain: {var2:Var}")
 def step_impl(context: Context, var1: str, role_label: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_players(
-        role_types=[context.get(var1).get_type().as_remote(context.tx()).get_relates(role_label)]),
+    relation = context.get(var1).as_relation()
+    assert_that(relation.as_remote(context.tx()).get_players(role_types=[relation.get_type().as_remote(context.tx()).get_relates(role_label)]),
         not_(has_item(context.get(var2))))

tests/behaviour/concept/thing/thing_steps.py

@@ -22,8 +22,7 @@
 from behave import *
 from hamcrest import *
 
-from typedb.common.exception import TypeDBClientException
-from typedb.common.label import Label
+from typedb.client import *
 from tests.behaviour.config.parameters import parse_bool, RootLabel
 from tests.behaviour.context import Context
 
@@ -62,7 +61,7 @@ def step_impl(context: Context, var: str):
 @step("relation {var1:Var} set has: {var2:Var}; throws exception")
 def step_impl(context: Context, var1: str, var2: str):
     try:
-        context.get(var1).as_remote(context.tx()).set_has(context.get(var2))
+        context.get(var1).as_remote(context.tx()).set_has(context.get(var2).as_attribute())
         assert False
     except TypeDBClientException:
         pass
@@ -72,35 +71,35 @@ def step_impl(context: Context, var1: str, var2: str):
 @step("attribute {var1:Var} set has: {var2:Var}")
 @step("relation {var1:Var} set has: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    context.get(var1).as_remote(context.tx()).set_has(context.get(var2))
+    context.get(var1).as_remote(context.tx()).set_has(context.get(var2).as_attribute())
 
 
 @step("entity {var1:Var} unset has: {var2:Var}")
 @step("attribute {var1:Var} unset has: {var2:Var}")
 @step("relation {var1:Var} unset has: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    context.get(var1).as_remote(context.tx()).unset_has(context.get(var2))
+    context.get(var1).as_remote(context.tx()).unset_has(context.get(var2).as_attribute())
 
 
 @step("entity {var1:Var} get keys contain: {var2:Var}")
 @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)))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(only_key=True), 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))))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(only_key=True), not_(has_item(context.get(var2).as_attribute())))
 
 
 @step("entity {var1:Var} get attributes contain: {var2:Var}")
 @step("attribute {var1:Var} get attributes contain: {var2:Var}")
 @step("relation {var1:Var} get attributes contain: {var2:Var}")
 def step_impl(context: Context, var1: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_has(), has_item(context.get(var2)))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(), has_item(context.get(var2).as_attribute()))
 
 
 @step("entity {var1:Var} get attributes({type_label}) contain: {var2:Var}")
@@ -122,14 +121,14 @@ def step_impl(context: Context, var1: str, var2: str):
 @step("attribute {var1:Var} get attributes({type_label}) as(datetime) contain: {var2:Var}")
 @step("relation {var1:Var} get attributes({type_label}) as(datetime) contain: {var2:Var}")
 def step_impl(context: Context, var1: str, type_label: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_has(attribute_type=context.tx().concepts().get_attribute_type(type_label)), has_item(context.get(var2)))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(attribute_type=context.tx().concepts().get_attribute_type(type_label)), has_item(context.get(var2).as_attribute()))
 
 
 @step("entity {var1:Var} get attributes do not contain: {var2:Var}")
 @step("attribute {var1:Var} get attributes do not contain: {var2:Var}")
 @step("relation {var1:Var} get attributes 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(), not_(has_item(context.get(var2))))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(), not_(has_item(context.get(var2).as_attribute())))
 
 
 @step("entity {var1:Var} get attributes({type_label}) do not contain: {var2:Var}")
@@ -151,7 +150,8 @@ def step_impl(context: Context, var1: str, var2: str):
 @step("attribute {var1:Var} get attributes({type_label}) as(datetime) do not contain: {var2:Var}")
 @step("relation {var1:Var} get attributes({type_label}) as(datetime) do not contain: {var2:Var}")
 def step_impl(context: Context, var1: str, type_label: str, var2: str):
-    assert_that(context.get(var1).as_remote(context.tx()).get_has(attribute_type=context.tx().concepts().get_attribute_type(type_label)), not_(has_item(context.get(var2))))
+    assert_that(context.get(var1).as_remote(context.tx()).get_has(attribute_type=context.tx().concepts().get_attribute_type(type_label)),
+                not_(has_item(context.get(var2).as_attribute())))
 
 
 @step("entity {var1:Var} get relations({label:ScopedLabel}) contain: {var2:Var}")

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

@@ -22,7 +22,7 @@
 from behave import *
 from hamcrest import *
 
-from typedb.api.concept.type.attribute_type import AttributeType
+from typedb.client import *
 from tests.behaviour.config.parameters import parse_value_type, parse_list, parse_label
 from tests.behaviour.context import Context
 
@@ -39,7 +39,7 @@ def step_impl(context: Context, type_label: str, value_type: str):
 
 @step("attribute({type_label}) get supertype value type: {value_type}")
 def step_impl(context: Context, type_label: str, value_type: str):
-    supertype = context.tx().concepts().get_attribute_type(type_label).as_remote(context.tx()).get_supertype()
+    supertype = context.tx().concepts().get_attribute_type(type_label).as_remote(context.tx()).get_supertype().as_attribute_type()
     assert_that(supertype.get_value_type(), is_(parse_value_type(value_type)))
 
 

tests/behaviour/concept/type/relationtype/relation_type_steps.py

@@ -22,8 +22,7 @@
 from behave import *
 from hamcrest import *
 
-from typedb.common.exception import TypeDBClientException
-from typedb.common.label import Label
+from typedb.client import *
 from tests.behaviour.config.parameters import parse_list, parse_bool, parse_label
 from tests.behaviour.context import Context