def _validate_type(self, proposal):
value = proposal["value"]
if value == "custom":
if not len(self._partials):
raise TraitError("Cannot set 'custom' type, use the ``partials`` attribute instead")
return value
else:
base_type, partial_count = parse_osc_type(value, types=self._valid_types)
return base_type + partial_count
def validate(self, obj, value):
if value is None and not self.allow_none:
self.error(obj, value)
try:
value = pd.DataFrame(value)
for validator in self.validators:
value = validator(self, value)
return value
except (ValueError, TypeError) as e:
raise TraitError(e)
def validate(self, obj, value):
if isinstance(value, str):
value = os.path.abspath(value)
if self.exists is not None:
if os.path.exists(value) != self.exists:
raise TraitError('Path "{}" {} exist'.format(
value, 'does not' if self.exists else 'must'))
if os.path.exists(value):
if os.path.isdir(value) and not self.directory_ok:
raise TraitError(
'Path "{}" must not be a directory'.format(value))
if os.path.isfile(value) and not self.file_ok:
raise TraitError(
'Path "{}" must not be a file'.format(value))
return value
return self.error(obj, value)
def validate(self, obj, value):
if value is None and not self.allow_none:
self.error(obj, value)
try:
value = np.asarray(value, dtype=self.dtype)
for validator in self.validators:
value = validator(self, value)
return value
except (ValueError, TypeError) as e:
raise TraitError(e)
def _valid_value_temp_files_server(self, proposal):
try:
if proposal["value"] != self.temp_files_server:
if self.temp_files_server == "disabled":
raise ValueError(
"feature is 'disabled', due to missing 'flask' module")
except (AttributeError, ValueError) as e:
message = f"The 'temp_files_server' trait of a {Constants.MAGIC_CLASS_NAME} instance {str(e)}"
raise TraitError(message)
return proposal["value"]
def _valid_value_auto_dataframe(self, proposal: Dict[str, Any]):
try:
if proposal["value"] is True and not Dependencies.is_installed(
"pandas"):
raise ValueError(
"cannot be set to True, 'pandas' package is not installed")
except (AttributeError, ValueError) as e:
message = f"The 'auto_dataframe' trait of a {Constants.MAGIC_CLASS_NAME} instance {str(e)}"
raise TraitError(message)
return proposal["value"]
def validate(self, obj, value):
if value is None and not self.allow_none:
self.error(obj, value)
if value is None or value is Undefined:
return super(XarrayType, self).validate(obj, value)
try:
value = self.klass(value)
except (ValueError, TypeError) as e:
raise TraitError(e)
return super(XarrayType, self).validate(obj, value)
def _validate_assignment_id(self, proposal):
if '+' in proposal['value']:
raise TraitError(
'Assignment names should not contain the following characters: +'
)
if proposal['value'].strip() != proposal['value']:
self.log.warning(
"assignment_id '%s' has trailing whitespace, stripping it away",
proposal['value'])
return proposal['value'].strip()
def _validate_colors(self, proposal):
if type(proposal['value']) is dict or type(self.positions) is dict:
return proposal['value']
required = self.positions.size // 3 # (x, y, z) triplet per 1 color
actual = proposal['value'].size
if actual != 0 and required != actual:
raise TraitError('colors has wrong size: %s (%s required)' %
(actual, required))
return proposal['value']
def validate(self, obj, value):
# cast to proper unicode
value = super(FilenameExtension, self).validate(obj, value)
# check that it starts with a dot
if value and not value.startswith('.'):
msg = "FileExtension trait '{}' does not begin with a dot: {!r}"
raise TraitError(msg.format(self.name, value))
return value
def _notebook_dir_validate(self, value, trait):
# Strip any trailing slashes
value = value.rstrip(os.sep)
if not os.path.isabs(value):
# If we receive a non-absolute path, make it absolute.
value = os.path.abspath(value)
if not os.path.isdir(value):
raise TraitError("No such notebook dir: %r" % value)
return value
def validate(self, obj, value):
if isinstance(value, bytes):
value = os.fsdecode(value)
if value is None:
if self.allow_none:
return None
else:
self.error(obj, value)
if not isinstance(value, (str, pathlib.Path)):
return self.error(obj, value)
if isinstance(value, str):
if value == "":
return self.error(obj, value)
try:
url = urlparse(value)
except ValueError:
return self.error(obj, value)
if url.scheme not in ("", "file"):
return self.error(obj, value)
value = pathlib.Path(url.netloc, url.path)
value = value.absolute()
exists = value.exists()
if self.exists is not None:
if exists != self.exists:
raise TraitError(
'Path "{}" {} exist'.format(
value, "does not" if self.exists else "must not"
)
)
if exists:
if not self.directory_ok and value.is_dir():
raise TraitError(f'Path "{value}" must not be a directory')
if not self.file_ok and value.is_file():
raise TraitError(f'Path "{value}" must not be a file')
return value
def validate(self, obj, value):
# Support a single value for all (check and convert into a default value)
if not isinstance(value, (list, List, UserList, TelescopePatternList)):
value = [("type", "*", self._trait.validate(obj, value))]
# Check each value of list
normalized_value = TelescopePatternList()
for pattern in value:
# now check for the standard 3-tuple of (command, argument, value)
if len(pattern) != 3:
raise TraitError(
"pattern should be a tuple of (command, argument, value)"
)
command, arg, val = pattern
val = self._trait.validate(obj, val)
if not isinstance(command, str):
raise TraitError("command must be a string")
if command not in ["type", "id"]:
raise TraitError("command must be one of: 'type', 'id'")
if command == "type":
if not isinstance(arg, str):
raise TraitError("'type' argument should be a string")
if command == "id":
try:
arg = int(arg)
except ValueError:
raise TraitError(f"Argument of 'id' should be an int (got '{arg}')")
val = self._trait.validate(obj, val)
normalized_value.append((command, arg, val))
normalized_value._lookup = TelescopeParameterLookup(normalized_value)
if isinstance(value, TelescopePatternList) and value._subarray is not None:
normalized_value.attach_subarray(value._subarray)
return normalized_value
def _states_change(self, change):
if change['new'] < 1:
raise TraitError('State value cannot smaller than 1')
else:
if len(self.selected_colors) < change["new"]:
additional_colors = ["#a6cee3", "#b2df8a", "#fdbf6f", "#6a3d9a", "#b15928", "#e31a1c", "#1f78b4", "#33a02c", "#ff7f00", "#cab2d6", "#ffff99"]
self.selected_colors = self.selected_colors + additional_colors * (1 + (change["new"] - len(self.selected_colors)) // len(additional_colors))
self.selected_colors = self.selected_colors[:change["new"]]
elif len(self.selected_colors) > change["new"]:
self.selected_colors = self.selected_colors[:change["new"]]
def _db_changed(self, change):
"""validate the db, since it can be an Instance of two different types"""
new = change['new']
connection_types = (DummyDB, )
if sqlite3 is not None:
connection_types = (DummyDB, sqlite3.Connection)
if not isinstance(new, connection_types):
msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \
(self.__class__.__name__, new)
raise TraitError(msg)
def validate(self, obj, value):
if isinstance(value, (int, float)):
return int(value)
try:
num = float(value[:-1])
except ValueError:
raise TraitError(
"{val} is not a valid memory specification. Must be an int or "
"a string with suffix K, M, G, T".format(val=value)
)
suffix = value[-1]
if suffix not in self.UNIT_SUFFIXES:
raise TraitError(
"{val} is not a valid memory specification. Must be an int or "
"a string with suffix K, M, G, T".format(val=value)
)
return int(float(num) * self.UNIT_SUFFIXES[suffix])
def validate(self, obj, value):
if isinstance(value, str):
try:
value = self._resolve_string(value)
except ImportError as exc:
raise TraitError(
"Failed to import %r for trait '%s.%s':\n\n%s"
% (value, type(obj).__name__, self.name, exc)
)
return super().validate(obj, value)
def _valid_function_parameters(self, function_parameters):
"""
Validate that the function parameters do not contain newlines
These might allow string injection, and would be difficult to indent
properly.
"""
if '\n' in function_parameters['value']:
raise TraitError("The function parameters cannot contain newlines")
return function_parameters['value']
def _validate_backend(self, proposed):
if proposed['value'] not in (
'custom',
'dummy',
'git',
'sqla',
):
raise TraitError('backend not recognized: {}'.format(
proposed['value']))
return proposed['value']
def validate(self, obj, value):
value = super(DataUnion, self).validate(obj, value)
if isinstance(value, NDArrayWidget) and self.dtype is not None:
if value.array.dtype != self.dtype:
raise TraitError(
'dtypes must match exactly when passing a NDArrayWidget to '
'a dtype constrained DataUnion')
if self.shape_constraint:
self.shape_constraint(self, get_union_array(value))
return value
def _valid_spec(self, proposal):
spec = proposal['value']
spec_parts = len(spec.split(SPEC_DIVIDER))
if spec_parts == 3:
return spec
elif spec_parts == 2:
return spec + '/master'
else:
raise TraitError(
'spec must contain two or three components but only got '
'{} (original spec: {})'.format(spec_parts, spec))
def validate(self, obj, value):
if not isinstance(value, ureg.Quantity):
self.error(obj, value)
if (self.dimensionality is not None
and self.dimensionality != value.dimensionality):
raise TraitError(
"The dimensionality of the '%s' trait of %s instance should "
"be %s, but a value with dimensionality %s was "
"specified" % (self.name, class_of(obj), self.dimensionality,
value.dimensionality))
if ((self.max is not None and (value.to(self.max.units) > self.max)) or
(self.min is not None and (value.to(self.min.units) < self.min))):
raise TraitError(
"The value of the '%s' trait of %s instance should "
"be between %s and %s, but a value of %s was "
"specified" %
(self.name, class_of(obj), self.min, self.max, value))
return value
def validate(self, owner, stl):
stl = super(BinaryStlData, self).validate(owner, stl)
if len(stl) < self.HEADER + self.COUNT_SIZE:
raise TraitError(
'Given bytestring is too short ({}) for Binary STL data.'.
format(len(stl)))
(num_facets, ) = struct.unpack(
'<I', stl[self.HEADER:self.HEADER + self.COUNT_SIZE])
expected_size = self.HEADER + self.COUNT_SIZE + num_facets * self.FACET_SIZE
if len(stl) != expected_size:
raise TraitError(
'Given bytestring has wrong length ({}) for Binary STL data. '
'For {} facets {} bytes were expected.'.format(
len(stl), num_facets, expected_size))
return stl
def validate(self, obj, value):
value = super(WebGLDataUnion, self).validate(obj, value)
array = value.array if isinstance(value, NDArrayWidget) else value
if array is not Undefined and str(array.dtype) == 'float64':
if isinstance(value, NDArrayWidget):
raise TraitError('Cannot use a float64 data widget as a BufferAttribute source.')
else:
# 64-bit not supported, coerce to 32-bit
value = value.astype('float32')
return value
def validate(self, obj, value):
"""
Validate that the passed in value is a valid memory specification
It could either be a pure int, when it is taken as a byte value.
If it has one of the suffixes, it is converted into the appropriate
pure byte value.
"""
if isinstance(value, (int, float)):
return int(value)
try:
num = float(value[:-1])
except ValueError:
raise TraitError('{val} is not a valid memory specification. Must be an int or a string with suffix K, M, G, T'.format(val=value))
suffix = value[-1]
if suffix not in self.UNIT_SUFFIXES:
raise TraitError('{val} is not a valid memory specification. Must be an int or a string with suffix K, M, G, T'.format(val=value))
else:
return int(float(num) * self.UNIT_SUFFIXES[suffix])
def _scales_validate(self, scales, scales_trait):
"""validates the dictionary of scales based on the mark's scaled
attributes metadata. First checks for missing scale and then for
'rtype' compatibility."""
# Validate scales' 'rtype' versus data attribute 'rtype' decoration
# At this stage it is already validated that all values in self.scales
# are instances of Scale.
for name in self.trait_names(scaled=True):
trait = self.traits()[name]
if name not in scales:
# Check for missing scale
if not trait.allow_none:
raise TraitError("Missing scale for data attribute %s." %
name)
else:
# Check scale range type compatibility
if scales[name].rtype != trait.get_metadata('rtype'):
raise TraitError("Range type mismatch for scale %s." %
name)
return scales
def validate_dtype(value, dtype):
try:
r = np.asarray(value, dtype=dtype)
if isinstance(value, np.ndarray) and r is not value:
warnings.warn(
'Given trait value dtype "%s" does not match required type "%s". '
'A coerced copy has been created.' %
(np.dtype(value.dtype).name, np.dtype(dtype).name))
return r
except (ValueError, TypeError) as e:
raise TraitError(e)
def _notebook_dir_changed(self, name, old, new):
"""Do a bit of validation of the notebook dir."""
if not os.path.isabs(new):
# If we receive a non-absolute path, make it absolute.
self.notebook_dir = os.path.abspath(new)
return
if not os.path.isdir(new):
raise TraitError("No such notebook dir: %r" % new)
# setting App.notebook_dir implies setting notebook and kernel dirs as well
self.config.FileContentsManager.root_dir = new
self.config.MappingKernelManager.root_dir = new
def resolve_subclass(baseclass, subclass):
if isinstance(subclass, basestring):
subclasses = _all_subclasses(baseclass)
subclass_matches = [
sc for sc in subclasses
if ("%s.%s" % (sc.__module__, sc.__name__)) == subclass
or sc.__name__ == subclass
]
if len(subclass_matches) == 1:
return subclass_matches[0]
elif len(subclass_matches) > 1:
raise TraitError("Ambiguous subclass name: %s subclasses: %s" %
(subclass, subclass_matches))
else:
raise TraitError("No matching subclass name: %s" % subclass)
else:
if not issubclass(subclass, baseclass):
raise TraitError("Specific class not subclass: %s base: %s" %
(subclass, baseclass))
return subclass
def _validate_post_save_hook(self, proposal):
value = proposal["value"]
if isinstance(value, str):
value = import_item(value)
if not callable(value):
raise TraitError("post_save_hook must be callable")
if callable(self.post_save_hook):
warnings.warn(
f"Overriding existing post_save_hook ({self.post_save_hook.__name__}) with a new one ({value.__name__}).",
stacklevel=2,
)
return value
