skrutable 2.6.2__tar.gz → 2.7.0__tar.gz

{skrutable-2.6.2 → skrutable-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skrutable
-Version: 2.6.2
+Version: 2.7.0
 Summary: skrutable library for working with Sanskrit text
 Home-page: https://github.com/tylergneill/skrutable
 Author: Tyler Neill

skrutable-2.7.0/src/skrutable/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.7.0"

{skrutable-2.6.2 → skrutable-2.7.0}/src/skrutable/config.json

@@ -15,10 +15,14 @@
 	"anuṣṭubh, full, both halves imperfect)": 5,
 	"anuṣṭubh, full, one half perfect, one length error)": 6,
 	"anuṣṭubh, full, one half imperfect, one length error)": 4,
-	"anuṣṭubh, half, single half perfect)" : 9,
-	"anuṣṭubh, half, single half imperfect)": 5,
+	"anuṣṭubh, 1 or 3 halves, all halves perfect)" : 9,
+	"anuṣṭubh, 1 or 3 halves, one imperfect)": 7,
+	"anuṣṭubh, 1 or 3 halves, two imperfect)": 6,
+	"anuṣṭubh, 1 or 3 halves, some perfect some length error)": 6,
+	"anuṣṭubh, 1 or 3 halves, at least one half imperfect)": 5,
+	"anuṣṭubh, 1 or 3 halves, some imperfect some length error)": 4,
 	"samavṛtta, perfect" : 9,
-	"samavṛtta, imperfect (3)" : 6,
+	"samavṛtta, imperfect (3)" : 7,
 	"samavṛtta, imperfect (2)" : 5,
 	"samavṛtta, quarter, perfect" : 8,
 	"ardhasamavṛtta, perfect" : 9,

{skrutable-2.6.2 → skrutable-2.7.0}/src/skrutable/meter_identification.py

@@ -66,9 +66,9 @@ def flush_profiling_report(write_file=False, wall_clock_secs=None, parallel_work
 		return
 	import sys, os
 	scan_keys = ('scan_clean', 'scan_translit', 'scan_syllabify', 'scan_weights', 'scan_morae_gana')
-	type_keys = ('anuzwuB', 'samavftta_etc', 'samavftta', 'upajAti', 'ardhasamavftta_perfect', 'vizamavftta', 'jAti', 'lev_samavftta', 'lev_ardha', 'lev_vizama')
+	type_keys = ('anuzwuB', 'ardhatraya', 'samavftta_etc', 'samavftta', 'upajAti', 'ardhasamavftta_perfect', 'vizamavftta', 'jAti', 'lev_samavftta', 'lev_ardha', 'lev_vizama')
 	type_abbrev = {
-		'anuzwuB': 'anuṣṭ', 'samavftta_etc': 'vftta↑', 'samavftta': 'samav', 'upajAti': 'upajāti',
+		'anuzwuB': 'anuṣṭ', 'ardhatraya': 'anuṣṭ3', 'samavftta_etc': 'vftta↑', 'samavftta': 'samav', 'upajAti': 'upajāti',
 		'ardhasamavftta_perfect': 'ardha✓', 'vizamavftta': 'vizama',
 		'jAti': 'jāti',
 		'lev_samavftta': 'lev✗sama', 'lev_ardha': 'lev✗ardh', 'lev_vizama': 'lev✗visa',
@@ -91,7 +91,8 @@ def flush_profiling_report(write_file=False, wall_clock_secs=None, parallel_work
 
 	n_verses = sum(b.get('_count', 0) for b in _category_totals.values())
 	wiggle_count = _section_totals.get('wiggle_count', 0)
-	lines = [f'\n=== {n_verses} verses / {wiggle_count} resplit candidates ===']
+	ardhatraya_gate_count = _section_totals.get('ardhatraya_gate_count', 0)
+	lines = [f'\n=== {n_verses} verses / {wiggle_count} resplit candidates / {ardhatraya_gate_count} ardhatraya gate hits ===']
 	hdr = ('  ' + 'category'.ljust(col_cat_w)
 		+ 'perf'.rjust(count_w) + 'impf'.rjust(count_w)
 		+ 'total'.rjust(sub_w) + 'scan∑'.rjust(sub_w) + 'types∑'.rjust(sub_w)
@@ -153,6 +154,8 @@ class Diagnostic:
 	imperfect_label_sanskrit: Optional[dict] = None # keyed by pada (1–4 or 'odd'/'even'); Sanskrit only
 	imperfect_label_english: Optional[dict] = None  # keyed by pada (1–4 or 'odd'/'even'); English only
 	problem_syllables: Optional[dict] = None        # keyed by pada (1–4 or 'odd'/'even'); None if perfect
+	notable_syllables: Optional[dict] = None        # keyed by pada (1–4 or 'odd'/'even'); green-highlighted "interesting/ok" syllables
+	notable_label: Optional[dict] = None            # keyed by pada (1–4 or 'odd'/'even'); label for the notable feature (same string for skt/eng)
 
 	def perfect(self):
 		return self.perfect_id_label is not None
@@ -473,17 +476,28 @@ class VerseTester(object):
 				result = None
 				for weights_pattern, label in meter_patterns.anuzwuB_pAda['odd'].items():
 					if re.match(weights_pattern, odd_pAda_weights):
-						result = Diagnostic(perfect_id_label=label)
+						is_vipula = 'vipulā' in label
+						result = Diagnostic(
+							perfect_id_label=label,
+							notable_syllables={'odd': [4, 5, 6]} if is_vipula else None,
+							notable_label={'odd': label} if is_vipula else None,
+						)
 						break
 				if result is None:
 					# Odd pāda matched no perfect pattern — try asamīcīna patterns
 					# before falling back to the generic ya-gaṇa violation label.
 					for weights_pattern, (label, problem_syls, code) in meter_patterns.anuzwuB_pAda_asamIcIna['odd'].items():
 						if re.match(weights_pattern, odd_pAda_weights):
+							is_vipula = 'vipulā' in label
+							# extract vipulā name from label like "asamīcīnā, ma-vipulāyāḥ pūrvam raḥ syāt"
+							vipula_match = re.search(r'\w+-vipulā', label)
+							vipula_name = vipula_match.group(0) if vipula_match else None
 							result = Diagnostic(
 								imperfect_label_sanskrit={'odd': label},
 								imperfect_label_english={'odd': code},
 								problem_syllables={'odd': problem_syls},
+								notable_syllables={'odd': [4, 5, 6]} if is_vipula else None,
+								notable_label={'odd': vipula_name} if vipula_name else None,
 							)
 							break
 				if result is None:
@@ -523,14 +537,14 @@ class VerseTester(object):
 				return None
 			if ardham_eva_result.perfect():
 				Vrs.meter_label = f"anuṣṭubh (ardham eva: {ardham_eva_result.perfect_id_label})"
-				Vrs.identification_score = meter_scores["anuṣṭubh, half, single half perfect)"]
+				Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, all halves perfect)"]
 				Vrs.is_perfect = True
 				Vrs.diagnostic = ardham_eva_result
 				return ardham_eva_result
 			elif ardham_eva_result.imperfect():
-				label_str = '; '.join(f"{k}: {v}" for k, v in ardham_eva_result.imperfect_label_sanskrit.items())
+				label_str = '; '.join(ardham_eva_result.imperfect_label_sanskrit.values())
 				Vrs.meter_label = f"anuṣṭubh (ardham eva: {label_str})"
-				Vrs.identification_score = meter_scores["anuṣṭubh, half, single half imperfect)"]
+				Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, at least one half imperfect)"]
 				Vrs.is_perfect = False
 				Vrs.diagnostic = ardham_eva_result
 				return ardham_eva_result
@@ -553,14 +567,14 @@ class VerseTester(object):
 		# one half imperfect
 
 		elif pAdas_ab_result.imperfect() and pAdas_cd_result.perfect():
-			ab_str = '; '.join(f"{k}: {v}" for k, v in pAdas_ab_result.imperfect_label_sanskrit.items())
+			ab_str = '; '.join(pAdas_ab_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: {ab_str}; 3,4: {pAdas_cd_result.perfect_id_label})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, one half perfect, one imperfect)"]
 			Vrs.is_perfect = False
 			Vrs.diagnostic = {'ab': pAdas_ab_result, 'cd': pAdas_cd_result}
 			return pAdas_ab_result
 		elif pAdas_ab_result.perfect() and pAdas_cd_result.imperfect():
-			cd_str = '; '.join(f"{k}: {v}" for k, v in pAdas_cd_result.imperfect_label_sanskrit.items())
+			cd_str = '; '.join(pAdas_cd_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: {pAdas_ab_result.perfect_id_label}; 3,4: {cd_str})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, one half perfect, one imperfect)"]
 			Vrs.is_perfect = False
@@ -570,8 +584,8 @@ class VerseTester(object):
 		# both halves imperfect
 
 		elif pAdas_ab_result.imperfect() and pAdas_cd_result.imperfect():
-			ab_str = '; '.join(f"{k}: {v}" for k, v in pAdas_ab_result.imperfect_label_sanskrit.items())
-			cd_str = '; '.join(f"{k}: {v}" for k, v in pAdas_cd_result.imperfect_label_sanskrit.items())
+			ab_str = '; '.join(pAdas_ab_result.imperfect_label_sanskrit.values())
+			cd_str = '; '.join(pAdas_cd_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: {ab_str}; 3,4: {cd_str})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, both halves imperfect)"]
 			Vrs.is_perfect = False
