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
