def __init__(self, schema: Schema, list_id: VariableId, argument_id: VariableId, identifier_id: Optional[VariableId]): self.subjects_path: ListType[str] = schema.get(list_id).absolute_path self.arg_path: ListType[str] = schema.get(argument_id).relative_path self.identifier_path: Optional[ListType[str]] = None if identifier_id is not None: self.identifier_path = schema.get(identifier_id).relative_path
def test_get_conflict_raises(track_type): t_spec: Dict = { "A": { "name": "temporal variable", "data_type": "Text", "sort_order": 0 } } t_track = Track.build(t_spec, None, "temporal") i_spec = copy.deepcopy(t_spec) i_track = Track.build(i_spec, None, "immutable") schema = Schema(t_track, i_track) with pytest.raises(ValueError): schema.get("A", track_type=track_type)
def build(cls, path_locator, schema: Schema, name: str, subjects: Dict): logging.info('Building instance of filter class "%s"' % name) filters = load(cls) variables = { var_name: schema.get(var_id) for var_name, var_id in subjects.items() } return filters[name](schema=schema, **variables)
def value_iterator( schema: Schema, subjects: Any, argument_id: Optional[VariableId], identifier_id: Optional[VariableId], identifier_target_id: Optional[VariableId]) -> ValueIterator: if isinstance(subjects, (list, dict)): if argument_id is not None: raise ValueError( "'argument' parameter specified for an ad-hoc grouping of variables. This parameter is " "only for cross-sectional analysis across List and KeyedList containers." ) if identifier_id is not None: raise ValueError( "'identifier' parameter specified for an ad-hoc grouping of variables. This parameter is " "only for cross-sectional analysis across List containers.") return AdHocIterator(schema, subjects) subjects_var_id: VariableId = cast(VariableId, subjects) subjects_var: Variable = schema.get(subjects_var_id) if isinstance( subjects_var, List ) and identifier_id is not None and identifier_target_id is None: raise ValueError("Identifier specified without a target.") if isinstance( subjects_var, List ) and identifier_id is None and identifier_target_id is not None: raise ValueError("Identifier target specified without an identifier.") if isinstance(subjects_var, KeyedList) and identifier_id is not None: raise ValueError( "Explicit identifier specified for a KeyedList, which have built-in identifiers." ) # Sometimes I hate MyPy not_optional_arg_id: VariableId = cast(VariableId, argument_id) if isinstance(subjects_var, List): return ListIterator(schema, subjects_var_id, not_optional_arg_id, identifier_id) if isinstance(subjects_var, KeyedList): return KeyedListIterator(schema, subjects_var_id, not_optional_arg_id) raise ValueError( 'The "subject" parameter must either be a list of primitive variables or the id of a List or ' 'KeyedList.')
def build( cls, path_locator: PathLocator, schema: Schema, name: str, target_schema: str, id_var: str, input_schema_vars: Dict, output_schema_vars: Dict ): target_schema_instance: Schema = Schema.load(path_locator, target_schema) aggregations: Dict[str, Type] = load(cls) input_variables: Dict[str, Variable] = { var_name: schema.get(var_id) for var_name, var_id in input_schema_vars.items() } output_variables: Dict[str, Variable] = { var_name: target_schema_instance.get(var_id) for var_name, var_id in output_schema_vars.items() } return aggregations[name](origin_schema=schema, target_schema=target_schema_instance, id_var=id_var, **input_variables, **output_variables)
def __init__(self, schema: Schema, subjects: Union[ListType, Dict]): self.subjects: Dict[str, ListType[str]] = {} data_type: Optional[str] = None for subject_id, identifier in _ad_hoc_subjects(subjects): subject: Variable = schema.get(subject_id) if not isinstance(subject, Primitive): raise ValueError( 'Non-primitive variable "%s" supplied as ad-hoc cross-sectional subject.' % subject_id) subject_data_type: str = subject.data_type if data_type is None: data_type = subject_data_type if subject_data_type != data_type: raise ValueError( 'Attempting to compare different data types (%s and %s)' % (data_type, subject_data_type)) if identifier in self.subjects: raise ValueError( 'Identifier "%s" supplied twice in ad-hoc cross sectional subjects.' % identifier) self.subjects[identifier] = subject.absolute_path
def test_lookup_initial(schema: Schema, abs_path: ListType[str], var_id: str): """Verifying that lookup works as expected off the bat.""" expected: Variable = schema.get(var_id) assert expected is not None actual: Variable = schema.lookup(abs_path) assert actual is expected
def __init__(self, schema: Schema, keyed_list_id: VariableId, argument_id: VariableId): self.subjects_path: ListType[str] = schema.get( keyed_list_id).absolute_path self.arg_path: ListType[str] = schema.get(argument_id).relative_path