@@ -581,14 +595,14 @@ class VerseTester(object):
 		# one half perfect, one length error
 
 		elif pAdas_ab_result.length_error() and pAdas_cd_result.perfect():
-			ab_str = '; '.join(f"{k}: {v}" for k, v in pAdas_ab_result.imperfect_label_sanskrit.items())
+			ab_str = '; '.join(pAdas_ab_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: ?? {ab_str}; 3,4: {pAdas_cd_result.perfect_id_label})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, one half perfect, one length error)"]
 			Vrs.is_perfect = False
 			Vrs.diagnostic = {'ab': pAdas_ab_result, 'cd': pAdas_cd_result}
 			return pAdas_cd_result
 		elif pAdas_ab_result.perfect() and pAdas_cd_result.length_error():
-			cd_str = '; '.join(f"{k}: {v}" for k, v in pAdas_cd_result.imperfect_label_sanskrit.items())
+			cd_str = '; '.join(pAdas_cd_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: {pAdas_ab_result.perfect_id_label}; 3,4: ?? {cd_str})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, one half perfect, one length error)"]
 			Vrs.is_perfect = False
@@ -598,16 +612,16 @@ class VerseTester(object):
 		# one half imperfect, one length error
 
 		elif pAdas_ab_result.length_error() and pAdas_cd_result.imperfect():
