Move custom query strings inline.

Author: florijanstamenkovic

labelbox/schema/benchmark.py

@@ -19,13 +19,8 @@ class Benchmark(DbObject):
     reference_label = Relationship.ToOne("Label", False, "reference_label")
 
     def delete(self):
-        query_str, params = _delete_benchmark(self.reference_label())
-        self.client.execute(query_str, params)
-
-
-def _delete_benchmark(label):
-    label_id_param = "labelId"
-    query_str = """mutation DeleteBenchmarkPyApi($%s: ID!) {
-        deleteBenchmark(where: {labelId: $%s}) {id}} """ % (
-            label_id_param, label_id_param)
-    return query_str, {label_id_param: label.uid}
+        label_param = "labelId"
+        query_str = """mutation DeleteBenchmarkPyApi($%s: ID!) {
+            deleteBenchmark(where: {labelId: $%s}) {id}} """ % (
+                label_param, label_param)
+        self.client.execute(query_str, {label_param: self.reference_label().uid})

labelbox/schema/data_row.py

@@ -1,6 +1,5 @@
 from labelbox.orm import query
-from labelbox.orm.db_object import (DbObject, Updateable, Deletable,
-                                    BulkDeletable)
+from labelbox.orm.db_object import DbObject, Updateable, BulkDeletable
 from labelbox.orm.model import Entity, Field, Relationship
 from labelbox.pagination import PaginatedCollection
 
@@ -43,23 +42,19 @@ def create_metadata(self, meta_type, meta_value):
         Return:
             AssetMetadata DB object.
         """
-        query_str, params = _create_metadata(meta_type, meta_value, self.uid)
-        res = self.client.execute(query_str, params)
+        meta_type_param = "meta_type"
+        meta_value_param = "meta_value"
+        data_row_id_param = "data_row_id"
+        query_str = """mutation CreateAssetMetadataPyApi(
+            $%s: MetadataType!, $%s: String!, $%s: ID!) {
+            createAssetMetadata(data: {
+                metaType: $%s metaValue: $%s dataRowId: $%s}) {%s}} """ % (
+            meta_type_param, meta_value_param, data_row_id_param,
+            meta_type_param, meta_value_param, data_row_id_param,
+            query.results_query_part(Entity.named("AssetMetadata")))
+
+        res = self.client.execute(
+            query_str, {meta_type_param: meta_type, meta_value_param: meta_value,
+                        data_row_id_param: self.uid})
         return Entity.named("AssetMetadata")(
             self.client, res["data"]["createAssetMetadata"])
-
-
-def _create_metadata(meta_type, meta_value, data_row_id):
-    meta_type_param = "meta_type"
-    meta_value_param = "meta_value"
-    data_row_id_param = "data_row_id"
-    query_str = """mutation CreateAssetMetadataPyApi(
-        $%s: MetadataType!, $%s: String!, $%s: ID!) {
-        createAssetMetadata(data: {
-            metaType: $%s metaValue: $%s dataRowId: $%s}) {%s}} """ % (
-        meta_type_param, meta_value_param, data_row_id_param,
-        meta_type_param, meta_value_param, data_row_id_param,
-        query.results_query_part(Entity.named("AssetMetadata")))
-    return query_str, {meta_type_param: meta_type,
-                       meta_value_param: meta_value,
-                       data_row_id_param: data_row_id}

labelbox/schema/dataset.py

@@ -3,7 +3,6 @@
 import os
 
 from labelbox.exceptions import InvalidQueryError, ResourceNotFoundError
-from labelbox.orm import query
 from labelbox.orm.db_object import DbObject, Updateable, Deletable
 from labelbox.orm.model import Entity, Field, Relationship
 
@@ -121,9 +120,15 @@ def convert_item(item):
         descriptor_url = self.client.upload_data(data)
 
         # Create data source
-        res = self.client.execute(*_create_data_rows(self.uid, descriptor_url))
+        dataset_param = "dataSetId"
+        url_param = "jsonURL"
+        query_str = """mutation AppendRowsToDatasetPyApi($%s: ID!, $%s: String!){
+            appendRowsToDataset(data:{datasetId: $%s, jsonFileUrl: $%s}
+            ){ taskId accepted } } """ % (
+                dataset_param, url_param, dataset_param, url_param)
+        res = self.client.execute(
+            query_str, {dataset_param: self.uid, url_param: descriptor_url})
         res = res["data"]["appendRowsToDataset"]
-
         if not res["accepted"]:
             raise MalformedRequestError(
                 "Server did not accept DataRow creation request", data)
@@ -167,25 +172,3 @@ def data_row_for_external_id(self, external_id):
             raise ResourceNotFoundError(DataRow, where)
 
         return data_rows[0]
-
-
-def _create_data_rows(dataset_id, json_file_url):
-    """ Generates the query and parameters dictionary for creating multiple
-    DataRows for a Dataset.
-
-    Args:
-        dataset_id (str): ID of the Dataset object to create DataRows for.
-        json_file_url (str): URL of the file containing row data.
-    Return:
-        (query_string, parameters_dict)
-    """
-    dataset_param = "dataSetId"
-    url_param = "jsonURL"
-    query_str = """mutation AppendRowsToDatasetPyApi(
-                    $%s: ID!, $%s: String!){
-          appendRowsToDataset(data:{datasetId: $%s, jsonFileUrl: $%s}
-        ){ taskId accepted } } """ % (dataset_param, url_param, dataset_param,
-                                      url_param)
-
-    return query_str, {dataset_param: dataset_id, url_param: json_file_url}
-

labelbox/schema/label.py

@@ -48,16 +48,11 @@ def create_benchmark(self):
         Return:
             The newly created Benchmark.
         """
