add update and number-in options, reduce number of custom types replacing with custom callbacks

Author: jreiberkyle

planet/cli/data.py

@@ -14,12 +14,12 @@
 """The Planet Data CLI."""
 from datetime import datetime
 import json
-from typing import List
+from typing import List, Union
 from contextlib import asynccontextmanager
 
 import click
 
-from planet import data_filter, io, DataClient, Session
+from planet import data_filter, exceptions, io, DataClient, Session
 
 from .cmds import coro, translate_exceptions
 from .io import echo_json
@@ -80,15 +80,6 @@ def parse_filter(ctx, param, value: str) -> dict:
         return json_value
 
 
-def assets_to_filter(ctx, param, value: str) -> dict:
-    if value is None:
-        return value
-
-    # manage assets as comma-separated names
-    assets = [part.strip() for part in value.split(",")]
-    return data_filter.asset_filter(assets)
-
-
 def geom_to_filter(ctx, param, value: str) -> dict:
     if value is None:
         return value
@@ -122,19 +113,15 @@ def _parse_geom(ctx, param, value: str) -> dict:
 
 
 class FieldType(click.ParamType):
+    """Clarify that this entry is for a field"""
     name = 'field'
-    help = 'FIELD is the name of the field to filter on.'
-
-    def convert(self, value, param, ctx):
-        return value
 
 
 class ComparisonType(click.ParamType):
     name = 'comp'
     valid = ['lt', 'lte', 'gt', 'gte']
-    help = 'COMP can be lt, lte, gt, or gte.'
 
-    def convert(self, value, param, ctx):
+    def convert(self, value, param, ctx) -> str:
         if value not in self.valid:
             self.fail(f'COMP ({value}) must be one of {",".join(self.valid)}',
                       param,
@@ -145,106 +132,164 @@ def convert(self, value, param, ctx):
 class GTComparisonType(ComparisonType):
     """Only support gt or gte comparison"""
     valid = ['gt', 'gte']
-    help = 'COMP can be gt, or gte.'
 
 
 class DateTimeType(click.ParamType):
     name = 'datetime'
-    help = 'DATETIME can be an RFC 3339 or ISO 8601 string.'
 
-    def convert(self, value, param, ctx):
+    def convert(self, value, param, ctx) -> datetime:
         if isinstance(value, datetime):
             return value
         else:
-            return io.str_to_datetime(value)
+            try:
+                return io.str_to_datetime(value)
+            except exceptions.PlanetError as e:
+                self.fail(str(e))
 
 
-class DateRangeFilter(click.Tuple):
-    help = ('Filter by date range in field. ' +
-            f'{FieldType.help} {ComparisonType.help} {DateTimeType.help}')
+class CommaSeparatedString(click.types.StringParamType):
+    """A list of strings that is extracted from a comma-separated string."""
 
-    def __init__(self) -> None:
-        super().__init__([FieldType(), ComparisonType(), DateTimeType()])
+    def convert(self, value, param, ctx) -> List[str]:
+        value = super().convert(value, param, ctx)
+
+        if isinstance(value, list):
+            return value
+        else:
+            return [part.strip() for part in value.split(",")]
+
+
+class CommaSeparatedFloat(CommaSeparatedString):
+    """A list of floats that is extracted from a comma-separated string."""
+    name = 'VALUE'
 
     def convert(self, value, param, ctx):
-        vals = super().convert(value, param, ctx)
+        values = super().convert(value, param, ctx)
+
+        try:
+            return [float(v) for v in values]
+        except ValueError:
+            self.fail(f'Cound not convert all entries in {value} to float.')
+
+
+def assets_to_filter(ctx, param, assets: str) -> dict:
+    if assets:
+        # TODO: validate and normalize
+        return data_filter.asset_filter(assets)
 
-        field, comp, value = vals
+
+def date_range_to_filter(ctx, param, values) -> Union[List[dict], None]:
+
+    def _func(obj):
+        field, comp, value = obj
         kwargs = {'field_name': field, comp: value}
         return data_filter.date_range_filter(**kwargs)
 
+    if values:
+        return [_func(v) for v in values]
 
-class RangeFilter(click.Tuple):
-    help = ('Filter by number range in field. ' +
-            f'{FieldType.help} {ComparisonType.help}')
 
-    def __init__(self) -> None:
-        super().__init__([FieldType(), ComparisonType(), float])
+def range_to_filter(ctx, param, values) -> Union[List[dict], None]:
 
-    def convert(self, value, param, ctx):
-        vals = super().convert(value, param, ctx)
-
-        field, comp, value = vals
+    def _func(obj):
+        field, comp, value = obj
         kwargs = {'field_name': field, comp: value}
         return data_filter.range_filter(**kwargs)
 
+    if values:
+        return [_func(v) for v in values]
 
-class UpdateFilter(click.Tuple):
-    help = ('Filter to items with changes to a specified field value made ' +
-            'after a specified date.' +
-            f'{FieldType.help} {GTComparisonType.help} {DateTimeType.help}')
-
-    def __init__(self) -> None:
-        super().__init__([FieldType(), GTComparisonType(), DateTimeType()])
 
-    def convert(self, value, param, ctx):
-        vals = super().convert(value, param, ctx)
+def update_to_filter(ctx, param, values) -> Union[List[dict], None]:
 
-        field, comp, value = vals
+    def _func(obj):
+        field, comp, value = obj
         kwargs = {'field_name': field, comp: value}
         return data_filter.update_filter(**kwargs)
 
+    if values:
+        return [_func(v) for v in values]
+
+
+def number_in_to_filter(ctx, param, values) -> Union[dict, None]:
+
+    def _func(obj):
+        field, values = obj
+        return data_filter.number_in_filter(field_name=field, values=values)
+
+    if values:
+        return [_func(v) for v in values]
+
 
 @data.command()
 @click.pass_context
 @translate_exceptions
 @pretty
 @click.option('--asset',
-              type=str,
+              type=CommaSeparatedString(),
               default=None,
               callback=assets_to_filter,
-              help='Filter to items with one or more of specified assets.')
+              help="""Filter to items with one or more of specified assets.
+    VALUE is a comma-separated list of entries.
+    When multiple entries are specified  an implicit 'or' logic is applied.""")
 @click.option('--date-range',
-              type=DateRangeFilter(),
+              type=click.Tuple([FieldType(), ComparisonType(),
+                                DateTimeType()]),
+              callback=date_range_to_filter,
               multiple=True,
-              help=DateRangeFilter.help)
+              help="""Filter by date range in field.
+    FIELD is the name of the field to filter on.
+    COMP can be lt, lte, gt, or gte.
+    DATETIME can be an RFC3339 or ISO 8601 string.""")
 @click.option('--geom',
               type=str,
               default=None,
               callback=geom_to_filter,
               help='Filter to items that overlap a given geometry.')