-			ab_str = '; '.join(f"{k}: {v}" for k, v in pAdas_ab_result.imperfect_label_sanskrit.items())
-			cd_str = '; '.join(f"{k}: {v}" for k, v in pAdas_cd_result.imperfect_label_sanskrit.items())
+			ab_str = '; '.join(pAdas_ab_result.imperfect_label_sanskrit.values())
+			cd_str = '; '.join(pAdas_cd_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: ?? {ab_str}; 3,4: {cd_str})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, one half imperfect, one length error)"]
 			Vrs.is_perfect = False
 			Vrs.diagnostic = {'ab': pAdas_ab_result, 'cd': pAdas_cd_result}
 			return pAdas_cd_result
 		elif pAdas_ab_result.imperfect() and pAdas_cd_result.length_error():
-			ab_str = '; '.join(f"{k}: {v}" for k, v in pAdas_ab_result.imperfect_label_sanskrit.items())
-			cd_str = '; '.join(f"{k}: {v}" for k, v in pAdas_cd_result.imperfect_label_sanskrit.items())
+			ab_str = '; '.join(pAdas_ab_result.imperfect_label_sanskrit.values())
+			cd_str = '; '.join(pAdas_cd_result.imperfect_label_sanskrit.values())
 			Vrs.meter_label = f"anuṣṭubh (1,2: {ab_str}; 3,4: ?? {cd_str})"
 			Vrs.identification_score = meter_scores["anuṣṭubh, full, one half imperfect, one length error)"]
 			Vrs.is_perfect = False
@@ -678,12 +692,10 @@ class VerseTester(object):
 		imperfect_note = None
 
 		if self.pAdasamatva_count == 3:
-			imperfect_note = "? 3 eva pādāḥ yuktāḥ"
-			meter_label += " (%s)" % imperfect_note
+			imperfect_note = True
 			score = meter_scores["samavṛtta, imperfect (3)"]
 		elif self.pAdasamatva_count == 2:
-			imperfect_note = "? 2 eva pādāḥ yuktāḥ"
-			meter_label += " (%s)" % imperfect_note
+			imperfect_note = True
 			score = meter_scores["samavṛtta, imperfect (2)"]
 		elif self.pAdasamatva_count == 0:
 			imperfect_note = "1 eva pādaḥ"
@@ -746,12 +758,10 @@ class VerseTester(object):
 				problem_syllables=problem_syllables or None,
 			)
 		else:
