def __init__(self, vocabulary, attribute_system, mapping, dummy=False): """ Construct a VariableAssignment object. :param vocabulary: The Vocabulary object :math:`\Sigma` the \ VariableAssignment is defined over. :type vocabulary: Vocabulary :param attribute_system: The AttributeSystem object \ :math:`\mathcal{S}` from which the objects \ :math:`\{s_{1}, \ldots, s_{n}\}` in the VariableAssignment come from. :type attribute_system: AttributeSystem :param mapping: The mapping :math:`\chi` from the variables V of \ the Vocabulary object :math:`\Sigma` in the ``vocabulary`` parameter \ to the objects :math:`\{s_{1}, \ldots, s_{n}\}` of the \ AttributeSystem object :math:`\mathcal{A}` in the \ ``attribute_system`` parameter. :type mapping: ``dict`` :param dummy: A flag for creating a dummy (i.e., empty) \ VariableAssignment object :math:`\chi_{dummy}`. :type dummy: ``bool`` :raises TypeError: ``vocabulary`` parameter must be a Vocabulary \ object, ``attribute_system`` parameter must be an AttributeSystem \ object and ``mapping`` parameter must be a ``dict`` with ``str`` keys \ and values. :raises ValueError: All keys in the ``mapping`` parameter must be in \ the Vocabulary object in the ``vocabulary`` parameter's ``V`` member \ and all values in the ``mapping`` parameter must be unique and match \ some object in the ``object`` member of the AttributeSystem object in \ the ``attribute_system`` parameter. """ if not isinstance(mapping, dict): raise TypeError("mapping parameter must be of type dict") if not all([isinstance(s, str) for s in mapping.keys()]): raise TypeError("mapping must be of form str: str") if not all([isinstance(s, str) for s in mapping.values()]): raise TypeError("mapping must be of form str: str") if dummy: Assignment.__init__(self, vocabulary, attribute_system) self._mapping = {} self._is_VariableAssignment = True else: source = mapping.keys() target = mapping.values() if len(source) != len(set(source)) or len(target) != len( set(target)): raise ValueError("duplicate values in mapping parameter " "are not allowed; mapping must be 1-to-1.") # total mapping so check for equality source_condition = set(source) <= set(vocabulary._V) target_condition = set(target) <= set(attribute_system._objects) if source_condition and target_condition: Assignment.__init__(self, vocabulary, attribute_system) self._mapping = mapping self._source = mapping.keys() self._target = mapping.values() self._is_VariableAssignment = True else: raise ValueError("VariableAssignment must be a function from " "vocabulary._V to attribute_system._objects")
def __init__(self, vocabulary, attribute_system, mapping): """ Construct a ConstantAssignment object. :param vocabulary: The Vocabulary object :math:`\Sigma` the \ ConstantAssignment is defined over. :type vocabulary: Vocabulary :param attribute_system: The AttributeSystem object \ :math:`\mathcal{S}` from which the objects \ :math:`\{s_{1}, \ldots, s_{n}\}` in the ConstantAssignment come from. :type attribute_system: AttributeSystem :param mapping: The mapping :math:`\\rho` from the constants C of \ the Vocabulary object :math:`\Sigma` in the ``vocabulary`` parameter \ to the objects :math:`\{s_{1}, \ldots, s_{n}\}` of the \ AttributeSystem object :math:`\mathcal{A}` in the \ ``attribute_system`` parameter. :type mapping: ``dict`` :raises TypeError: ``vocabulary`` parameter must be a Vocabulary \ object, ``attribute_system`` parameter must be an AttributeSystem \ object and ``mapping`` parameter must be a ``dict`` with ``str`` keys \ and values. :raises ValueError: All keys in the ``mapping`` parameter must be in \ the Vocabulary object in the ``vocabulary`` parameter's ``C`` member \ and all values in the ``mapping`` parameter must be unique and match \ some object in the ``object`` member of the AttributeSystem object in \ the ``attribute_system`` parameter. """ if not isinstance(mapping, dict): raise TypeError( "mapping parameter must be of type dict") if not all([isinstance(s, str) for s in mapping.keys()]): raise TypeError("mapping must be of form str: str") if not all([isinstance(s, str) for s in mapping.values()]): raise TypeError("mapping must be of form str: str") source = mapping.keys() target = mapping.values() if len(target) != len(set(target)): raise ValueError( "duplicate values in mapping parameter " "are not allowed; mapping must be 1-to-1.") # note: Vocabularies prevent duplicates as do dictionary keys source_condition = set(source) <= set(vocabulary._C) # note: AttributeSystems prevent duplicate objects target_condition = set(target) <= set(attribute_system._objects) if source_condition and target_condition: Assignment.__init__(self, vocabulary, attribute_system) self._mapping = mapping self._source = mapping.keys() self._target = mapping.values() self._is_ConstantAssignment = True else: raise ValueError( "ConstantAssignment must be a partial (or total) function " "from Vocabulary's C to AttributeSystem's objects")
def __init__(self, vocabulary, attribute_system, mapping, dummy=False): """ Construct a VariableAssignment object. :param vocabulary: The Vocabulary object :math:`\Sigma` the \ VariableAssignment is defined over. :type vocabulary: Vocabulary :param attribute_system: The AttributeSystem object \ :math:`\mathcal{S}` from which the objects \ :math:`\{s_{1}, \ldots, s_{n}\}` in the VariableAssignment come from. :type attribute_system: AttributeSystem :param mapping: The mapping :math:`\chi` from the variables V of \ the Vocabulary object :math:`\Sigma` in the ``vocabulary`` parameter \ to the objects :math:`\{s_{1}, \ldots, s_{n}\}` of the \ AttributeSystem object :math:`\mathcal{A}` in the \ ``attribute_system`` parameter. :type mapping: ``dict`` :param dummy: A flag for creating a dummy (i.e., empty) \ VariableAssignment object :math:`\chi_{dummy}`. :type dummy: ``bool`` :raises TypeError: ``vocabulary`` parameter must be a Vocabulary \ object, ``attribute_system`` parameter must be an AttributeSystem \ object and ``mapping`` parameter must be a ``dict`` with ``str`` keys \ and values. :raises ValueError: All keys in the ``mapping`` parameter must be in \ the Vocabulary object in the ``vocabulary`` parameter's ``V`` member \ and all values in the ``mapping`` parameter must be unique and match \ some object in the ``object`` member of the AttributeSystem object in \ the ``attribute_system`` parameter. """ if not isinstance(mapping, dict): raise TypeError( "mapping parameter must be of type dict") if not all([isinstance(s, str) for s in mapping.keys()]): raise TypeError("mapping must be of form str: str") if not all([isinstance(s, str) for s in mapping.values()]): raise TypeError("mapping must be of form str: str") if dummy: Assignment.__init__(self, vocabulary, attribute_system) self._mapping = {} self._is_VariableAssignment = True else: source = mapping.keys() target = mapping.values() if len(source) != len(set(source)) or len(target) != len(set(target)): raise ValueError( "duplicate values in mapping parameter " "are not allowed; mapping must be 1-to-1.") # total mapping so check for equality source_condition = set(source) <= set(vocabulary._V) target_condition = set(target) <= set(attribute_system._objects) if source_condition and target_condition: Assignment.__init__(self, vocabulary, attribute_system) self._mapping = mapping self._source = mapping.keys() self._target = mapping.values() self._is_VariableAssignment = True else: raise ValueError( "VariableAssignment must be a function from " "vocabulary._V to attribute_system._objects")