-        query_str, params = _create_benchmark(self)
-        res = self.client.execute(query_str, params)
+        label_id_param = "labelId"
+        query_str = """mutation CreateBenchmarkPyApi($%s: ID!) {
+            createBenchmark(data: {labelId: $%s}) {%s}} """ % (
+                label_id_param, label_id_param,
+                query.results_query_part(Entity.named("Benchmark")))
+        res = self.client.execute(query_str, {label_id_param: self.uid})
         res = res["data"]["createBenchmark"]
         return Entity.named("Benchmark")(self.client, res)
-
-
-def _create_benchmark(label):
-    label_id_param = "labelId"
-    query_str = """mutation CreateBenchmarkPyApi($%s: ID!) {
-        createBenchmark(data: {labelId: $%s}) {%s}} """ % (
-            label_id_param, label_id_param,
-            query.results_query_part(Entity.named("Benchmark")))
-    return query_str, {label_id_param: label.uid}

labelbox/schema/project.py

@@ -69,9 +69,29 @@ def create_label(self, **kwargs):
         return Label(self.client, res)
 
     def labels(self, datasets=None, order_by=None):
-        query_string, params = _project_labels(self, datasets, order_by)
-        return PaginatedCollection(self.client, query_string, params,
-                                   ["project", "labels"], Entity.named("Label"))
+        Label = Entity.named("Label")
+
+        if datasets is not None:
+            where = " where:{dataRow: {dataset: {id_in: [%s]}}}" % ", ".join(
+                '"%s"' % dataset.uid for dataset in datasets)
+        else:
+            where = ""
+
+        if order_by is not None:
+            query.check_order_by_clause(Label, order_by)
+            order_by_str = "orderBy: %s_%s" % (
+                order_by[0].graphql_name, order_by[1].name.upper())
+        else:
+            order_by_str = ""
+
+        query_str = """query GetProjectLabelsPyApi($project_id: ID!)
+            {project (where: {id: $project_id})
+                {labels (skip: %%d first: %%d%s%s) {%s}}}""" % (
+            where, order_by_str, query.results_query_part(Label))
+
+        return PaginatedCollection(
+            self.client, query_str, {"project_id": self.uid},
+            ["project", "labels"], Label)
 
     def export_labels(self, timeout_seconds=60):
         """ Calls the server-side Label exporting that generates a JSON
@@ -84,7 +104,11 @@ def export_labels(self, timeout_seconds=60):
                 is returned.
         """
         sleep_time = 2
-        query_str, id_param = _export_labels()
+        id_param = "projectId"
+        query_str = """mutation GetLabelExportUrlPyApi($%s: ID!)
+            {exportLabels(data:{projectId: $%s }) {downloadUrl createdAt shouldPoll} }
+        """ %  (id_param, id_param)
+
         while True:
             res = self.client.execute(query_str, {id_param: self.uid})[
                 "data"]["exportLabels"]