-			# fewer than 4 matching pādas; append any length notes to the meter_label
-			length_notes = [f"pāda {p} {v}" for p, v in per_pada_sanskrit.items() if v in ('adhikākṣarā', 'ūnākṣarā')]
-			full_imperfect_str = imperfect_note
+			# fewer than 4 matching pādas; append per-pāda notes to the meter_label
+			length_notes = [f"pāda {p} {v}" for p, v in per_pada_sanskrit.items()]
 			if length_notes:
-				full_imperfect_str += "; " + "; ".join(length_notes)
-				meter_label = meter_label.replace(f"({imperfect_note})", f"({full_imperfect_str})")
+				meter_label += " (%s)" % "; ".join(length_notes)
 			diagnostic = Diagnostic(
 				imperfect_label_sanskrit=per_pada_sanskrit or None,
 				imperfect_label_english=per_pada_english or None,
@@ -760,7 +770,7 @@ class VerseTester(object):
 
 		# score arbitration: may tie with pre-existing result (e.g., upajāti)
 		old_score = Vrs.identification_score
-		self.combine_results(Vrs, new_label=meter_label, new_score=score, new_is_perfect=imperfect_note is None and not has_any_error)
+		self.combine_results(Vrs, new_label=meter_label, new_score=score, new_is_perfect=not imperfect_note and not has_any_error)
 		if score >= old_score:
 			Vrs.diagnostic = diagnostic
 
@@ -945,14 +955,13 @@ class VerseTester(object):
 
 			meter_labels.append(meter_label)
 
-		unique_meter_labels = list(set(meter_labels)) # de-dupe
+		unique_meter_labels = sorted(set(meter_labels)) # de-dupe, stable order
 		combined_meter_labels = ', '.join(unique_meter_labels)
 
 		# Assign score based on how complete and homogeneous the match is.
 		family = meter_patterns.samavftta_family_names[wbp_lens[0]] if wbp_lens[0] < 27 else 'daṇḍaka'
-		unique_meter_labels_copy = unique_meter_labels; unique_meter_labels_copy.sort()
 		if (family == "triṣṭubh" and
-			unique_meter_labels_copy == ['indravajrā [11: ttjgg]', 'upendravajrā [11: jtjgg]']
+			unique_meter_labels == ['indravajrā [11: ttjgg]', 'upendravajrā [11: jtjgg]']
 			):
 			family = '' # clearer not to specify in this case
 
@@ -976,19 +985,12 @@ class VerseTester(object):
 		if all(lbl.startswith('ajñātam') for lbl in meter_labels):
 			score -= 1
 
-		imperfect_note = None
+		imperfect_note = len(wbp_lens) != 4 and unique_sorted_lens != [11, 12]
 		overall_meter_label = "upajāti %s: %s" % (
 			family,
 			combined_meter_labels
 			)
 
-		if 	(
-				len(wbp_lens) != 4 and
-				unique_sorted_lens != [11, 12]
-			): # not perfect and also not triṣṭubh-jagatī-saṃkara
-			imperfect_note = "? %d eva pādāḥ yuktāḥ" % len(wbp_lens)
-			overall_meter_label += " (%s)" % imperfect_note
-
 		# Build diagnostic: excluded pādas are flagged as hyper/hypometric relative
 		# to the majority length; included pādas contribute no error entry.
 		most_freq_len = wbp_lens[0] if wbp_lens else None
@@ -1005,11 +1007,14 @@ class VerseTester(object):
 					per_pada_sanskrit[pada_num] = 'adhikākṣarā' if hyper else 'ūnākṣarā'
 					per_pada_english[pada_num] = 'hypermetric' if hyper else 'hypometric'
 
-		if imperfect_note is None and not per_pada_english:
-			# all four pādas included and none flagged
+		# Append per-pāda imperfect notes to label.
+		length_notes = [f"pāda {p} {v}" for p, v in per_pada_sanskrit.items()]
+		if length_notes:
+			overall_meter_label += " (%s)" % "; ".join(length_notes)
+
+		if not per_pada_english and not imperfect_note:
 			diagnostic = Diagnostic(perfect_id_label=overall_meter_label)
-		elif imperfect_note is None:
-			# all four pādas included but some have length errors
+		elif not imperfect_note:
 			diagnostic = Diagnostic(
 				perfect_id_label=overall_meter_label,
 				imperfect_label_sanskrit=per_pada_sanskrit or None,
@@ -1017,11 +1022,6 @@ class VerseTester(object):
 				problem_syllables=problem_syllables or None,
 			)
 		else:
-			# fewer than 4 pādas included; append length notes to the meter_label
-			length_notes = [f"pāda {p} {v}" for p, v in per_pada_sanskrit.items()]
-			if length_notes:
-				full_imperfect_str = imperfect_note + "; " + "; ".join(length_notes)
-				overall_meter_label = overall_meter_label.replace(f"({imperfect_note})", f"({full_imperfect_str})")
 			diagnostic = Diagnostic(
 				imperfect_label_sanskrit=per_pada_sanskrit or None,
 				imperfect_label_english=per_pada_english or None,
@@ -1030,7 +1030,8 @@ class VerseTester(object):
 
 		# score arbitration: may tie with pre-existing result (e.g., samavṛtta)
 		old_score = Vrs.identification_score
-		self.combine_results(Vrs, overall_meter_label, score, new_is_perfect=imperfect_note is None and not per_pada_english)
+		is_perfect = not imperfect_note and not per_pada_english
+		self.combine_results(Vrs, overall_meter_label, score, new_is_perfect=is_perfect)
 		if score >= old_score:
 			Vrs.diagnostic = diagnostic
 
@@ -1573,6 +1574,63 @@ class VerseTester(object):
 		else:
 			return 0
 
+	def attempt_ardhatraya_identification(self, Vrs):
+		"""
+		Identification for 6-pāda input (3 ardhas = 1.5 anuṣṭubh verses).
+		Tests each ardha (pāda pair) independently with test_as_anuzwuB_half,
+		then assembles a combined label and score from all three results.
+		Returns 1 if identified, 0 otherwise.
+		"""
+
+		w_p = Vrs.syllable_weights.split('\n')
+		if len(w_p) < 6:
+			return 0
+
+		r1 = self.test_as_anuzwuB_half(w_p[0], w_p[1])
+		r2 = self.test_as_anuzwuB_half(w_p[2], w_p[3])
+		r3 = self.test_as_anuzwuB_half(w_p[4], w_p[5])
+
+		if r1 is None or r2 is None or r3 is None:
+			return 0
+
+		def _ardha_label(r):
+			if r.perfect():
+				return r.perfect_id_label
+			else:
+				return '; '.join(r.imperfect_label_sanskrit.values())
+
+		l1, l2, l3 = _ardha_label(r1), _ardha_label(r2), _ardha_label(r3)
+		Vrs.meter_label = f"anuṣṭubh (1,2: {l1}; 3,4: {l2}; 5,6: {l3})"
+
+		results = [r1, r2, r3]
+		n_perfect = sum(1 for r in results if r.perfect())
+		n_length_error = sum(1 for r in results if r.length_error())
+		n_imperfect = 3 - n_perfect - n_length_error
+
+		if n_length_error == 0 and n_imperfect == 0:
+			Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, all halves perfect)"]
+			Vrs.is_perfect = True
+		elif n_length_error == 0:
+			if n_imperfect == 3:
+				Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, at least one half imperfect)"]
+			elif n_imperfect == 2:
+				Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, two imperfect)"]
+			else:
+				Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, one imperfect)"]
+			Vrs.is_perfect = False
+		elif n_perfect > 0 and n_imperfect == 0:
+			Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, some perfect some length error)"]
+			Vrs.is_perfect = False
+		elif n_imperfect > 0 and n_perfect == 0:
+			Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, some imperfect some length error)"]
+			Vrs.is_perfect = False
+		else:
+			Vrs.identification_score = meter_scores["anuṣṭubh, 1 or 3 halves, some perfect some length error)"]
+			Vrs.is_perfect = False
+
+		Vrs.diagnostic = {'ab': r1, 'cd': r2, 'ef': r3}
+		return 1
+
 
 class MeterIdentifier(object):
 	"""
@@ -1598,6 +1656,8 @@ class MeterIdentifier(object):
 		"""
 
 		iter_list = [start_pos]
