Fix issues 43337, 43611 (#48)

- Add get_domain_details API to domain module
- Fix Issue 43337
- Fix ConditionalFormat.to_json to match what LabKey Server response
- domain.save: support optional "options"

Author: labkey-alan

CHANGE.txt

@@ -2,6 +2,12 @@
 LabKey Python Client API News
 +++++++++++
 
+What's New in the LabKey 2.2.0 package
+==============================
+- Add `domain.get_domain_details` API to domain module.
+- Support saving domain options via `domain.save`.
+- Fix `ConditionalFormat.to_json()` to match server response.
+
 What's New in the LabKey 2.1.1 package
 ==============================
 

labkey/__init__.py

@@ -16,6 +16,6 @@
 from labkey import domain, query, experiment, security, utils
 
 __title__ = "labkey"
-__version__ = "2.1.1"
+__version__ = "2.2.0"
 __author__ = "LabKey"
 __license__ = "Apache License 2.0"

labkey/domain.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 #
 import functools
-from typing import Union, List
+from typing import Dict, List, Union, Tuple
 
 from .server_context import ServerContext
 from labkey.query import QueryFilter
@@ -207,12 +207,12 @@ def __init__(self, **kwargs):
 
     def to_json(self):
         data = {
-            "backgroundColor": self.background_color,
+            "backgroundcolor": self.background_color,
             "bold": self.bold,
             "filter": self.filter,
             "italic": self.italic,
             "strikethrough": self.strike_through,
-            "textColor": self.text_color,
+            "textcolor": self.text_color,
         }
 
         return data
@@ -392,12 +392,12 @@ def create(
     domain = None
 
     # domainDesign is not required when creating a domain from a template
-    if domain_definition["domainDesign"] is not None:
+    if domain_definition.get("domainDesign", None) is not None:
         domain_fields = domain_definition["domainDesign"]["fields"]
         domain_definition["domainDesign"]["fields"] = list(
             map(__format_conditional_filters, domain_fields)
         )
-    
+
     raw_domain = server_context.make_request(url, json=domain_definition)
 
     if raw_domain is not None:
@@ -436,13 +436,50 @@ def get(
     """
     url = server_context.build_url("property", "getDomain.api", container_path=container_path)
     payload = {"schemaName": schema_name, "queryName": query_name}
-    domain = None
     raw_domain = server_context.make_request(url, payload, method="GET")
 
+    if raw_domain is not None:
+        return Domain(**raw_domain)
+
+    return None
+
+
+def get_domain_details(
+    server_context: ServerContext,
+    schema_name: str = None,
+    query_name: str = None,
+    domain_id: int = None,
+    domain_kind: str = None,
+    container_path: str = None,
+) -> Tuple[Domain, Dict]:
+    """
+    Gets a domain design and its associated options.
+    :param server_context: A LabKey server context. See utils.create_server_context.
+    :param schema_name: schema of table
+    :param query_name: table name of domain to get
+    :param domain_id: id of domain to get
+    :param domain_kind: domainKind of domain to get
+    :param container_path: labkey container path if not already set in context
+    :return: Domain, Dict
+    """
+    url = server_context.build_url(
+        "property", "getDomainDetails.api", container_path=container_path
+    )
+    payload = {
+        "schemaName": schema_name,
+        "queryName": query_name,
+        "domainId": domain_id,
+        "domainKind": domain_kind,
+    }
+    response = server_context.make_request(url, payload, method="GET")
+    raw_domain = response.get("domainDesign", None)
+    domain = None
+    options = response.get("options", None)
+
     if raw_domain is not None:
         domain = Domain(**raw_domain)
 
-    return domain
+    return domain, options
 
 
 def infer_fields(
@@ -473,6 +510,7 @@ def save(
     query_name: str,
     domain: Domain,
     container_path: str = None,
+    options: Dict = None,
 ) -> any:
     """
     Saves the provided domain design
@@ -481,6 +519,7 @@ def save(
     :param query_name: query name of domain
     :param domain: Domain to save
     :param container_path: labkey container path if not already set in context
+    :param options: associated domain options to be saved
     :return:
     """
     url = server_context.build_url("property", "saveDomain.api", container_path=container_path)
@@ -490,6 +529,9 @@ def save(
         "schemaName": schema_name,
     }
 
+    if options is not None:
+        payload["options"] = options
+
     return server_context.make_request(url, json=payload)
 
 
@@ -513,10 +555,30 @@ def drop(self, schema_name: str, query_name: str, container_path: str = None):
     def get(self, schema_name: str, query_name: str, container_path: str = None):
         return get(self.server_context, schema_name, query_name, container_path)
 
+    @functools.wraps(get_domain_details)
+    def get_domain_details(
+        self,
+        schema_name: str = None,
+        query_name: str = None,
+        domain_id: int = None,
+        domain_kind: str = None,
+        container_path: str = None,
+    ):
+        return get_domain_details(
+            self.server_context, schema_name, query_name, domain_id, domain_kind, container_path
+        )
+
     @functools.wraps(infer_fields)
     def infer_fields(self, data_file: any, container_path: str = None):
         return infer_fields(self.server_context, data_file, container_path)
 
     @functools.wraps(save)
-    def save(self, schema_name: str, query_name: str, domain: Domain, container_path: str = None):
-        return save(self.server_context, schema_name, query_name, domain, container_path)
+    def save(
+        self,
+        schema_name: str,
+        query_name: str,
+        domain: Domain,
+        container_path: str = None,
+        options: Dict = None,
+    ):
+        return save(self.server_context, schema_name, query_name, domain, container_path, options)

samples/domain_example.py

@@ -65,9 +65,9 @@
 dataset_domain = api.domain.create(dataset_domain_definition)
 
 ###################
-# Get a domain
+# Get a domain and it's associated options
 ###################
-list_domain = api.domain.get("lists", "BloodTypes")
+list_domain, list_domain_options = api.domain.get_domain_details("lists", "BloodTypes")
 
 # examine different from the domain
 print(list_domain.name)
@@ -82,10 +82,13 @@
 fields_file = open("data/infer.tsv", "rb")
 inferred_fields = api.domain.infer_fields(fields_file)
 
+# Update the description via domain options
+list_domain_options["description"] = "Contains all known human blood types"
+
 for field in inferred_fields:
     list_domain.add_field(field)
 
-api.domain.save("lists", "BloodTypes", list_domain)
+api.domain.save("lists", "BloodTypes", list_domain, options=list_domain_options)
 
 ###################
 # Drop a domain

test/integration/conftest.py

@@ -61,6 +61,6 @@ def project(server_context_vars):
         # The project may not exist, and that is ok.
         pass
 
-    project_ = container.create(context, PROJECT_NAME, folder_type="study")
+    project_ = container.create(context, PROJECT_NAME, folder_type="Study")
     yield project_
     container.delete(context, PROJECT_NAME)

test/integration/test_domain.py

@@ -166,8 +166,6 @@ def test_remove_conditional_format(api: APIWrapper, list_fixture):
 
 
 def test_update_conditional_format_serialize_filter(api: APIWrapper, list_fixture):
-    from labkey.query import QueryFilter
-
     new_filter = QueryFilter("formatted", 15, QueryFilter.Types.GREATER_THAN_OR_EQUAL)
     cf = conditional_format(new_filter, text_color="ff00ff")
 
@@ -232,3 +230,34 @@ def test_create_list_with_conditional_formatted_field(api: APIWrapper):
             assert len(field.conditional_formats) == 2
 
     api.domain.drop(LISTS_SCHEMA, "composed_list_name")
+
+
+def test_get_domain_details(api: APIWrapper, list_fixture):
+    # test retrieving domain by specifying schema/query
+    domain, options = api.domain.get_domain_details(LISTS_SCHEMA, LIST_NAME)
+    assert domain.name == LIST_NAME
+    assert len(domain.fields) == 2
+    assert domain.fields[0].name == "rowId"
+    assert domain.fields[1].name == "formatted"
+    assert domain.fields[1].conditional_formats[0].to_json() == CONDITIONAL_FORMAT[0]
+    assert options["keyName"] == "rowId"
+    assert options["name"] == LIST_NAME
+
+    # test retrieving domain by specifying domainId
+    assert domain.domain_id is not None
+    domain_from_id, domain_from_id_options = api.domain.get_domain_details(
+        domain_id=domain.domain_id
+    )
+    assert domain_from_id.name == LIST_NAME
+
+
+def test_domain_save_options(api: APIWrapper, list_fixture):
+    domain, options = api.domain.get_domain_details(LISTS_SCHEMA, LIST_NAME)
+    expected_description = "updated description from test"
+    assert options.get("description") != expected_description
+
+    options["description"] = expected_description
+    api.domain.save(LISTS_SCHEMA, LIST_NAME, domain, options=options)
+
+    updated_domain, updated_options = api.domain.get_domain_details(LISTS_SCHEMA, LIST_NAME)
+    assert updated_options.get("description") == expected_description