@@ -104,7 +128,14 @@ def labeler_performance(self):
         Returns:
             A PaginatedCollection of LabelerPerformance objects.
         """
-        query_str, params = _labeler_performance(self)
+        project_id_param = "projectId"
+        query_str = """query LabelerPerformancePyApi($%s: ID!) {
+            project(where: {id: $%s}) {
+                labelerPerformance(skip: %%d first: %%d) {
+                    count user {%s} secondsPerLabel totalTimeLabeling consensus
+                    averageBenchmarkAgreement lastActivityTime}
+            }}""" % (project_id_param, project_id_param,
+                     query.results_query_part(Entity.named("User")))
 
         def create_labeler_performance(client, result):
             result["user"] = Entity.named("User")(client, result["user"])
@@ -113,9 +144,9 @@ def create_labeler_performance(client, result):
             return LabelerPerformance(**{utils.snake_case(key): value
                                          for key, value in result.items()})
 
-        return PaginatedCollection(self.client, query_str, params,
-                                   ["project", "labelerPerformance"],
-                                   create_labeler_performance)
+        return PaginatedCollection(
+            self.client, query_str, {project_id_param: self.uid},
+            ["project", "labelerPerformance"], create_labeler_performance)
 
     def review_metrics(self, net_score):
         """ Returns this Project's review metrics.
@@ -127,8 +158,13 @@ def review_metrics(self, net_score):
         if net_score not in (None,) + tuple(Entity.named("Review").NetScore):
             raise InvalidQueryError("Review metrics net score must be either None "
                                     "or one of Review.NetScore values")
-        query_str, params = _project_review_metrics(self, net_score)
-        res = self.client.execute(query_str, params)
+        project_id_param = "project_id"
+        net_score_literal = "None" if net_score is None else net_score.name
+        query_str = """query ProjectReviewMetricsPyApi($%s: ID!){
+            project(where: {id:$%s})
+            {reviewMetrics {labelAggregate(netScore: %s) {count}}}
+        }""" % (project_id_param, project_id_param, net_score_literal)
+        res = self.client.execute(query_str, {project_id_param: self.uid})
         return res["data"]["project"]["reviewMetrics"]["labelAggregate"]["count"]
 
     def setup(self, labeling_frontend, labeling_frontend_options):
@@ -162,8 +198,15 @@ def set_labeling_parameter_overrides(self, data):
         Return:
             bool indicating if the operation was a success.
         """
-        query_str, params = _set_labeling_parameter_overrides(self, data)
-        res = self.client.execute(query_str, params)
+        data_str = ",\n".join(
+            "{dataRow: {id: \"%s\"}, priority: %d, numLabels: %d }" % (
+                data_row.uid, priority, num_labels)
+            for data_row, priority, num_labels in data)
+        project_param = "projectId"
+        query_str = """mutation setLabelingParameterOverridesPyApi($%s: ID!){
+            project(where: { id: $%s }) {setLabelingParameterOverrides
+            (data: [%s]) {success}}} """ % (project_param, project_param, data_str)
+        res = self.client.execute(query_str, {project_param: self.uid})
         return res["data"]["project"]["setLabelingParameterOverrides"]["success"]
 
     def unset_labeling_parameter_overrides(self, data_rows):
@@ -173,8 +216,13 @@ def unset_labeling_parameter_overrides(self, data_rows):
         Return:
             bool indicating if the operation was a success.
         """
-        query_str, params = _unset_labeling_parameter_overrides(self, data_rows)
-        res = self.client.execute(query_str, params)
+        project_param = "projectId"
+        query_str = """mutation unsetLabelingParameterOverridesPyApi($%s: ID!){
+            project(where: { id: $%s}) {
+            unsetLabelingParameterOverrides(data: [%s]) { success }}}""" % (
+            project_param, project_param,
+            ",\n".join("{dataRowId: \"%s\"}" % row.uid for row in data_rows))
+        res = self.client.execute(query_str, {project_param: self.uid})
         return res["data"]["project"]["unsetLabelingParameterOverrides"]["success"]
 
 
@@ -188,112 +236,3 @@ class LabelingParameterOverride(DbObject):
     "consensus average_benchmark_agreement last_activity_time")
 LabelerPerformance.__doc__ = "Named tuple containing info about a labeler's " \
     "performance."