+		if resplit_option == 'none':
+			return iter_list
 		if resplit_option == 'resplit_max':
 			distance_multiplier = 0.50 # wiggle as far as 50% of part_len
 		elif resplit_option == 'resplit_lite':
@@ -1683,6 +1743,141 @@ class MeterIdentifier(object):
 		return Verses_found
 
 
+	def resplit_Verse_ardhatraya(self, syllable_list, ab_br, bc_br, cd_br, de_br, ef_br):
+		syllable_list = list(syllable_list)
+		_fix_conjunct_pada_boundaries(syllable_list, [ab_br, cd_br, ef_br])
+		sss = scansion_syllable_separator
+		return (sss.join(syllable_list[:ab_br]) + '\n'
+				+ sss.join(syllable_list[ab_br:bc_br]) + '\n'
+				+ sss.join(syllable_list[bc_br:cd_br]) + '\n'
+				+ sss.join(syllable_list[cd_br:de_br]) + '\n'
+				+ sss.join(syllable_list[de_br:ef_br]) + '\n'
+				+ sss.join(syllable_list[ef_br:])
+				)
+
+	def constrained_resplit_identify(self, Vrs, syllable_list, VrsTster,
+									n_pAdas, pada_len, resplit_option,
+									resplit_func, attempt_func,
+									keep_mid_breaks=None, user_seeds=None):
+		"""
+		Constrained resplit enumerator for known-structure meters.
+
+		Rather than wiggling break positions freely, generates only splits where
+		every pāda length falls within [pada_len - tol, pada_len + tol], where
+		tol = 1 for resplit_lite/none, 2 for resplit_max.
+
+		n_pAdas: number of pādas expected (e.g. 6 for ardhatraya, 4 for samavṛtta)
+		pada_len: canonical pāda length in syllables
+		resplit_func: callable(syllable_list, *break_positions) → text_syllabified
+		attempt_func: callable(Vrs) → 0 or 1
+		keep_mid_breaks: set of 0-indexed break indices to lock to seed position
+		                 (e.g. {1, 3} for ardhatraya bc/de when resplit_keep_midpoint)
+		user_seeds: list of break positions derived from user-provided punctuation/newlines;
+		            overrides canonical pada_len-based seeds where provided
+
+		Returns a list for MeterIdentifier.Verses_found.
+		"""
+		tol = 1 if resplit_option in ('none', 'resplit_lite') else 2
+		keep_mid_breaks = keep_mid_breaks or set()
+		n_breaks = n_pAdas - 1
+		total = len(syllable_list)
+
+		# Seed each break: prefer user-provided positions, fall back to canonical.
+		canonical_seeds = [pada_len * (i + 1) for i in range(n_breaks)]
+		seeds = list(user_seeds) if user_seeds else canonical_seeds
+
+		# For each break, build the list of candidate positions:
+		# either locked to seed (keep_midpoint) or all positions in [seed-tol, seed+tol].
+		def candidates(break_idx):
+			seed = seeds[break_idx]
+			if break_idx in keep_mid_breaks:
+				return [seed]
+			return list(range(seed - tol, seed + tol + 1))
+
+		S = Sc()
+		Verses_found = []
+
+		def _recurse(break_idx, chosen):
+			if break_idx == n_breaks:
+				try:
+					new_text_syllabified = resplit_func(syllable_list, *chosen)
+					temp_V = copy(Vrs)
+					temp_V.text_syllabified = new_text_syllabified
+					if _DEBUG_TIMING:
+						_section_totals['wiggle_count'] = _section_totals.get('wiggle_count', 0) + 1
+					temp_V.syllable_weights = timed('scan_weights')(S.scan_syllable_weights)(
+						temp_V.text_syllabified)
+					temp_V.morae_per_line = timed('scan_morae_gana')(S.count_morae)(
+						temp_V.syllable_weights)
+					temp_V.gaRa_abbreviations = timed('scan_morae_gana')(
+						lambda: '\n'.join([S.gaRa_abbreviate(line) for line in temp_V.syllable_weights.split('\n')])
+					)()
+					success = attempt_func(temp_V)
+					if success:
+						Verses_found.append(temp_V)
+					if temp_V.identification_score == meter_scores["max score"]:
+						return True  # signal early exit
+				except IndexError:
+					pass
+				return False
+
+			prev = chosen[-1] if chosen else 0
+			for pos in candidates(break_idx):
+				seg_len = pos - prev
+				if not (pada_len - tol <= seg_len <= pada_len + tol):
+					continue
+				# check remaining syllables can form valid pādas
+				remaining = total - pos
+				remaining_breaks = n_breaks - break_idx - 1
+				remaining_pAdas = n_pAdas - break_idx - 1
+				min_remaining = remaining_pAdas * (pada_len - tol)
+				max_remaining = remaining_pAdas * (pada_len + tol)
+				if not (min_remaining <= remaining <= max_remaining):
+					continue
+				if _recurse(break_idx + 1, chosen + [pos]):
+					return True  # propagate early exit
+			return False
+
+		_recurse(0, [])
+		return Verses_found
+
+	def wiggle_identify_ardhatraya(self, Vrs, syllable_list, VrsTster,
+									newline_indices, text_syllabified):
+		"""Constrained resplit for 6-pāda (3-ardha) anuṣṭubh."""
+		resplit_option = VrsTster.resplit_option
+		pada_len = 8
+		n_breaks = 5
+
+		# Derive user seeds from punctuation/newlines when available,
+		# mirroring the seeding logic in wiggle_identify.
+		user_seeds = None
+		if len(newline_indices) == n_breaks:
+			if resplit_option in ('none', 'resplit_lite'):
+				# all breaks provided — seed all five from user positions
+				user_seeds = [
+					text_syllabified[:newline_indices[i]].count(scansion_syllable_separator)
+					for i in range(n_breaks)
+				]
+			elif resplit_option == 'resplit_max' and VrsTster.resplit_keep_midpoint:
+				# seed bc (idx 1) and de (idx 3) from user positions, wiggle the rest
+				canonical = [pada_len * (i + 1) for i in range(n_breaks)]
+				canonical[1] = text_syllabified[:newline_indices[1]].count(scansion_syllable_separator)
+				canonical[3] = text_syllabified[:newline_indices[3]].count(scansion_syllable_separator)
+				user_seeds = canonical
+
+		keep_mid = {1, 3} if VrsTster.resplit_keep_midpoint else set()
+
+		return self.constrained_resplit_identify(
+			Vrs, syllable_list, VrsTster,
+			n_pAdas=6, pada_len=pada_len,
+			resplit_option=resplit_option,
+			resplit_func=self.resplit_Verse_ardhatraya,
+			attempt_func=VrsTster.attempt_ardhatraya_identification,
+			keep_mid_breaks=keep_mid,
+			user_seeds=user_seeds,
+		)
+
+
 	def find_meter(self, rw_str, from_scheme=None):
 
 		self.Scanner = S = Sc()
