def _validate_terms(cls, v, values, **kwargs):
"""Normalize ``terms`` to initialize Statement."""
# make TermSequence for validation, then ignore it
TermSequence.validate_terms(v)
if len(v) != len(values["predicate"]):
message = (
"The number of items in 'terms' must be " +
f"{len(values['predicate'])}, not {len(v)}, " +
f"to match predicate.context_slots for '{values['predicate']}'"
)
raise ValueError(message)
return v
def test_load_factor_marked_reciprocal(self):
fact = Fact(
predicate=Comparison(
content="the distance between $place1 and $place2 was",
sign="<",
expression="5 miles",
),
terms=TermSequence(
[Entity(name="the apartment"),
Entity(name="the office")]),
)
assert hasattr(fact.predicate.quantity, "dimensionality")
data = {
"type":
"fact",
"content":
"the distance between ${place1} and ${place2} was",
"sign":
"<",
"expression":
"5 miles",
"terms": [
{
"type": "entity",
"name": "the office"
},
{
"type": "entity",
"name": "the apartment"
},
],
}
loaded_fact = Fact(**data)
assert loaded_fact.means(fact)
def new_context(self, changes: Dict[Comparable, Comparable]) -> Comparable:
"""
Create new :class:`Factor`, replacing keys of ``changes`` with values.
:returns:
a version of ``self`` with the new context.
"""
result = deepcopy(self)
new_terms = TermSequence([
factor.new_context(changes) for factor in self.terms_without_nulls
])
result.terms = list(new_terms)
return result
def terms(self) -> TermSequence:
r"""
Get :class:`Factor`\s used in comparisons with other :class:`Factor`\s.
:returns:
a tuple of attributes that are designated as the ``terms``
for whichever subclass of :class:`Factor` calls this method. These
can be used for comparing objects using :meth:`consistent_with`
"""
result: List[Term] = []
result.extend(self.outputs)
result.extend(self.inputs)
result.extend(self.despite)
return TermSequence(result)
def test_cannot_put_string_in_term_sequence(self):
entity = Entity(name="Austin")
with pytest.raises(TypeError):
TermSequence([entity, "Dallas as a string"])
def test_term_sequence_from_one_term(self):
entity = Entity(name="Austin")
sequence = TermSequence(entity)
assert sequence[0].name == entity.name
def term_sequence(self) -> TermSequence:
"""Return a TermSequence of the terms in this Statement."""
return TermSequence(self.terms)
def term_permutations(self) -> Iterator[TermSequence]:
"""Generate permutations of context factors that preserve same meaning."""
for pattern in self.predicate.term_index_permutations():
sorted_terms = [x for _, x in sorted(zip(pattern, self.terms))]
yield TermSequence(sorted_terms)
def get_term_sequence_from_mapping(
self, term_mapping: Mapping[str, Term]) -> TermSequence:
"""Get an ordered list of terms from a mapping of placeholder names to terms."""
placeholders = self.placeholders
result = [term_mapping[placeholder] for placeholder in placeholders]
return TermSequence(result)