def __init__(self, iterable): if self._type_params is None: raise TypeError( "Cannot instantiate a generic List; the item type must be specified (like `List[Int]`)" ) if isinstance(iterable, type(self)): self.graft = client.apply_graft("list.copy", iterable) elif isinstance(iterable, List): raise ProxyTypeError( "Cannot convert {} to {}, since they have different value types" .format(type(iterable).__name__, type(self).__name__)) else: if not isinstance(iterable, abc.Iterable): raise ProxyTypeError( "Expected an iterable, got {}".format(iterable)) value_type = self._type_params[0] def checker_promoter(i, x): try: return value_type._promote(x) except ProxyTypeError: raise ProxyTypeError( "{}: Expected iterable values of type {}, but for item {}, got {!r}" .format(type(self).__name__, value_type, i, x)) iterable = tuple( checker_promoter(i, x) for i, x in enumerate(iterable)) self.graft = client.apply_graft("list", *iterable)
def __init__(self, arr): if self._type_params is None: raise TypeError( "Cannot instantiate a generic Array; " "the dtype and dimensionality must be specified (like `Array[Float, 3]`). " "Alternatively, Arrays can be instantiated with `from_numpy` " "(like `Array.from_numpy(my_array)`).") if isinstance(arr, np.ndarray): if arr.dtype.kind != WF_TO_DTYPE_KIND[self.dtype]: raise TypeError("Invalid dtype {} for an {}".format( arr.dtype, type(self).__name__)) if arr.ndim != self.ndim: raise ValueError( "Cannot instantiate a {}-dimensional Workflows Array from a " "{}-dimensional NumPy array".format(self.ndim, arr.ndim)) arr_list = arr.tolist() self.graft = client.apply_graft("array.create", arr_list) else: list_type = functools.reduce( lambda accum, cur: List[accum], range(self._type_params[1]), self._type_params[0], ) try: arr = list_type._promote(arr) except ProxyTypeError: raise ValueError( "Cannot instantiate an Array from {!r}".format(arr)) self.graft = client.apply_graft("array.create", arr)
def __init__(self, imgs, func): """ You should construct `ImageCollectionGroupby` from `.ImageCollection.groupby` in most cases. Parameters ---------- imgs: ImageCollection `ImageCollection` to group func: Function Key function which takes an `Image` and returns which group the `Image` belongs to. Must return an instance of ``self.key_type``. Returns ------- grouped: ImageCollectionGroupby """ if self._type_params is None: raise TypeError( "Cannot instantiate a generic {}; the item type must be specified".format( type(self).__name__ ) ) self.graft = client.apply_graft("ImageCollectionGroupby.create", imgs, func) # store this once so that repeated calls to `.groups` refer to the same object in the graft self._groups = Dict[self.key_type, ImageCollection]._from_apply( "ImageCollectionGroupby.groups", self )
def __init__(self, iterable): value_types = self._type_params if value_types is None: raise TypeError( "Cannot instantiate a generic Tuple; the item types must be specified (like `Tuple[Int, Float]`)" ) # TODO: copy constructor if not isinstance(iterable, abc.Iterable): raise ProxyTypeError( "Expected an iterable, got {}".format(iterable)) try: length = len(iterable) except TypeError: iterable = tuple(iterable) length = len(iterable) if length != len(self._type_params): raise ProxyTypeError( "To construct {}, expected an iterable of {} items, " "but got {} items".format( type(self).__name__, len(self._type_params), length)) def checker_promoter(i, x): cls = value_types[i] try: return cls._promote(x) except ProxyTypeError: raise ProxyTypeError( "While constructing {}, expected {} for tuple element {}, but got {!r}" .format(type(self).__name__, cls, i, x)) iterable = tuple( checker_promoter(i, x) for i, x in enumerate(iterable)) self.graft = client.apply_graft("tuple", *iterable)
def _update_value(self, change): if not self.trait_has_value("xyz_obj"): # avoids crazy tracebacks in __init__ when given bad arguments, # and `hold_trait_notifications` tries to fire notifiers _before_ # reraising the exception: `xyz_obj` might not be set yet, # and accessing it would cause its own spew of confusing traitlets errors. return if len(self.xyz_obj.params) > 0: try: # attept to promote parameters as the Function's arguments args, kwargs = self.xyz_obj.object._promote_arguments( **self.parameters.to_dict()) except Exception: # when arguments are invalid (currently, only if a LayerPicker has no layer selected), # `value` is None self.set_trait("value", None) return else: args, kwargs = (), {} graft = graft_client.apply_graft("XYZ.use", self.xyz_obj.id, *args, **kwargs) self.set_trait( "value", self.imagery._from_graft(graft), )
def __init__(self, type_): if isinstance(type_, np.dtype): val = type_.char elif type_ in ( int, np.int, np.int_, np.int8, np.int16, np.int32, np.int64, Int, float, np.float, np.float_, np.float32, np.float64, Float, bool, np.bool, np.bool_, Bool, ): val = type_.__name__.lower() else: raise ValueError( "Cannot construct a DType object from {}. Must be a " "NumPy dtype, NumPy type, Python type, or proxy type.".format(type_) ) self.graft = client.apply_graft("wf.dtype.create", val)
def __init__(self, data, mask=False, fill_value=None): if self._type_params is None: raise TypeError( "Cannot instantiate a generic MaskedArray; " "the dtype and dimensionality must be specified (like `MaskedArray[Float, 3]`)" ) if isinstance(data, np.ndarray): if data.dtype.kind != WF_TO_DTYPE_KIND[self._type_params[0]]: raise TypeError("Invalid dtype {} for {}".format( data.dtype, type(self).__name__)) if data.ndim != self.ndim: raise ValueError( "Cannot instantiate a {}-dimensional Workflows MaskedArray from a " "{}-dimensional NumPy data array".format( self.ndim, data.ndim)) data = data.tolist() else: data_list_type = functools.reduce(lambda accum, cur: List[accum], range(self.ndim), self.dtype) try: data = data_list_type._promote(data) except ProxyTypeError: raise ValueError( "Cannot instantiate the data Array from {!r}".format(data)) if isinstance(mask, (bool, np.bool_, Bool)): mask = Bool._promote(mask) elif isinstance(mask, np.ndarray): if mask.dtype.kind != "b": raise TypeError( "Invalid dtype {} for a mask array, should be boolean". format(mask.dtype)) if mask.ndim != self.ndim: raise ValueError( "Cannot instantiate a {}-dimensional Workflows MaskedArray with a " "{}-dimensional NumPy mask array".format( self.ndim, mask.ndim)) mask = mask.tolist() else: # TODO(Clark): Support mask broadcasting to data shape? This could be done # client-side or server-side. mask_list_type = functools.reduce(lambda accum, cur: List[accum], range(self._type_params[1]), Bool) try: mask = mask_list_type._promote(mask) except ProxyTypeError: raise ValueError( "Cannot instantiate the mask Array from {!r}".format(mask)) fill_value = _promote_fill_value(self, fill_value) self.graft = client.apply_graft("maskedarray.create", data, mask, fill_value)
def __init__(self, obj): if isinstance(obj, type(self)): self.graft = obj.graft elif isinstance(obj, (np.int64, np.float64, np.bool, np.bool_)): cast = PY_TYPE[type(obj)](obj) self.graft = client.apply_graft("wf.scalar.create", cast) else: raise ProxyTypeError( "Cannot instantiate a Scalar from {}.".format(obj))
def __init__(self, start=None, stop=None, step=None): if not ((isinstance(start, Int) and start.literal_value is None) or (isinstance(stop, Int) and stop.literal_value is None) or (isinstance(step, Int) and step.literal_value is None)): self._literal_value = slice(start.literal_value, stop.literal_value, step.literal_value) self.graft = client.apply_graft("wf.Slice.create", start=start, stop=stop, step=step)
def __init__(self, data, mask=False, fill_value=None): mask_literal_value = mask.literal_value if (isinstance(mask_literal_value, np.ndarray) and mask_literal_value.dtype.kind != "b"): raise TypeError("Invalid dtype {} for a mask array, " "should be boolean".format( mask_literal_value.dtype)) self.graft = client.apply_graft("maskedarray.create", data, mask, fill_value)
def _from_apply(cls, function, *args, **kwargs): """ Construct a new instance of `cls` from a graft function application. Like ``cls._from_graft(client.apply_graft(function, *args, **kwargs))``, with parameter merging of the inputs. """ return cls._from_graft( client.apply_graft(function, *args, **kwargs), params=merge_params(function, *args, *kwargs.values()), )
def __init__(self, **kwargs): if self._type_params is None: raise TypeError( "Cannot instantiate a generic {}; the item types must be specified " "(like Struct[{}])".format( type(self).__name__, "{'a': Str, 'b': Int}")) promoted = self._promote_kwargs(kwargs, optional=self._optional, read_only=self._read_only) self.graft = client.apply_graft(self._constructor, **promoted) self._items_cache = promoted
def __init__(self, arr): if isinstance(arr, np.generic): arr = arr.tolist() if isinstance(arr, (int, float, bool)): self._literal_value = arr self.graft = client.apply_graft("wf.array.create", arr) elif isinstance(arr, (Int, Float, Bool, List)): self.graft = client.apply_graft("wf.array.create", arr) else: if not isinstance(arr, np.ndarray): try: arr = np.asarray(arr) except Exception: raise ValueError("Cannot construct Array from {!r}".format(arr)) if arr.dtype.kind not in ("b", "i", "f"): raise TypeError("Invalid dtype {} for an Array".format(arr.dtype)) self._literal_value = arr arr_list = arr.tolist() self.graft = client.apply_graft("wf.array.create", arr_list)
def __init__(self, **kwargs): if self._type_params is None: raise TypeError( "Cannot instantiate a generic {}; the item types must be specified " "(like Struct[{}])".format(type(self).__name__, "{'a': Str, 'b': Int}") ) promoted = self._promote_kwargs( kwargs, optional=self._optional, read_only=self._read_only ) self.graft = client.apply_graft(self._constructor, **promoted) self.params = merge_params(self._constructor, *kwargs.values()) # ^ NOTE: this would need to include the keys as well if proxytypes ever become hashable self._items_cache = promoted
def __init__(self, obj): from .string import Str if (isinstance(obj, Number) and not self._is_generic() or isinstance(obj, (Bool, Str))): self.params = obj.params if isinstance(obj, type(self)): self.graft = obj.graft else: self.graft = client.apply_graft( "wf.{}.cast".format(self.__class__.__name__), obj) self.params = obj.params else: if isinstance(obj, np.generic): obj = obj.tolist() super(Number, self).__init__(obj)
def __init__( self, days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0, ): self.graft = client.apply_graft( "timedelta.from_components", days=days, seconds=seconds, microseconds=microseconds, milliseconds=milliseconds, minutes=minutes, hours=hours, weeks=weeks, )
def __init__(self, images): "Construct an ImageCollection from a sequence of Images" self.graft = client.apply_graft("ImageCollection.from_images", images)
def __init__(self, x): self.graft = graft_client.apply_graft("foo", x=x)
def _from_apply(cls, function, *args, **kwargs): "Shorthand for ``cls._from_graft(client.apply_graft(function, *args, **kwargs))``" return cls._from_graft(client.apply_graft(function, *args, **kwargs))
def __init__(self, *dct, **kwargs): if self._type_params is None: raise TypeError( "Cannot instantiate a generic Dict; the key and value types must be specified (like `Dict[Str, Bool]`)" ) if len(dct) > 1: raise TypeError("Dict expected at most 1 arguments, got {}".format( len(dct))) if len(dct) == 0: dct = kwargs kwargs = {} else: dct = dct[0] kt, vt = self._type_params if isinstance(dct, BaseDict): other_kt, other_vt = dct.key_type, dct.value_type if not (issubclass(other_kt, kt) and issubclass(other_vt, vt)): raise ProxyTypeError( "Cannot convert {} to {}, their element types are different" .format(type(dct).__name__, type(self).__name__)) self.graft = dct.graft self.params = dct.params if len(kwargs) > 0: raise NotImplementedError( "Don't have key merging onto a proxy dict yet.") else: if not isinstance(dct, abc.Mapping): raise ProxyTypeError("Expected a mapping, got {}".format(dct)) dct = dct.copy() dct.update(kwargs) # TODO(gabe): numer of copies of source dict could definitely be reduced here is_str_dict = issubclass(kt, Str) promoted = {} if is_str_dict else [] for key, val in six.iteritems(dct): try: promoted_key = kt._promote(key) except ProxyTypeError: raise ProxyTypeError( "Expected Dict keys of type {}, but got {}".format( kt, key)) try: promoted_val = vt._promote(val) except ProxyTypeError: raise ProxyTypeError( "Expected Dict values of type {}, but got {}".format( vt, val)) if is_str_dict: promoted[key] = promoted_val # note we use the unpromoted key, which should be a string # this is an optimization that produces a cleaner graph for the case of string-keyed dicts # FIXME this logic would break on Str proxytype keys, if proxytypes every become hashable else: promoted += [promoted_key, promoted_val] # for non-string dicts, we just give varargs of key, value, key, value, ... # since that's a much simpler graft representation than constructing a list # of tuples if is_str_dict: self.graft = client.apply_graft("wf.dict.create", **promoted) self.params = merge_params(*dct.values()) else: self.graft = client.apply_graft("wf.dict.create", *promoted) self.params = merge_params(*(x for kv in dct.items() for x in kv))
def __init__(self, x): self.graft = graft_client.apply_graft("bar", x=x) self.params = getattr(x, "params", ())
def __init__(self, x): self.graft = client.apply_graft("bar", x=x)