@@ -1742,7 +1937,7 @@ class MeterIdentifier(object):
 
 		if _DEBUG_TIMING:
 			_pre_keys = ('scan_clean', 'scan_translit', 'scan_syllabify', 'scan_weights', 'scan_morae_gana',
-				'anuzwuB', 'samavftta', 'upajAti', 'vizamavftta',
+				'anuzwuB', 'ardhatraya', 'samavftta', 'upajAti', 'vizamavftta',
 				'ardhasamavftta_perfect', 'jAti', 'lev_samavftta', 'lev_ardha', 'lev_vizama', 'samavftta_etc')
 			_pre = {k: _section_totals.get(k, 0.0) for k in _pre_keys}
 
@@ -1753,7 +1948,7 @@ class MeterIdentifier(object):
 		self.VerseTester.resplit_option = resplit_option
 		self.VerseTester.resplit_keep_midpoint = resplit_keep_midpoint
 
-		if resplit_option in ['none', 'single_pAda'] or V.text_cleaned == '':
+		if resplit_option == 'single_pAda' or V.text_cleaned == '':
 			# No resplitting: test the verse exactly as scanned.
 			VT._ardha_stash = []
 			VT._vizama_stash = []
@@ -1765,7 +1960,7 @@ class MeterIdentifier(object):
 			if VT._vizama_stash and meter_scores["viṣamavṛtta, imperfect"] > V.identification_score:
 				timed('lev_vizama')(VT.is_vizamavftta)(V)
 