-
-
-def _project_labels(project, datasets, order_by):
-    """ Returns the query and params for getting a Project's labels
-    relationship. A non-standard relationship query is used to support
-    filtering on Datasets.
-    Args:
-        datasets (list or None): The datasets filter. If None it's
-            ignored.
-    Return:
-        (query_string, params)
-    """
-    Label = Entity.named("Label")
-
-    if datasets is not None:
-        where = " where:{dataRow: {dataset: {id_in: [%s]}}}" % ", ".join(
-            '"%s"' % dataset.uid for dataset in datasets)
-    else:
-        where = ""
-
-    if order_by is not None:
-        query.check_order_by_clause(Label, order_by)
-        order_by_str = "orderBy: %s_%s" % (
-            order_by[0].graphql_name, order_by[1].name.upper())
-    else:
-        order_by_str = ""
-
-    query_str = """query GetProjectLabelsPyApi($project_id: ID!)
-        {project (where: {id: $project_id})
-            {labels (skip: %%d first: %%d%s%s) {%s}}}""" % (
-        where, order_by_str, query.results_query_part(Label))
-    return query_str, {"project_id": project.uid}
-
-
-def _export_labels():
-    """ Returns the query and ID param for exporting a Project's
-    labels.
-    Return:
-        (query_string, id_param_name)
-    """
-    id_param = "projectId"
-    query_str = """mutation GetLabelExportUrlPyApi($%s: ID!) {exportLabels(data:{
-        projectId: $%s } ) {
-        downloadUrl createdAt shouldPoll } }
-    """ %  (id_param, id_param)
-    return (query_str, id_param)
-
-
-def _labeler_performance(project):
-    project_id_param = "projectId"
-    query_str = """query LabelerPerformancePyApi($%s: ID!) {
-        project(where: {id: $%s}) {
-            labelerPerformance(skip: %%d first: %%d) {
-                count user {%s} secondsPerLabel totalTimeLabeling consensus
-                averageBenchmarkAgreement lastActivityTime}
-        }
-    }""" % (project_id_param, project_id_param,
-            query.results_query_part(Entity.named("User")))
-
-    return query_str, {project_id_param: project.uid}
-
-
-def _project_review_metrics(project, net_score):
-    project_id_param = "project_id"
-    net_score_literal = "None" if net_score is None else net_score.name
-    query_str = """query ProjectReviewMetricsPyApi($%s: ID!){
-        project(where: {id:$%s})
-        {reviewMetrics {labelAggregate(netScore: %s) {count}}}
-    }""" % (project_id_param, project_id_param, net_score_literal)
-
-    return query_str, {project_id_param: project.uid}
-
-
-def _set_labeling_parameter_overrides(project, data):
-    """ Constructs a query for setting labeling parameter overrides.
-    Args:
-        project (Project): The project to set param overrides for.
-            data (iterable): An iterable of tuples. Each tuple must contain
-                (DataRow, priority, numberOfLabels) for the new override.
-    Return:
-        (query_string, query_parameters)
-    """
-    data_str = ",\n".join(
-        "{dataRow: {id: \"%s\"}, priority: %d, numLabels: %d }" % (
-            data_row.uid, priority, num_labels)
-        for data_row, priority, num_labels in data)
-    query_str = """mutation setLabelingParameterOverridesPyApi {
-        project(where: { id: "%s" }) {
-            setLabelingParameterOverrides(data: [%s]) { success } } } """ % (
-                project.uid, data_str)
-    return query_str, {}
-
-
-def _unset_labeling_parameter_overrides(project, data_rows):
-    """ Constructs a query for unsetting labeling parameter overrides.
-    Args:
-        project (Project): The project to set param overrides for.
-        data_rows (iterable): An iterable of DataRow objects
-            for which the to set as parameter overrides.
-    Return:
-        (query_string, query_parameters)
-    """
-    data_str = ",\n".join("{dataRowId: \"%s\"}" % data_row.uid
-                          for data_row in data_rows)
-    query_str = """mutation unsetLabelingParameterOverridesPyApi {
-        project(where: { id: "%s" }) {
-            unsetLabelingParameterOverrides(data: [%s]) { success } } } """ % (
-                project.uid, data_str)
-    return query_str, {}