def scan(self, original_line: str, optional_transform: bool = False,
dactyl_smoothing: bool = False) -> Verse:
"""Scan a line of Latin hexameter and produce a scansion pattern, and other data.
>>> scanner = HexameterScanner()
>>> print(scanner.scan("impulerit. Tantaene animis caelestibus irae?"))
Verse(original='impulerit. Tantaene animis caelestibus irae?', scansion='- U U - - - U U - - - U U - - ', meter='hexameter', valid=True, syllable_count=15, accented='īmpulerīt. Tāntaene animīs caelēstibus īrae?', scansion_notes=['Valid by positional stresses.'], syllables = ['īm', 'pu', 'le', 'rīt', 'Tān', 'taen', 'a', 'ni', 'mīs', 'cae', 'lēs', 'ti', 'bus', 'i', 'rae'])
>>> print(scanner.scan(
... "Arma virumque cano, Troiae qui prīmus ab ōrīs").scansion) # doctest: +NORMALIZE_WHITESPACE
- U U - U U - - - - - U U - -
>>> # some hexameters need the optional transformations:
>>> optional_transform_scanner = HexameterScanner(optional_transform=True)
>>> print(optional_transform_scanner.scan(
... "Ītaliam, fāto profugus, Lāvīniaque vēnit").scansion) # doctest: +NORMALIZE_WHITESPACE
- - - - - U U - - - U U - U
>>> print(HexameterScanner().scan(
... "lītora, multum ille et terrīs iactātus et alto").scansion) # doctest: +NORMALIZE_WHITESPACE
- U U - - - - - - - U U - U
>>> print(HexameterScanner().scan(
... "vī superum saevae memorem Iūnōnis ob īram;").scansion) # doctest: +NORMALIZE_WHITESPACE
- U U - - - U U - - - U U - U
>>> # handle multiple elisions
>>> print(scanner.scan("monstrum horrendum, informe, ingens, cui lumen ademptum").scansion) # doctest: +NORMALIZE_WHITESPACE
- - - - - - - - - U U - U
>>> # if we have 17 syllables, create a chain of all dactyls
>>> print(scanner.scan("quadrupedante putrem sonitu quatit ungula campum"
... ).scansion) # doctest: +NORMALIZE_WHITESPACE
- U U - U U - U U - U U - U U - U
>>> # if we have 13 syllables exactly, we'll create a spondaic hexameter
>>> print(HexameterScanner().scan(
... "illi inter sese multa vi bracchia tollunt").scansion) # doctest: +NORMALIZE_WHITESPACE
- - - - - - - - - UU - -
>>> print(HexameterScanner().scan(
... "dat latus; insequitur cumulo praeruptus aquae mons").scansion) # doctest: +NORMALIZE_WHITESPACE
- U U - U U - U U - - - U U - -
>>> print(optional_transform_scanner.scan(
... "Non quivis videt inmodulata poëmata iudex").scansion) # doctest: +NORMALIZE_WHITESPACE
- - - U U - U U - U U- U U - -
>>> print(HexameterScanner().scan(
... "certabant urbem Romam Remoramne vocarent").scansion) # doctest: +NORMALIZE_WHITESPACE
- - - - - - - U U - U U - -
>>> # advanced smoothing is available via keyword flags: dactyl_smoothing
>>> # print(HexameterScanner().scan(
#... "his verbis: 'o gnata, tibi sunt ante ferendae",
#... dactyl_smoothing=True).scansion) # doctest: +NORMALIZE_WHITESPACE
#- - - - - U U - - - U U - -
"""
verse = Verse(original_line, meter='hexameter')
# replace punctuation with spaces
line = original_line.translate(self.punctuation_substitutions)
# conservative i to j
line = self.transform_i_to_j(line)
working_line = self.elide_all(line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
if optional_transform:
working_line = self.transform_i_to_j_optional(line)
working_line = self.elide_all(working_line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
verse.scansion_notes += [self.constants.NOTE_MAP["optional i to j"]]
verse.working_line = working_line
verse.syllable_count = self.syllabifier.get_syllable_count(syllables)
verse.syllables = syllables
if verse.syllable_count < 12:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["< 12"]]
return verse
stresses = self.flag_dipthongs(syllables)
syllables_wspaces = StringUtils.to_syllables_with_trailing_spaces(working_line, syllables)
offset_map = self.calc_offset(syllables_wspaces)
for idx, syl in enumerate(syllables):
for accented in self.constants.ACCENTED_VOWELS:
if accented in syl:
stresses.append(idx)
# first syllable is always long in hexameter
stresses.append(0)
# second to last syllable is always long
stresses.append(verse.syllable_count - 2)
verse.scansion = self.produce_scansion(stresses,
syllables_wspaces, offset_map)
if len(StringUtils.stress_positions(self.constants.STRESSED, verse.scansion)) != \
len(set(stresses)):
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["invalid syllables"]]
return verse
if self.metrical_validator.is_valid_hexameter(verse.scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["positionally"]]
return self.assign_candidate(verse, verse.scansion)
# identify some obvious and probably choices based on number of syllables
if verse.syllable_count == 17: # produce all dactyls
candidate = self.produce_scansion(
self.metrical_validator.hexameter_known_stresses(),
syllables_wspaces, offset_map)
verse.scansion_notes += [self.constants.NOTE_MAP["17"]]
if self.metrical_validator.is_valid_hexameter(candidate):
return self.assign_candidate(verse, candidate)
if verse.syllable_count == 12: # create all spondee hexameter
candidate = self.produce_scansion(list(range(12)), syllables_wspaces, offset_map)
if self.metrical_validator.is_valid_hexameter(verse.scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["12"]]
return self.assign_candidate(verse, candidate)
if verse.syllable_count == 13: # create spondee hexameter with a dactyl at 5th foot
known_unaccents = [9, 10]
last_syllable_accented = False
for vowel in self.constants.ACCENTED_VOWELS:
if vowel in verse.syllables[12]:
last_syllable_accented = True
if not last_syllable_accented:
known_unaccents.append(12)
if set(known_unaccents) - set(stresses) != len(known_unaccents):
verse.scansion = self.produce_scansion([x for x in range(13)
if x not in known_unaccents],
syllables_wspaces, offset_map)
verse.scansion_notes += [self.constants.NOTE_MAP["5th dactyl"]]
if self.metrical_validator.is_valid_hexameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
if verse.syllable_count > 17:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["> 17"]]
return verse
smoothed = self.correct_inverted_amphibrachs(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["inverted"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hexameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_first_two_dactyls(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["invalid start"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hexameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_invalid_fifth_foot(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["invalid 5th"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hexameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
feet = self.metrical_validator.hexameter_feet(verse.scansion.replace(" ", ""))
if feet:
# Normal good citizens are unwelcome in the house of hexameter
invalid_feet_in_hexameter = [self.constants.IAMB, self.constants.TROCHEE]
current_foot = 0
ending = feet.pop() # don't process the ending, a possible trochee, add it back after
scanned_line = ""
for foot in feet:
if foot.replace(" ", "") in invalid_feet_in_hexameter:
scanned_line = self.invalid_foot_to_spondee(feet, foot, current_foot)
scanned_line = scanned_line + ending
current_foot += 1
smoothed = self.produce_scansion(stresses +
StringUtils.stress_positions(
self.constants.STRESSED, scanned_line),
syllables_wspaces, offset_map)
if self.metrical_validator.is_valid_hexameter(smoothed):
verse.scansion_notes += [self.constants.NOTE_MAP["invalid foot"]]
return self.assign_candidate(verse, smoothed)
# need to do this again, since the scansion has changed
smoothed = self.correct_inverted_amphibrachs(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["inverted"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hexameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
candidates = self.metrical_validator.closest_hexameter_patterns(verse.scansion)
if candidates is not None:
if len(candidates) == 1 \
and len(verse.scansion.replace(" ", "")) == len(candidates[0]) \
and len(StringUtils.differences(verse.scansion, candidates[0])) == 1:
tmp_scansion = self.produce_scansion(
StringUtils.differences(verse.scansion, candidates[0]),
syllables_wspaces, offset_map)
if self.metrical_validator.is_valid_hexameter(tmp_scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["closest match"]]
return self.assign_candidate(verse, tmp_scansion)
# need to do this again, since the scansion has changed
smoothed = self.correct_inverted_amphibrachs(smoothed)
if self.metrical_validator.is_valid_hexameter(smoothed):
verse.scansion_notes += [self.constants.NOTE_MAP["inverted"]]
return self.assign_candidate(verse, smoothed)
if dactyl_smoothing:
smoothed = self.correct_dactyl_chain(smoothed)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["dactyl smoothing"]]
verse.scansion = smoothed
if self.metrical_validator.is_valid_hexameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
# if the line doesn't scan "as is", if may scan if the optional i to j transformations
# are made, so here we set them and try again.
if self.optional_transform and not verse.valid:
return self.scan(original_line, optional_transform=True, dactyl_smoothing=True)
return verse
def scan(self,
original_line: str,
optional_transform: bool = False) -> Verse:
"""Scan a line of Latin hendecasyllables and produce a scansion pattern, and other data.
:return: a Verse object
>>> scanner = HendecasyllableScanner()
>>> print(scanner.scan("Cui dono lepidum novum libellum"))
Verse(original='Cui dono lepidum novum libellum', scansion=' - U - U U - U - U - U ', meter='hendecasyllable', valid=True, syllable_count=11, accented='Cui donō lepidūm novūm libēllum', scansion_notes=['Corrected invalid start.'], syllables = ['Cui', 'do', 'no', 'le', 'pi', 'dūm', 'no', 'vūm', 'li', 'bēl', 'lum'])
>>> print(scanner.scan(
... "ārida modo pumice expolitum?").scansion) # doctest: +NORMALIZE_WHITESPACE
- U - U U - U - U - U
"""
verse = Verse(original_line, meter='hendecasyllable')
# replace punctuation with spaces
line = original_line.translate(self.punctuation_substitutions)
# conservative i to j
line = self.transform_i_to_j(line)
working_line = self.elide_all(line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
if optional_transform:
working_line = self.transform_i_to_j_optional(line)
working_line = self.elide_all(working_line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
verse.scansion_notes += [
self.constants.NOTE_MAP["optional i to j"]
]
verse.working_line = working_line
verse.syllable_count = self.syllabifier.get_syllable_count(syllables)
verse.syllables = syllables
# identify some obvious and probably choices based on number of syllables
if verse.syllable_count > 11:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["> 11"]]
return verse
if verse.syllable_count < 11:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["< 11"]]
return verse
stresses = self.flag_dipthongs(syllables)
syllables_wspaces = StringUtils.to_syllables_with_trailing_spaces(
working_line, syllables)
offset_map = self.calc_offset(syllables_wspaces)
for idx, syl in enumerate(syllables):
for accented in self.constants.ACCENTED_VOWELS:
if accented in syl:
stresses.append(idx)
# second to last syllable is always long
stresses.append(verse.syllable_count - 2)
verse.scansion = self.produce_scansion(stresses, syllables_wspaces,
offset_map)
if len(StringUtils.stress_positions(self.constants.STRESSED, verse.scansion)) != \
len(set(stresses)):
verse.valid = False
verse.scansion_notes += [
self.constants.NOTE_MAP["invalid syllables"]
]
return verse
if self.metrical_validator.is_valid_hendecasyllables(verse.scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["positionally"]]
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_invalid_start(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["invalid start"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hendecasyllables(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_antepenult_chain(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [
self.constants.NOTE_MAP["antepenult chain"]
]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hendecasyllables(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
candidates = self.metrical_validator.closest_hendecasyllable_patterns(
verse.scansion)
if candidates is not None:
if len(candidates) == 1 \
and len(verse.scansion.replace(" ", "")) == len(candidates[0]) \
and len(StringUtils.differences(verse.scansion, candidates[0])) == 1:
tmp_scansion = self.produce_scansion(
StringUtils.differences(verse.scansion, candidates[0]),
syllables_wspaces, offset_map)
if self.metrical_validator.is_valid_hendecasyllables(
tmp_scansion):
verse.scansion_notes += [
self.constants.NOTE_MAP["closest match"]
]
return self.assign_candidate(verse, tmp_scansion)
# if the line doesn't scan "as is", if may scan if the optional i to j transformations
# are made, so here we set them and try again.
if self.optional_transform and not verse.valid:
return self.scan(original_line, optional_transform=True)
verse.accented = self.formatter.merge_line_scansion(
verse.original, verse.scansion)
return verse
def scan(self, original_line: str, optional_transform: bool = False) -> Verse:
"""Scan a line of Latin hendecasyllables and produce a scansion pattern, and other data.
:return: a Verse object
>>> scanner = HendecasyllableScanner()
>>> print(scanner.scan("Cui dono lepidum novum libellum"))
Verse(original='Cui dono lepidum novum libellum', scansion=' - U - U U - U - U - U ', meter='hendecasyllable', valid=True, syllable_count=11, accented='Cui donō lepidūm novūm libēllum', scansion_notes=['Corrected invalid start.'], syllables = ['Cui', 'do', 'no', 'le', 'pi', 'dūm', 'no', 'vūm', 'li', 'bēl', 'lum'])
>>> print(scanner.scan(
... "ārida modo pumice expolitum?").scansion) # doctest: +NORMALIZE_WHITESPACE
- U - U U - U - U - U
"""
verse = Verse(original_line, meter='hendecasyllable')
# replace punctuation with spaces
line = original_line.translate(self.punctuation_substitutions)
# conservative i to j
line = self.transform_i_to_j(line)
working_line = self.elide_all(line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
if optional_transform:
working_line = self.transform_i_to_j_optional(line)
working_line = self.elide_all(working_line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
verse.scansion_notes += [self.constants.NOTE_MAP["optional i to j"]]
verse.working_line = working_line
verse.syllable_count = self.syllabifier.get_syllable_count(syllables)
verse.syllables = syllables
# identify some obvious and probably choices based on number of syllables
if verse.syllable_count > 11:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["> 11"]]
return verse
if verse.syllable_count < 11:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["< 11"]]
return verse
stresses = self.flag_dipthongs(syllables)
syllables_wspaces = StringUtils.to_syllables_with_trailing_spaces(working_line, syllables)
offset_map = self.calc_offset(syllables_wspaces)
for idx, syl in enumerate(syllables):
for accented in self.constants.ACCENTED_VOWELS:
if accented in syl:
stresses.append(idx)
# second to last syllable is always long
stresses.append(verse.syllable_count - 2)
verse.scansion = self.produce_scansion(stresses,
syllables_wspaces, offset_map)
if len(StringUtils.stress_positions(self.constants.STRESSED, verse.scansion)) != \
len(set(stresses)):
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["invalid syllables"]]
return verse
if self.metrical_validator.is_valid_hendecasyllables(verse.scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["positionally"]]
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_invalid_start(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["invalid start"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hendecasyllables(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_antepenult_chain(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["antepenult chain"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_hendecasyllables(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
candidates = self.metrical_validator.closest_hendecasyllable_patterns(verse.scansion)
if candidates is not None:
if len(candidates) == 1 \
and len(verse.scansion.replace(" ", "")) == len(candidates[0]) \
and len(StringUtils.differences(verse.scansion, candidates[0])) == 1:
tmp_scansion = self.produce_scansion(
StringUtils.differences(verse.scansion, candidates[0]),
syllables_wspaces, offset_map)
if self.metrical_validator.is_valid_hendecasyllables(tmp_scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["closest match"]]
return self.assign_candidate(verse, tmp_scansion)
# if the line doesn't scan "as is", if may scan if the optional i to j transformations
# are made, so here we set them and try again.
if self.optional_transform and not verse.valid:
return self.scan(original_line, optional_transform=True)
verse.accented = self.formatter.merge_line_scansion(
verse.original, verse.scansion)
return verse
def scan(self,
original_line: str,
optional_transform: bool = False,
dactyl_smoothing: bool = False) -> Hexameter:
"""Scan a line of Latin hexameter and produce a scansion pattern, and other data.
>>> scanner = HexameterScanner()
>>> print(scanner.scan("impulerit. Tantaene animis caelestibus irae?"))
Hexameter( original='impulerit. Tantaene animis caelestibus irae?', scansion='- U U - - - U U - - - U U - - ', valid=True, syllable_count=15, accented='īmpulerīt. Tāntaene animīs caelēstibus īrae?', scansion_notes=['Valid by positional stresses.'], syllables = ['īm, pu, le, rīt, Tān, taen, a, ni, mīs, cae, lēs, ti, bus, i, rae'])
>>> # Note: possible doctest quirk with leading whitespace; so we strip responses:
>>> print(scanner.scan(
... "Arma virumque cano, Troiae qui prīmus ab ōrīs").scansion.strip())
- U U - U U - - - - - U U - -
>>> print(scanner.scan(
... "Ītaliam, fāto profugus, Lāvīniaque vēnit").scansion.strip())
- - - - - U U - - - U U - U
>>> print(HexameterScanner().scan(
... "lītora, multum ille et terrīs iactātus et alto").scansion.strip())
- U U - - - - - - - U U - U
>>> print(HexameterScanner().scan(
... "vī superum saevae memorem Iūnōnis ob īram;").scansion.strip())
- U U - - - U U - - - U U - U
>>> # handle multiple elisions
>>> print(scanner.scan(
... "monstrum horrendum, informe, ingens, cui lumen ademptum"
... ).scansion.strip())
- - - - - - - - - U U - U
>>> # if we have 17 syllables, create a chain of all dactyls
>>> print(scanner.scan("quadrupedante putrem sonitu quatit ungula campum"
... ).scansion.strip())
- U U - U U - U U - U U - U U - U
>>> print(HexameterScanner().scan(
... "illi inter sese multa vi bracchia tollunt").scansion.strip())
- - - - - - - - - UU - -
>>> print( HexameterScanner().scan(
... "dat latus; insequitur cumulo praeruptus aquae mons").scansion.strip())
- U U - U U - U U - - - U U - -
>>> print(HexameterScanner().scan(
... "Non quivis videt inmodulata poëmata iudex").scansion.strip())
- - - U U - U U - U U- U U - -
>>> print( HexameterScanner().scan(
... "certabant urbem Romam Remoramne vocarent").scansion.strip())
- - - - - - - U U - U U - -
>>> # advanced smoothing is available via keyword flags
>>> print(HexameterScanner().scan(
... "his verbis: 'o gnata, tibi sunt ante ferendae",
... dactyl_smoothing=True).scansion.strip() )
- - - - - U U - - - U U - -
"""
hexameter = Hexameter(original_line)
# replace punctuation with spaces
line = original_line.translate(self.punctuation_substitutions)
# conservative i to j
line = self.transform_i_to_j(line)
working_line = self.elide_all(line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
if optional_transform:
working_line = self.transform_i_to_j_optional(line)
working_line = self.elide_all(working_line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
hexameter.scansion_notes += [
self.constants.NOTE_MAP["optional i to j"]
]
hexameter.working_line = working_line
hexameter.syllable_count = len(syllables)
hexameter.syllables = syllables
stresses = self.flag_dipthongs(syllables)
syllables_wspaces = StringUtils.to_syllables_with_trailing_spaces(
working_line, syllables)
offset_map = self.calc_offset(syllables_wspaces)
for idx, syl in enumerate(syllables):
for accented in self.constants.ACCENTED_VOWELS:
if accented in syl:
stresses.append(idx)
# first syllable is always long
stresses.append(0)
# second to last syllable is always long
stresses.append(hexameter.syllable_count - 2)
def validate(scansion: str) -> bool:
"""Helper closure for validation."""
if self.metrical_validator.is_valid_hexameter(scansion):
hexameter.scansion = scansion
hexameter.valid = True
hexameter.accented = self.formatter.merge_line_scansion(
hexameter.original, hexameter.scansion)
return True
return False
hexameter.scansion = self.produce_scansion(stresses, syllables_wspaces,
offset_map)
if len(StringUtils.stress_positions(self.constants.STRESSED, hexameter.scansion)) != \
len(set(stresses)):
hexameter.valid = False
hexameter.scansion_notes += [
self.constants.NOTE_MAP["invalid syllables"]
]
return hexameter
if validate(hexameter.scansion):
hexameter.scansion_notes += [
self.constants.NOTE_MAP["positionally"]
]
return hexameter
smoothed = self.correct_inverted_amphibrachs(hexameter.scansion)
if distance(hexameter.scansion, smoothed) > 0:
hexameter.scansion_notes += [self.constants.NOTE_MAP["inverted"]]
hexameter.scansion = smoothed
stresses += StringUtils.differences(hexameter.scansion, smoothed)
if validate(hexameter.scansion):
return hexameter
smoothed = self.correct_invalid_start(hexameter.scansion)
if distance(hexameter.scansion, smoothed) > 0:
hexameter.scansion_notes += [
self.constants.NOTE_MAP["invalid start"]
]
hexameter.scansion = smoothed
stresses += StringUtils.differences(hexameter.scansion, smoothed)
if validate(hexameter.scansion):
return hexameter
smoothed = self.correct_invalid_fifth_foot(hexameter.scansion)
if distance(hexameter.scansion, smoothed) > 0:
hexameter.scansion_notes += [
self.constants.NOTE_MAP["invalid 5th"]
]
hexameter.scansion = smoothed
stresses += StringUtils.differences(hexameter.scansion, smoothed)
if validate(hexameter.scansion):
return hexameter
feet = self.metrical_validator.hexameter_feet(
hexameter.scansion.replace(" ", ""))
if feet:
# Normal good citizens are unwelcome in the house of hexameter
invalid_feet_in_hexameter = [
self.constants.IAMB, self.constants.TROCHEE
]
current_foot = 0
ending = feet.pop(
) # don't process the ending, a possible trochee, add it back after
scanned_line = ""
for foot in feet:
if foot.replace(" ", "") in invalid_feet_in_hexameter:
scanned_line = self.invalid_foot_to_spondee(
feet, foot, current_foot)
scanned_line = scanned_line + ending
current_foot += 1
smoothed = self.produce_scansion(
stresses + StringUtils.stress_positions(
self.constants.STRESSED, scanned_line), syllables_wspaces,
offset_map)
if validate(smoothed):
hexameter.scansion_notes += [
self.constants.NOTE_MAP["invalid foot"]
]
return hexameter
# need to do this again, since the scansion has changed
smoothed = self.correct_inverted_amphibrachs(hexameter.scansion)
if distance(hexameter.scansion, smoothed) > 0:
hexameter.scansion_notes += [self.constants.NOTE_MAP["inverted"]]
hexameter.scansion = smoothed
stresses += StringUtils.differences(hexameter.scansion, smoothed)
if validate(hexameter.scansion):
return hexameter
candidates = self.metrical_validator.closest_hexameter_patterns(
hexameter.scansion)
if candidates is not None:
if len(candidates) == 1 \
and len(hexameter.scansion.replace(" ", "")) == len(candidates[0]) \
and len(StringUtils.differences(hexameter.scansion, candidates[0])) == 1:
tmp_scansion = self.produce_scansion(
StringUtils.differences(hexameter.scansion, candidates[0]),
syllables_wspaces, offset_map)
if validate(tmp_scansion):
hexameter.scansion = tmp_scansion
hexameter.scansion_notes += [
self.constants.NOTE_MAP["closest match"]
]
return hexameter
# identify some obvious and probably choices based on number of syllables
if hexameter.syllable_count == 17: # produce all dactyls
candidate = self.produce_scansion(
self.metrical_validator.hexameter_known_stresses(),
syllables_wspaces, offset_map)
hexameter.scansion_notes += [self.constants.NOTE_MAP["17"]]
if validate(candidate):
return hexameter
if hexameter.syllable_count == 12: # create all spondee hexameter
if validate(
self.produce_scansion(list(range(12)), syllables_wspaces,
offset_map)):
hexameter.scansion_notes += [self.constants.NOTE_MAP["12"]]
return hexameter
if hexameter.syllable_count < 12:
hexameter.valid = False
hexameter.scansion_notes += [self.constants.NOTE_MAP["< 12"]]
return hexameter
if hexameter.syllable_count == 13: # create spondee hexameter with a dactyl at 5th foot
known_unaccents = [9, 10, 12]
if set(known_unaccents) - set(stresses) != len(known_unaccents):
hexameter.scansion = self.produce_scansion(
[x for x in range(13) if x not in known_unaccents],
syllables_wspaces, offset_map)
hexameter.scansion_notes += [
self.constants.NOTE_MAP["5th dactyl"]
]
if validate(hexameter.scansion):
return hexameter
if hexameter.syllable_count > 17:
hexameter.valid = False
hexameter.scansion_notes += [self.constants.NOTE_MAP["> 17"]]
return hexameter
# need to do this again, since the scansion has changed
smoothed = self.correct_inverted_amphibrachs(smoothed)
if validate(smoothed):
hexameter.scansion = smoothed
hexameter.scansion_notes += [self.constants.NOTE_MAP["inverted"]]
return hexameter
if dactyl_smoothing:
smoothed = self.correct_dactyl_chain(smoothed)
if distance(hexameter.scansion, smoothed) > 0:
hexameter.scansion_notes += [
self.constants.NOTE_MAP["dactyl smoothing"]
]
hexameter.scansion = smoothed
if validate(hexameter.scansion):
return hexameter
# if the line doesn't scan "as is", if may scan if the optional i to j transformations
# are made, so here we set them and try again.
if not optional_transform and not hexameter.valid:
return self.scan(original_line,
optional_transform=True,
dactyl_smoothing=True)
return hexameter
def scan(self, original_line: str, optional_transform: bool = False) -> Verse:
"""Scan a line of Latin pentameter and produce a scansion pattern, and other data.
>>> scanner = PentameterScanner()
>>> print(scanner.scan('ex hoc ingrato gaudia amore tibi.'))
Verse(original='ex hoc ingrato gaudia amore tibi.', scansion='- - - - - - U U - U U U ', meter='pentameter', valid=True, syllable_count=12, accented='ēx hōc īngrātō gaudia amōre tibi.', scansion_notes=['Spondaic pentameter'], syllables = ['ēx', 'hoc', 'īn', 'gra', 'to', 'gau', 'di', 'a', 'mo', 're', 'ti', 'bi'])
>>> print(scanner.scan(
... "in vento et rapida scribere oportet aqua.").scansion) # doctest: +NORMALIZE_WHITESPACE
- - - U U - - U U - U U U
"""
verse = Verse(original_line, meter='pentameter')
# replace punctuation with spaces
line = original_line.translate(self.punctuation_substitutions)
# conservative i to j
line = self.transform_i_to_j(line)
working_line = self.elide_all(line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
if optional_transform:
working_line = self.transform_i_to_j_optional(line)
working_line = self.elide_all(working_line)
working_line = self.accent_by_position(working_line)
syllables = self.syllabifier.syllabify(working_line)
verse.scansion_notes += [self.constants.NOTE_MAP["optional i to j"]]
verse.working_line = working_line
verse.syllable_count = self.syllabifier.get_syllable_count(syllables)
verse.syllables = syllables
if verse.syllable_count < 12:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["< 12p"]]
return verse
stresses = self.flag_dipthongs(syllables)
syllables_wspaces = StringUtils.to_syllables_with_trailing_spaces(working_line, syllables)
offset_map = self.calc_offset(syllables_wspaces)
for idx, syl in enumerate(syllables):
for accented in self.constants.ACCENTED_VOWELS:
if accented in syl:
stresses.append(idx)
# first syllable is always long in Pentameter
stresses.append(0)
# second to last syllable is always long
stresses.append(verse.syllable_count - 2)
verse.scansion = self.produce_scansion(stresses,
syllables_wspaces, offset_map)
if len(StringUtils.stress_positions(self.constants.STRESSED, verse.scansion)) != \
len(set(stresses)):
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["invalid syllables"]]
return verse
if self.metrical_validator.is_valid_pentameter(verse.scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["positionally"]]
return self.assign_candidate(verse, verse.scansion)
# identify some obvious and probably choices based on number of syllables
if verse.syllable_count == 12: # produce spondees where possible
candidate = self.make_spondaic(verse.scansion)
verse.scansion_notes += [self.constants.NOTE_MAP["12p"]]
return self.assign_candidate(verse, candidate)
if verse.syllable_count == 14: # produce spondees where possible
candidate = self.make_dactyls(verse.scansion)
verse.scansion_notes += [self.constants.NOTE_MAP["14p"]]
return self.assign_candidate(verse, candidate)
if verse.syllable_count > 14:
verse.valid = False
verse.scansion_notes += [self.constants.NOTE_MAP["> 14"]]
return verse
smoothed = self.correct_first_two_dactyls(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["invalid start"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_pentameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
smoothed = self.correct_penultimate_dactyl_chain(verse.scansion)
if distance(verse.scansion, smoothed) > 0:
verse.scansion_notes += [self.constants.NOTE_MAP["penultimate dactyl chain"]]
verse.scansion = smoothed
stresses += StringUtils.differences(verse.scansion, smoothed)
if self.metrical_validator.is_valid_pentameter(verse.scansion):
return self.assign_candidate(verse, verse.scansion)
candidates = self.metrical_validator.closest_pentameter_patterns(verse.scansion)
if candidates is not None:
if len(candidates) == 1 \
and len(verse.scansion.replace(" ", "")) == len(candidates[0]) \
and len(StringUtils.differences(verse.scansion, candidates[0])) == 1:
tmp_scansion = self.produce_scansion(
StringUtils.differences(verse.scansion, candidates[0]),
syllables_wspaces, offset_map)
if self.metrical_validator.is_valid_pentameter(tmp_scansion):
verse.scansion_notes += [self.constants.NOTE_MAP["closest match"]]
return self.assign_candidate(verse, tmp_scansion)
# if the line doesn't scan "as is", it may scan if the optional i to j transformations
# are made, so here we set them and try again.
if self.optional_transform and not verse.valid:
return self.scan(original_line, optional_transform=True)
verse.accented = self.formatter.merge_line_scansion(verse.original, verse.scansion)
return verse