-		elif resplit_option in ['resplit_max', 'resplit_lite']:
+		elif resplit_option in ['none', 'resplit_max', 'resplit_lite']:
 
 			# Capture any user-provided pāda breaks (newlines surviving scansion cleaning).
 			newline_indices = [
@@ -1791,14 +1986,14 @@ class MeterIdentifier(object):
 				)
 
 			if len(newline_indices) == 3:
-				if resplit_option == 'resplit_lite':
+				if resplit_option in ('none', 'resplit_lite'):
 					# all three breaks provided — override all three
 					pAda_brs['ab'], pAda_brs['bc'], pAda_brs['cd'] = (
 						V.text_syllabified[:newline_indices[i]].count(
 							scansion_syllable_separator
 							) for i in [0, 1, 2]
 						)
-				elif	(
+				elif (
 							resplit_option == 'resplit_max' and
 							self.VerseTester.resplit_keep_midpoint
 						):
@@ -1807,15 +2002,15 @@ class MeterIdentifier(object):
 						scansion_syllable_separator)
 
 			elif len(newline_indices) == 1:
-				if 	(
-						resplit_option == 'resplit_lite'
+				if (
+						resplit_option in ('none', 'resplit_lite')
 					) or (
 						resplit_option == 'resplit_max' and
 						self.VerseTester.resplit_keep_midpoint
 					):
 					# single break provided — treat as bc, wiggle the rest
 					pAda_brs['bc'] = V.text_syllabified[:newline_indices[0]].count(
-					scansion_syllable_separator)
+						scansion_syllable_separator)
 
 			else:
 				# unusable number of user-provided pāda breaks — use length-based seeds