-# @click.option('--number-in',
-#               type=RangeFilter(),
-#               multiple=True,
-#               help=RangeFilter.help)
+@click.option('--number-in',
+              type=click.Tuple([FieldType(), CommaSeparatedFloat()]),
+              multiple=True,
+              callback=number_in_to_filter,
+              help="""Filter field by numeric in.
+    FIELD is the name of the field to filter on.
+    VALUE is a comma-separated list of entries.
+    When multiple entries are specified  an implicit 'or' logic is applied.""")
 @click.option('--range',
               'nrange',
-              type=RangeFilter(),
+              type=click.Tuple([FieldType(), ComparisonType(), float]),
+              callback=range_to_filter,
               multiple=True,
-              help=RangeFilter.help)
+              help="""Filter by date range in field.
+    FIELD is the name of the field to filter on.
+    COMP can be lt, lte, gt, or gte.
+    DATETIME can be an RFC3339 or ISO 8601 string.""")
 # @click.option('--string-in',
 #               type=RangeFilter(),
 #               multiple=True,
 #               help=RangeFilter.help)
-@click.option('--update',
-              type=UpdateFilter(),
-              multiple=True,
-              help=UpdateFilter.help)
+@click.option(
+    '--update',
+    type=click.Tuple([FieldType(), GTComparisonType(), DateTimeType()]),
+    callback=update_to_filter,
+    multiple=True,
+    help="""Filter to items with changes to a specified field value made after
+    a specified date.
+    FIELD is the name of the field to filter on.
+    COMP can be gt or gte.
+    DATETIME can be an RFC3339 or ISO 8601 string.""")
 @click.option('--permission',
               type=bool,
               default=True,
               help='Filter to assets with download permissions.')
-def filter(ctx, asset, date_range, geom, nrange, update, permission, pretty):
+def filter(ctx,
+           asset,
+           date_range,
+           geom,
+           number_in,
+           nrange,
+           update,
+           permission,
+           pretty):
     """Create a structured item search filter.
 
     This command provides basic functionality for specifying a filter by
@@ -255,11 +300,24 @@ def filter(ctx, asset, date_range, geom, nrange, update, permission, pretty):
     """
     permission = data_filter.permission_filter() if permission else None
 
+    filter_options = (asset,
+                      date_range,
+                      geom,
+                      number_in,
+                      nrange,
+                      update,
+                      permission)
+
     # options allowing multiples are broken up so one filter is created for
     # each time the option is specified
-    filter_args = (asset, *date_range, geom, *nrange, *update, permission)
-
-    filters = [f for f in filter_args if f]
+    # unspecified options are skipped
+    filters = []
+    for f in filter_options:
+        if f:
+            if isinstance(f, list):
+                filters.extend(f)
+            else:
+                filters.append(f)
 
     if filters:
         if len(filters) > 1:

tests/integration/test_data_cli.py

@@ -172,6 +172,36 @@ def test_data_filter_geom(geom_fixture,
     assert_and_filters_equal(json.loads(result.output), expected_filt)
 
 
+# @pytest.mark.skip
+@respx.mock
+@pytest.mark.asyncio
+def test_data_filter_number_in(
+                          invoke,
+                          assert_and_filters_equal):
+    runner = CliRunner()
+
+    result = invoke(["filter"] + '--number-in field 1'.split() +
+                    '--number-in field2 2,3.5'.split(),
+                    runner=runner)
+    assert result.exit_code == 0
+
+    number_in_filter1 = {
+        "type": "NumberInFilter", "field_name": "field", "config": [1.0]
+    }
+    number_in_filter2 = {
+        "type": "NumberInFilter",
+        "field_name": "field2",
+        "config": [2.0, 3.5]
+        }
+
+    expected_filt = {
+        "type": "AndFilter",
+        "config": [permission_filter, number_in_filter1, number_in_filter2]
+    }
+
+    assert_and_filters_equal(json.loads(result.output), expected_filt)
+
+
 @respx.mock
 @pytest.mark.asyncio
 def test_data_filter_range(invoke, assert_and_filters_equal):