dxpy 0.361.0__tar.gz → 0.363.0__tar.gz

{dxpy-0.361.0 → dxpy-0.363.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dxpy
-Version: 0.361.0
+Version: 0.363.0
 Summary: DNAnexus Platform API bindings for Python
 Home-page: https://github.com/dnanexus/dx-toolkit
 Author: Aleksandra Zalcman, Andrey Kislyuk, Anurag Biyani, Geet Duggal, Katherine Lai, Kurt Jensen, Marek Hrvol, Ohad Rodeh, Phil Sung

{dxpy-0.361.0 → dxpy-0.363.0}/dxpy/bindings/search.py

@@ -114,7 +114,7 @@ def find_data_objects(classname=None, state=None, visibility=None,
                       modified_after=None, modified_before=None,
                       created_after=None, created_before=None,
                       describe=False, limit=None, level=None, region=None,
-                      return_handler=False, first_page_size=100,
+                      archival_state=None, return_handler=False, first_page_size=100,
                       **kwargs):
     """
     :param classname:
@@ -160,9 +160,11 @@ def find_data_objects(classname=None, state=None, visibility=None,
         things, be used to customize the set of fields that is returned)
     :type describe: bool or dict
     :param level: The minimum permissions level for which results should be returned (one of "VIEW", "UPLOAD", "CONTRIBUTE", or "ADMINISTER")
+    :type level: string
     :param region: Filter on result set by the given region(s).
     :type region: string or list of strings
-    :type level: string
+    :param archival_state: Filter by the given archival state (one of "archived", "live", "archival", “unarchiving”, or "any"). Requires classname="file", project, and folder arguments to be provided.
+    :type archival_state: string 
     :param limit: The maximum number of results to be returned (if not specified, the number of results is unlimited)
     :type limit: int
     :param first_page_size: The number of results that the initial API call will return. Subsequent calls will raise this by multiplying by 2 up to a maximum of 1000.
@@ -260,6 +262,8 @@ def find_data_objects(classname=None, state=None, visibility=None,
         query['level'] = level
     if region is not None:
         query['region'] = region
+    if archival_state is not None:
+        query['archivalState'] = archival_state
     if limit is not None:
         query["limit"] = limit
 

{dxpy-0.361.0 → dxpy-0.363.0}/dxpy/cli/dataset_utilities.py

@@ -28,6 +28,7 @@ import csv
 import dxpy
 import codecs
 import subprocess
+from functools import reduce
 from ..utils.printing import fill
 from ..bindings import DXRecord
 from ..bindings.dxdataobject_functions import is_dxlink, describe
@@ -35,6 +36,7 @@ from ..bindings.dxfile import DXFile
 from ..utils.resolver import resolve_existing_path, is_hashid, ResolutionError, resolve_path, check_folder_exists
 from ..utils.file_handle import as_handle
 from ..utils.describe import print_desc
+from ..compat import USING_PYTHON2
 from ..exceptions import (
     err_exit,
     PermissionDenied,
@@ -1127,13 +1129,29 @@ def resolve_validate_dx_path(path):
 class VizserverError(Exception):
     pass
 
-def validate_cohort_ids(descriptor, project, resp,ids):
+def validate_cohort_ids(descriptor, project, resp, ids):
     # Usually the name of the table
     entity_name = descriptor.model["global_primary_key"]["entity"]
     # The name of the column or field in the table
     field_name = descriptor.model["global_primary_key"]["field"] 
 
+    # Get data type of global primay key field
+    gpk_type = descriptor.model["entities"][entity_name]["fields"][field_name]["mapping"]["column_sql_type"]
     # Prepare a payload to find entries matching the input ids in the dataset
+    if gpk_type in ["integer", "bigint"]:
+        if USING_PYTHON2:
+            lambda_for_list_conv = lambda a, b: a+[long(b)]
+        else:
+            lambda_for_list_conv = lambda a, b: a+[int(b)]
+    elif gpk_type in ["float", "double"]:
+        lambda_for_list_conv = lambda a, b: a+[float(b)]
+    elif gpk_type in ["string"]:
+        lambda_for_list_conv = lambda a, b: a+[str(b)]
+    else:
+        err_msg = "Invalid input record. Cohort ID field in the input dataset or cohortbrowser record is of type, {type}. Support is currently only available for Cohort ID fields having one of the following types; string, integer and float".format(type = gpk_type)
+        raise ValueError(err_msg) 
+    id_list = reduce(lambda_for_list_conv, ids, [])
+
     entity_field_name = "{}${}".format(entity_name, field_name)
     fields_list = [{field_name: entity_field_name}]
 
@@ -1145,7 +1163,7 @@ def validate_cohort_ids(descriptor, project, resp,ids):
             "pheno_filters": {
                 "filters": {
                     entity_field_name: [
-                        {"condition": "in", "values": ids}
+                        {"condition": "in", "values": id_list}
                     ]
                 }
             }
@@ -1167,11 +1185,13 @@ def validate_cohort_ids(descriptor, project, resp,ids):
         discovered_ids.add(result[field_name])
 
     # Compare the discovered cohort ids to the user-provided cohort ids
-    if discovered_ids != set(ids):
+    if discovered_ids != set(id_list):
         # Find which given samples are not present in the dataset
-        missing_ids = set(ids).difference(discovered_ids)
+        missing_ids = set(id_list).difference(discovered_ids)
         err_msg = "The following supplied IDs do not match IDs in the main entity of dataset, {dataset_name}: {ids}".format(dataset_name = resp["dataset"], ids = missing_ids)
         raise ValueError(err_msg)
+    
+    return id_list, lambda_for_list_conv
 
         
 def has_access_level(project, access_level):
@@ -1249,23 +1269,26 @@ def create_cohort(args):
     rec_descriptor = DXDataset(resp["dataset"], project=dataset_project).get_descriptor()
 
     try:
-        validate_cohort_ids(rec_descriptor, dataset_project, resp, samples)
+        list_of_ids, lambda_for_list_conv = validate_cohort_ids(rec_descriptor, dataset_project, resp, samples)
     except ValueError as err:
-        err_exit(str(err))
+        err_exit(str(err), expected_exceptions=(ValueError,))
     except VizserverError as err:
-        err_exit(str(err))
+        err_exit(str(err), expected_exceptions=(VizserverError,))
     except Exception as err:
         err_exit(str(err))
     # Input cohort IDs have been succesfully validated    
 
+    # converting list of IDs to list of string IDs
+
     base_sql = resp.get("baseSql", resp.get("base_sql"))
     try:
         raw_cohort_query_payload = cohort_filter_payload(
-            samples,
+            list_of_ids,
             rec_descriptor.model["global_primary_key"]["entity"],
             rec_descriptor.model["global_primary_key"]["field"],
             resp.get("filters", {}),
             from_project,
+            lambda_for_list_conv,
             base_sql,
         )
     except Exception as e:
@@ -1321,7 +1344,7 @@ class DXDataset(DXRecord):
         assert self._record_type in self.types
         assert "descriptor" in self.details
         if is_dxlink(self.details["descriptor"]):
-            self.descriptor_dxfile = DXFile(self.details["descriptor"], mode="rb")
+            self.descriptor_dxfile = DXFile(self.details["descriptor"], mode="rb", project=project)
         else:
             err_exit("%s : Invalid cohort or dataset" % self.details["descriptor"])
         self.descriptor = None

{dxpy-0.361.0 → dxpy-0.363.0}/dxpy/dx_extract_utils/cohort_filter_payload.py

@@ -1,7 +1,8 @@
 import copy
+from functools import reduce
 
 
-def generate_pheno_filter(values, entity, field, filters):
+def generate_pheno_filter(values, entity, field, filters, lambda_for_list_conv):
 
     if "pheno_filters" not in filters:
         # Create a pheno_filter if none exists. This will be a compound filter
@@ -33,9 +34,9 @@ def generate_pheno_filter(values, entity, field, filters):
             if primary_filter["condition"] == "exists":
                 pass
             elif primary_filter["condition"] == "in":
-                values = sorted(set(values).intersection(set(primary_filter["values"])))
+                values = sorted(set(values).intersection(set(reduce(lambda_for_list_conv, primary_filter["values"], []))))
             elif primary_filter["condition"] == "not-in":
-                values = sorted(set(values) - set(primary_filter["values"]))
+                values = sorted(set(values) - set(reduce(lambda_for_list_conv, primary_filter["values"], [])))
             else:
                 raise ValueError("Invalid input cohort."
                                  " Cohorts cannot have conditions other than \"in\", \"not-in\", or \"exists\" on the primary entity and field.")
@@ -82,11 +83,11 @@ def generate_pheno_filter(values, entity, field, filters):
     return filters
 
 
-def cohort_filter_payload(values, entity, field, filters, project_context, base_sql=None):
+def cohort_filter_payload(values, entity, field, filters, project_context, lambda_for_list_conv, base_sql=None):
     if "logic" in filters and filters["logic"] != "and":
         raise ValueError("Invalid input cohort. Cohorts must have 'and' logic on the primary entity and field.")
     filter_payload = {}
-    filter_payload["filters"] = generate_pheno_filter(values, entity, field, filters)
+    filter_payload["filters"] = generate_pheno_filter(values, entity, field, filters, lambda_for_list_conv)
     if "logic" not in filter_payload["filters"]:
         filter_payload["filters"]["logic"] = "and"
     filter_payload["project_context"] = project_context

dxpy-0.363.0/dxpy/toolkit_version.py

@@ -0,0 +1 @@
+version = '0.363.0'

{dxpy-0.361.0 → dxpy-0.363.0}/dxpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dxpy
-Version: 0.361.0
+Version: 0.363.0
 Summary: DNAnexus Platform API bindings for Python
 Home-page: https://github.com/dnanexus/dx-toolkit
 Author: Aleksandra Zalcman, Andrey Kislyuk, Anurag Biyani, Geet Duggal, Katherine Lai, Kurt Jensen, Marek Hrvol, Ohad Rodeh, Phil Sung

{dxpy-0.361.0 → dxpy-0.363.0}/test/test_create_cohort.py

@@ -419,8 +419,9 @@ class TestCreateCohort(unittest.TestCase):
             "logic": "and",
         }
         expected_sql = "SELECT `patient_1`.`patient_id` AS `patient_id` FROM `database_yyyyyyyyyyyyyyyyyyyyyyyy__create_cohort_pheno_database`.`patient` AS `patient_1` WHERE `patient_1`.`patient_id` IN ('patient_1', 'patient_2');"
+        lambda_for_list_conv = lambda a, b: a+[str(b)]
         
-        generated_filter = generate_pheno_filter(values, entity, field, filters)
+        generated_filter = generate_pheno_filter(values, entity, field, filters, lambda_for_list_conv)
         self.assertEqual(expected_filter, generated_filter)
 
         # Testing raw cohort query api
@@ -471,8 +472,9 @@ class TestCreateCohort(unittest.TestCase):
             visualize_response = json.load(f)
         filters = visualize_response.get("filters", {})
         base_sql = visualize_response.get("baseSql", visualize_response.get("base_sql"))
+        lambda_for_list_conv = lambda a, b: a+[str(b)]
 
-        test_payload = cohort_filter_payload(values, entity, field, filters, project_context, base_sql)
+        test_payload = cohort_filter_payload(values, entity, field, filters, project_context, lambda_for_list_conv, base_sql)
 
         with open(os.path.join(self.payloads_dir, "raw-cohort-query_input", "{}.json".format(payload_name))) as f:
             valid_payload = json.load(f)

dxpy-0.361.0/dxpy/toolkit_version.py

@@ -1 +0,0 @@
-version = '0.361.0'