@@ -1827,6 +2022,21 @@ class MeterIdentifier(object):
 				pAda_brs, quarter_len
 				)
 
+			# --- ardhatraya pass (6-pāda / 3-ardha anuṣṭubh) ---
+			best_4pAda_score = (
+				max(v.identification_score for v in self.Verses_found)
+				if self.Verses_found else 0
+			)
+			_ardhatraya_gate = best_4pAda_score < meter_scores["max score"] and 44 <= total_syll_count <= 52
+			if _DEBUG_TIMING:
+				_section_totals['ardhatraya_gate_count'] = _section_totals.get('ardhatraya_gate_count', 0) + (1 if _ardhatraya_gate else 0)
+			if _ardhatraya_gate:
+				ardhatraya_found = timed('ardhatraya')(self.wiggle_identify_ardhatraya)(
+					V, syllable_list, VT,
+					newline_indices, V.text_syllabified
+				)
+				self.Verses_found.extend(ardhatraya_found)
+
 			# Post-wiggle: deferred imperfect ardhasamavṛtta pass over accumulated stash.
 			_lev_ardha_t0 = _time.perf_counter() if _DEBUG_TIMING else None
 			ardha_stash = VT._ardha_stash
@@ -1972,7 +2182,7 @@ class MeterIdentifier(object):
 
 		if _DEBUG_TIMING:
 			all_keys = ('scan_clean', 'scan_translit', 'scan_syllabify', 'scan_weights', 'scan_morae_gana',
-				'anuzwuB', 'samavftta', 'upajAti', 'vizamavftta',
+				'anuzwuB', 'ardhatraya', 'samavftta', 'upajAti', 'vizamavftta',
 				'ardhasamavftta_perfect', 'jAti', 'lev_samavftta', 'lev_ardha', 'lev_vizama', 'samavftta_etc')
 			verse_times = {k: _section_totals.get(k, 0.0) - _pre[k] for k in all_keys}
 			verse_times['scan'] = sum(verse_times[k] for k in ('scan_clean', 'scan_translit', 'scan_syllabify', 'scan_weights', 'scan_morae_gana'))
@@ -2032,7 +2242,7 @@ def _identify_meter_worker(args):
 		_mi._DEBUG_TIMING = True
 	MI = MeterIdentifier()
 	all_keys = ('scan_clean', 'scan_translit', 'scan_syllabify', 'scan_weights', 'scan_morae_gana',
-		'anuzwuB', 'samavftta', 'upajAti', 'vizamavftta',
+		'anuzwuB', 'ardhatraya', 'samavftta', 'upajAti', 'vizamavftta',
 		'ardhasamavftta_perfect', 'jAti', 'lev_samavftta', 'lev_ardha', 'lev_vizama', 'samavftta_etc')
 	if debug_timing:
 		pre = {k: _section_totals.get(k, 0.0) for k in all_keys}

{skrutable-2.6.2 → skrutable-2.7.0}/src/skrutable/meter_patterns.py

@@ -238,7 +238,7 @@ samavfttas_by_family_and_gaRa = {
 	'jtj(r|B)' : 'vaṃśastha',
 	'mmy(y|j)' : 'vaiśvadevī',
 	'rrr(r|B)' : 'sragviṇī',
-
+	'nnm(y|j)' : 'paṭuvṛtta',
 	},
 
 13: {
@@ -313,7 +313,8 @@ samavfttas_by_family_and_gaRa = {
 22: {
 	'mmtnnns(g|l)' : 'haṃsī', # also mmggnnnngg
 	'tByjsrn(g|l)' : 'aśvadhāṭī',
-	},
+	'Brnrnrn(g|l)' : 'madraka'
+},
 
 23: {
 	'njBjBjBl(g|l)' : 'adritanayā',

{skrutable-2.6.2 → skrutable-2.7.0}/src/skrutable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skrutable
-Version: 2.6.2
+Version: 2.7.0
 Summary: skrutable library for working with Sanskrit text
 Home-page: https://github.com/tylergneill/skrutable
 Author: Tyler Neill

skrutable-2.6.2/src/skrutable/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.6.2"