archive-gh-me/earthengine-api
1
0
Fork 0
mirror of https://github.com/google/earthengine-api.git synced 2025-12-08 19:26:12 +00:00
Code Issues Projects Releases Wiki Activity
earthengine-api/python/ee/filter.py
Kurt Schwehr f63eb81c08 Unify python arguments types in _arg_types.py. 
PiperOrigin-RevId: 660924888
2024-08-08 11:52:08 -07:00

1008 lines
35 KiB
Python
Raw Blame History

"""Collection filters.
Example usage:
Filter('time', low, high)
.bounds(ring)
.eq('time', value)
.lt('time', value)
"""
# Using lowercase function naming to match the JavaScript names.
# pylint: disable=g-bad-name
from __future__ import annotations
from typing import Optional
from ee import _arg_types
from ee import _utils
from ee import apifunction
from ee import computedobject
from ee import ee_exception
# A map from the deprecated old-style comparison operator names to API
# function names, implicitly prefixed with "Filter.". Negative operators
# (those starting with "not_") are not included.
_FUNCTION_NAMES = {
'equals': 'equals',
'less_than': 'lessThan',
'greater_than': 'greaterThan',
'contains': 'stringContains',
'starts_with': 'stringStartsWith',
'ends_with': 'stringEndsWith',
}
class Filter(computedobject.ComputedObject):
"""An object to represent collection filters."""
_initialized = False
# Tell pytype to not complain about dynamic attributes.
_HAS_DYNAMIC_ATTRIBUTES = True
@_utils.accept_opt_prefix(('opt_filter', 'filter_'))
def __init__(self, filter_=None):
"""Construct a filter.
This constructor accepts the following args:
1) Another filter.
2) An array of filters (which are implicitly ANDed together).
3) A ComputedObject returning a filter. Users shouldn't be making these;
they're produced by the generator functions below.
Args:
filter_: Optional filter to add.
"""
self.initialize()
if isinstance(filter_, (list, tuple)):
if not filter_:
raise ee_exception.EEException('Empty list specified for ee.Filter().')
elif len(filter_) == 1:
filter_ = filter_[0]
else:
self._filter = tuple(filter_)
super().__init__(
apifunction.ApiFunction.lookup('Filter.and'),
{'filters': self._filter})
return
if isinstance(filter_, computedobject.ComputedObject):
super().__init__(filter_.func, filter_.args, filter_.varName)
self._filter = (filter_,)
elif filter_ is None:
# A silly call with no arguments left for backward-compatibility.
# Encoding such a filter is expected to fail, but it can be composed
# by calling the various methods that end up in _append().
super().__init__(None, None)
self._filter = ()
else:
raise ee_exception.EEException(
'Invalid argument specified for ee.Filter(): %s' % filter_
)
@classmethod
def initialize(cls) -> None:
"""Imports API functions to this class."""
if not cls._initialized:
apifunction.ApiFunction.importApi(cls, cls.name(), cls.name())
cls._initialized = True
@classmethod
def reset(cls) -> None:
"""Removes imported API functions from this class."""
apifunction.ApiFunction.clearApi(cls)
cls._initialized = False
def predicateCount(self) -> int:
"""Return the number of predicates that have been added to this filter.
Returns:
The number of predicates that have been added to this filter.
This does not count nested predicates.
"""
return len(self._filter)
def _append(self, new_filter: _arg_types.Filter) -> Filter:
"""Append a predicate to this filter.
These are implicitly ANDed.
Args:
new_filter: The filter to append to this one. Possible types are:
1) another fully constructed Filter,
2) a JSON representation of a filter,
3) an array of 1 or 2.
Returns:
A new filter that is the combination of both.
"""
if new_filter is None:
raise ValueError('new_filter should never be None')
prev = list(self._filter)
if isinstance(new_filter, Filter):
prev.extend(new_filter._filter) # pylint: disable=protected-access
elif isinstance(new_filter, list):
prev.extend(new_filter)
else:
prev.append(new_filter)
return Filter(prev)
@staticmethod
def metadata_(name: str, operator: str, value: _arg_types.Any) -> Filter:
"""Filter on metadata. This is deprecated.
Args:
name: The property name to filter on.
operator: The type of comparison. One of:
"equals", "less_than", "greater_than", "contains", "begins_with",
"ends_with", or any of these prefixed with "not_".
value: The value to compare against.
Returns:
The new filter.
Deprecated. Use ee.Filter.eq(), ee.Filter.gte(), etc.'
"""
operator = operator.lower()
# Check for negated filters.
negated = False
if operator.startswith('not_'):
negated = True
operator = operator[4:]
# Convert the operator to a function.
if operator not in _FUNCTION_NAMES:
raise ee_exception.EEException(
'Unknown filtering operator: %s' % operator)
func_name = 'Filter.' + _FUNCTION_NAMES[operator]
new_filter = apifunction.ApiFunction.call_(func_name, name, value)
return new_filter.Not() if negated else new_filter
@staticmethod
def name() -> str:
return 'Filter'
@staticmethod
def And(*args) -> Filter:
"""Combine two or more filters using boolean AND."""
if len(args) == 1 and isinstance(args[0], (list, tuple)):
args = args[0]
return apifunction.ApiFunction.call_('Filter.and', args)
@staticmethod
def area(
min: _arg_types.Number, # pylint: disable=redefined-builtin
max: _arg_types.Number, # pylint: disable=redefined-builtin
# pylint: disable=invalid-name
maxError: Optional[_arg_types.ErrorMargin] = None,
geometrySelector: Optional[_arg_types.String] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns an area filter of the geometry.
Returns a filter that passes if the specified geometry has an area within
the given range (inclusive).
Args:
min: Minimum area in square meters (inclusive).
max: Maximum area in square meters (inclusive).
maxError: The maximum allowed error for computing the geometry's area.
geometrySelector: The name of the geometry property to use for filtering.
Leave blank or use '.geo' to operate on the object's geometry.
"""
return apifunction.ApiFunction.call_(
'Filter.area', min, max, maxError, geometrySelector
)
@staticmethod
def dateRangeContains(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if a date range contains a date.
Creates a unary or binary filter that passes if the left operand, a date
range, contains the right operand, a date.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.dateRangeContains', leftField, rightValue, rightField, leftValue
)
@staticmethod
@_utils.accept_opt_prefix('opt_errorMargin')
def bounds(
geometry: _arg_types.Geometry,
# pylint: disable-next=invalid-name
errorMargin: Optional[_arg_types.ErrorMargin] = None,
) -> Filter:
"""Returns a filter on intersection with geometry.
Items in the collection with a footprint that fails to intersect
the given geometry will be excluded. This is an alias for geometry().
Caution: providing a large or complex collection as the `geometry` argument
can result in poor performance. Collating the geometry of collections does
not scale well; use the smallest collection (or geometry) that is required
to achieve the desired outcome.
Args:
geometry: The geometry to filter to either as a GeoJSON geometry, or a
FeatureCollection, from which a geometry will be extracted.
errorMargin: An optional error margin. If a number, interpreted as sphere
surface meters.
"""
return Filter.geometry(geometry, errorMargin)
@staticmethod
def calendarRange(
start: _arg_types.Integer,
end: Optional[_arg_types.Integer] = None,
field: Optional[_arg_types.String] = None,
) -> Filter:
"""Returns a filter that passes if a timestamp is in a range.
Returns a filter that passes if the object's timestamp falls within the
given range of a calendar field.
The `month`, `day_of_year`, `day_of_month`, and `day_of_week` are 1-based.
Times are assumed to be in UTC. Weeks are assumed to begin on Monday as day
1. If `end` < `start` then this tests for `value` >= `start` OR `value` <=
`end`, to allow for wrapping.
Args:
start: The start of the desired calendar field, inclusive.
end: The end of the desired calendar field, inclusive. Defaults to the
same value as start.
field: The calendar field to filter over. Options are: `year`, `month`,
`hour`, `minute`, `day_of_year`, `day_of_month`, and `day_of_week`.
"""
return apifunction.ApiFunction.call_(
'Filter.calendarRange', start, end, field
)
@staticmethod
def contains(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
maxError: Optional[_arg_types.ErrorMargin] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the left contains the right geometry.
Creates a unary or binary filter that passes if the left geometry contains
the right geometry (empty geometries are not contained in anything).
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
maxError: The maximum reprojection error allowed during filter
application.
"""
return apifunction.ApiFunction.call_(
'Filter.contains',
leftField,
rightValue,
rightField,
leftValue,
maxError,
)
@staticmethod
@_utils.accept_opt_prefix('opt_end')
def date(
start: _arg_types.Date, end: Optional[_arg_types.Date] = None
) -> Filter:
"""Filter images by date.
The start and end may be a Date, numbers (interpreted as milliseconds since
1970-01-01T00:00:00Z), or strings (such as '1996-01-01T08:00'). Based on
'system:time_start'.
Args:
start: The inclusive start date.
end: The optional exclusive end date, If not specified, a 1-millisecond
range starting at 'start' is created.
Returns:
The modified filter.
"""
date_range = apifunction.ApiFunction.call_('DateRange', start, end)
return apifunction.ApiFunction.apply_('Filter.dateRangeContains', {
'leftValue': date_range,
'rightField': 'system:time_start'
})
@staticmethod
def dayOfYear(start: _arg_types.Integer, end: _arg_types.Integer) -> Filter:
"""Returns a day-of-year filter.
Returns a filter that passes if the object's timestamp falls within the
given day-of-year range.
Args:
start: The start of the desired day range, inclusive.
end: The end of the desired day range, inclusive.
"""
return apifunction.ApiFunction.call_('Filter.dayOfYear', start, end)
@staticmethod
def disjoint(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
maxError: Optional[_arg_types.ErrorMargin] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter.
Creates a unary or binary filter that passes unless the left geometry
intersects the right geometry.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
maxError: The maximum reprojection error allowed during filter
application.
"""
return apifunction.ApiFunction.call_(
'Filter.disjoint',
leftField,
rightValue,
rightField,
leftValue,
maxError,
)
@staticmethod
def eq(name: _arg_types.String, value: _arg_types.Any) -> Filter:
"""Filter to metadata equal to the given value."""
return apifunction.ApiFunction.call_('Filter.equals', name, value)
@staticmethod
def equals(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the two operands are equals.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.equals', leftField, rightValue, rightField, leftValue
)
@staticmethod
def expression(expression) -> Filter:
"""Returns a filter tree from a string.
Args:
expression: A string to be parsed into a Filter object (e.g., "property >
value"). Supported operators include: >, >=, <, <=, ==, !=, (), !, &&
and ||.
"""
return apifunction.ApiFunction.call_('Filter.expression', expression)
@staticmethod
@_utils.accept_opt_prefix('opt_errorMargin')
def geometry(
geometry: _arg_types.Geometry,
# pylint: disable-next=invalid-name
errorMargin: Optional[_arg_types.ErrorMargin] = None,
):
"""Filter on intersection with geometry.
Items in the collection with a footprint that fails to intersect
the given geometry will be excluded.
Args:
geometry: The geometry to filter to either as a GeoJSON geometry, or a
FeatureCollection, from which a geometry will be extracted.
errorMargin: An optional error margin. If a number, interpreted as sphere
surface meters.
Returns:
The constructed filter.
"""
# Invoke geometry promotion then manually promote to a Feature.
args = {
'leftField': '.all',
'rightValue': apifunction.ApiFunction.call_('Feature', geometry)
}
if errorMargin is not None:
args['maxError'] = errorMargin
return apifunction.ApiFunction.apply_('Filter.intersects', args)
@staticmethod
def greaterThan(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if value is greater than the right operand.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.greaterThan', leftField, rightValue, rightField, leftValue
)
@staticmethod
def greaterThanOrEquals(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns filter that passes if value is greater than the right operand.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.greaterThanOrEquals',
leftField,
rightValue,
rightField,
leftValue,
)
@staticmethod
def gt(name: _arg_types.String, value: _arg_types.Any) -> Filter:
"""Filter on metadata greater than the given value."""
return apifunction.ApiFunction.call_('Filter.greaterThan', name, value)
@staticmethod
def gte(name: _arg_types.String, value: _arg_types.Any) -> Filter:
"""Filter on metadata greater than or equal to the given value."""
return Filter.lt(name, value).Not()
@staticmethod
def hasType(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the left has the type.
Creates a unary or binary filter that passes if the left operand has the
type, or is a subtype of the type named in the right operand.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
Returns:
An ee.Filter.
"""
return apifunction.ApiFunction.call_(
'Filter.hasType', leftField, rightValue, rightField, leftValue
)
@staticmethod
def intersects(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
maxError: Optional[_arg_types.ErrorMargin] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if left intersects the right geometry.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
maxError: The maximum reprojection error allowed during filter
application.
"""
return apifunction.ApiFunction.call_(
'Filter.intersects',
leftField,
rightValue,
rightField,
leftValue,
maxError,
)
@staticmethod
def isContained(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
maxError: Optional[_arg_types.ErrorMargin] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns filter that passes if the right geometry contains the geometry.
Empty geometries are not contained in anything.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
maxError: The maximum reprojection error allowed during filter
application.
"""
return apifunction.ApiFunction.call_(
'Filter.isContained',
leftField,
rightValue,
rightField,
leftValue,
maxError,
)
@staticmethod
@_utils.accept_opt_prefix(
'opt_leftField', 'opt_rightValue', 'opt_rightField', 'opt_leftValue'
)
def inList(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Filter on metadata contained in a list.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
Returns:
The constructed filter.
"""
# Implement this in terms of listContains, with the arguments switched.
# In listContains the list is on the left side, while in inList it's on
# the right.
return apifunction.ApiFunction.apply_(
'Filter.listContains',
{
'leftField': rightField,
'rightValue': leftValue,
'rightField': leftField,
'leftValue': rightValue,
},
)
@staticmethod
def lessThan(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns filter that passes if the value is less than the right operand.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.lessThan', leftField, rightValue, rightField, leftValue
)
@staticmethod
def lessThanOrEquals(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns filter that passes if the value is less than the right operand.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.lessThanOrEquals', leftField, rightValue, rightField, leftValue
)
@staticmethod
def listContains(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns filter that passes if the left, contains the right.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
Returns:
An ee.Filter.
"""
return apifunction.ApiFunction.call_(
'Filter.listContains', leftField, rightValue, rightField, leftValue
)
@staticmethod
def lt(name: _arg_types.String, value: _arg_types.Any) -> Filter:
"""Filter to metadata less than the given value."""
return apifunction.ApiFunction.call_('Filter.lessThan', name, value)
@staticmethod
def lte(name: _arg_types.String, value: _arg_types.Any) -> Filter:
"""Filter on metadata less than or equal to the given value."""
return Filter.gt(name, value).Not()
@staticmethod
def maxDifference(
difference: _arg_types.Number,
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the fields are within a given difference.
Creates a unary or binary filter that passes if the left and right operands,
both numbers, are within a given maximum difference.
If used as a join condition, this numeric difference is used as a join
measure.
Args:
difference: The maximum difference for which the filter will return true.
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.maxDifference',
difference,
leftField,
rightValue,
rightField,
leftValue,
)
@staticmethod
def neq(name: _arg_types.String, value: _arg_types.Any) -> Filter:
"""Filter to metadata not equal to the given value."""
return Filter.eq(name, value).Not()
@staticmethod
def notEquals(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes unless the two operands are equal.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.notEquals', leftField, rightValue, rightField, leftValue
)
def Not(self) -> Filter:
"""Returns the opposite of this filter.
Returns:
The negated filter, which will match if and only if this filter does not.
"""
return apifunction.ApiFunction.call_('Filter.not', self)
@staticmethod
def notNull(properties: _arg_types.List) -> Filter:
"""Returns a filter that passes if all the named properties are not null."""
return apifunction.ApiFunction.call_('Filter.notNull', properties)
@staticmethod
def Or(*args) -> Filter:
"""Combine two or more filters using boolean OR."""
if len(args) == 1 and isinstance(args[0], (list, tuple)):
args = args[0]
return apifunction.ApiFunction.call_('Filter.or', args)
@staticmethod
def rangeContains(
field: _arg_types.String,
minValue: _arg_types.Number, # pylint: disable=invalid-name
maxValue: _arg_types.Number, # pylint: disable=invalid-name
) -> Filter:
"""Returns a filter that passes if the value is in the range.
Returns a filter that passes if the value of the selected field is in the
specified range (inclusive).
Args:
field: A selector for the property being tested.
minValue: The lower bound of the range.
maxValue: The upper bound of the range.
"""
return apifunction.ApiFunction.call_(
'Filter.rangeContains', field, minValue, maxValue
)
@staticmethod
def stringContains(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if it contains the right string.
Creates a unary or binary filter that passes if the left operand, a string,
contains the right operand, also a string.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.stringContains', leftField, rightValue, rightField, leftValue
)
@staticmethod
def stringEndsWith(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the string ends with the right string.
Creates a unary or binary filter that passes if the left operand, a string,
ends with the right operand, also a string.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.stringEndsWith', leftField, rightValue, rightField, leftValue
)
@staticmethod
def stringStartsWith(
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the string starts with the right string.
Creates a unary or binary filter that passes if the left operand, a string,
starts with the right operand, also a string.
Args:
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
"""
return apifunction.ApiFunction.call_(
'Filter.stringStartsWith', leftField, rightValue, rightField, leftValue
)
@staticmethod
def withinDistance(
distance: _arg_types.Number,
# pylint: disable=invalid-name
leftField: Optional[_arg_types.String] = None,
rightValue: Optional[_arg_types.Any] = None,
rightField: Optional[_arg_types.String] = None,
leftValue: Optional[_arg_types.Any] = None,
maxError: Optional[_arg_types.ErrorMargin] = None,
# pylint: enable=invalid-name
) -> Filter:
"""Returns a filter that passes if the geometry is within a distance.
Creates a unary or binary filter that passes if the left geometry is within
a specified distance of the right geometry. If used as a join condition,
this distance is used as a join measure.
Args:
distance: The maximum distance for which the filter will return true.
leftField: A selector for the left operand. Should not be specified if
leftValue is specified.
rightValue: The value of the right operand. Should not be specified if
rightField is specified.
rightField: A selector for the right operand. Should not be specified if
rightValue is specified.
leftValue: The value of the left operand. Should not be specified if
leftField is specified.
maxError: The maximum reprojection error allowed during filter
application.
"""
return apifunction.ApiFunction.call_(
'Filter.withinDistance',
distance,
leftField,
rightValue,
rightField,
leftValue,
maxError,
)
Reference in New Issue View Git Blame Copy Permalink