added AmudYomiBavliDirshu calculator

Author: Pinny Markowitz

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - `jewish_calendar.is_taanis_bechorim()` function added
 - `jewish_calendar.is_shabbos_mevorchim()` function added
 - `jewish_calendar.significant_shabbos()` function added
+- New `AmudYomiBavliDirshu` calculator for Amud Yomi Bavli following the Dirshu learning schedule
+- Support for limudim containing fractional units (required for Amud Yomi)
 
 ### Fixed
 - Bug in `jewish_date.__add__()` and `jewish_date.__sub__()` returned the base JewishDate type even when inherited.

test/test_amud_yomi_bavli_dirshu_calculator.py

@@ -0,0 +1,70 @@
+import unittest
+from datetime import date
+
+from zmanim.limudim.calculators.amud_yomi_bavli_dirshu import AmudYomiBavliDirshu
+
+
+class TestAmudYomiBavliDirshuCalculator(unittest.TestCase):
+    def test_simple_date(self):
+        test_date = date(2024, 5, 30)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.start_date(), test_date)
+        self.assertEqual(limud.end_date(), test_date)
+        self.assertEqual(limud.description(), 'shabbos 53a')
+
+    def test_before_cycle_began(self):
+        test_date = date(2023, 1, 1)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertIsNone(limud)
+
+    def test_first_day_of_cycle(self):
+        test_date = date(2038, 8, 4)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.start_date(), test_date)
+        self.assertEqual(limud.end_date(), test_date)
+        self.assertEqual(limud.description(), 'berachos 2a')
+
+    def test_last_day_of_cycle(self):
+        test_date = date(2038, 8, 3)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'niddah 73a')
+
+    def test_end_of_meilah(self):
+        test_date = date(2038, 2, 10)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'meilah 22a')
+
+    def test_beginning_of_kinnim(self):
+        test_date = date(2038, 2, 11)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'kinnim 22b')
+
+    def test_end_of_kinnim(self):
+        test_date = date(2038, 2, 16)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'kinnim 25a')
+
+    def test_beginning_of_tamid(self):
+        test_date = date(2038, 2, 17)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'tamid 25b')
+
+    def test_end_of_tamid(self):
+        test_date = date(2038, 3, 5)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'tamid 33b')
+
+    def test_beginning_of_midos(self):
+        test_date = date(2038, 3, 6)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'midos 34a')
+
+    def test_end_of_midos(self):
+        test_date = date(2038, 3, 13)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'midos 37b')
+
+    def test_after_midos(self):
+        test_date = date(2038, 3, 14)
+        limud = AmudYomiBavliDirshu().limud(test_date)
+        self.assertEqual(limud.description(), 'niddah 2a')

test/test_limudim_unit.py

@@ -12,10 +12,22 @@ def test_str_for_a_paged_unit(self):
         subject = Unit(['berachos', 3])
         self.assertEqual(str(subject), 'berachos 3')
 
-    def test_str_for_a_multi_level_unit(self):
+    def test_str_for_a_multi_level_unit_with_integers(self):
         subject = Unit(['berachos', 3, 5, 7, 4, 5])
         self.assertEqual(str(subject), 'berachos 3:5:7:4:5')
 
+    def test_str_for_a_multi_level_unit_with_a_character(self):
+        subject = Unit(['berachos', 'a'])
+        self.assertEqual(str(subject), 'berachos a')
+
+    def test_str_for_a_multi_level_unit_with_integer_and_then_a_character(self):
+        subject = Unit(['berachos', 13, 'a'])
+        self.assertEqual(str(subject), 'berachos 13a')
+
+    def test_str_for_a_multi_level_unit_with_integer_and_then_a_character_and_rlm_marker(self):
+        subject = Unit(['berachos', 13, u'a\u200f'])
+        self.assertEqual(str(subject), u'berachos 13a\u200f')
+
     def test_str_for_a_multi_component_primitive_unit(self):
         subject = Unit('tazria', 'metzora')
         self.assertEqual(str(subject), 'tazria - metzora')

zmanim/limudim/calculators/amud_yomi_bavli_dirshu.py

@@ -0,0 +1,42 @@
+from datetime import date
+from fractions import Fraction
+from typing import Optional, Union
+
+from zmanim.hebrew_calendar.jewish_date import JewishDate
+from zmanim.limudim.calculators.daf_yomi_bavli import DafYomiBavli
+from zmanim.limudim.cycle import Cycle
+
+
+class AmudYomiBavliDirshu(DafYomiBavli):
+    Units = {u[0]: u[1] + (0 if i in [0, 2, 5, 8, 9, 10, 11, 12, 21, 27, 29, 30, 31, 32, 33, 35, 36, 39]
+                           else Fraction(1, 2))
+             for i, u in enumerate(DafYomiBavli.Units.items())}
+
+    def initial_cycle_date(self) -> JewishDate:
+        return self._jewish_date(date(2023, 10, 16))
+
+    @staticmethod
+    def default_units() -> dict:
+        return AmudYomiBavliDirshu.Units
+
+    def unit_step(self) -> Union[int, Fraction]:
+        return Fraction(1, 2)   # Rational numbers preferred over float
+
+    def fractional_units(self) -> Optional[tuple]:
+        return 'a', 'b'
+
+    def starting_page(self, units: dict, unit_name: str) -> int:
+        if unit_name == 'kinnim':
+            return 22 + self.unit_step()
+        elif unit_name == 'tamid':
+            return 25 + self.unit_step()
+        elif unit_name == 'midos':
+            return 34
+        else:
+            return self.default_starting_page()
+
+    def cycle_end_calculation(self, start_date: JewishDate, iteration: int) -> JewishDate:
+        return start_date + (5406 - 1)
+
+    def cycle_units_calculation(self, cycle: Cycle) -> dict:
+        return self.default_units()

zmanim/limudim/limud_calculator.py

@@ -1,5 +1,7 @@
 from datetime import date
+from fractions import Fraction
 from functools import reduce
+from numbers import Number
 from typing import Optional, Union
 
 from zmanim.hebrew_calendar.jewish_date import JewishDate
@@ -37,7 +39,7 @@ def perpetual_cycle_anchor(self) -> Optional[Anchor]:
         return None
 
     # Number of units to apply over an iteration
-    def unit_step(self) -> int:
+    def unit_step(self) -> Union[int, Fraction]:
         return 1
 
     # Are units components of some larger grouping? (e.g. pages or mishnayos)
@@ -94,30 +96,32 @@ def skip_unit(self) -> Optional[Unit]:
     def is_skip_interval(self, interval: Interval) -> bool:
         return False
 
+    def base_unit(self) -> Union[int, Fraction]:
+        return self.unit_step() if self.fractional_units() else 1
+
     def tiered_units_for_interval(self, units: Union[dict, list], interval: Interval) -> Optional[Unit]:
         iteration = interval.iteration
-        offset = ((iteration - 1) * self.unit_step()) + 1
-        if self.unit_step() > 1:
-            offset2 = (offset - 1) + self.unit_step()
-        else:
-            offset2 = None
+        offset = ((iteration - 1) * self.unit_step()) + self.base_unit()
+        offset2 = (offset - 1) + self.unit_step() if self.unit_step() > 1 else None
         offsets = list(filter(None.__ne__, [offset, offset2]))
         targets = [[o, []] for o in offsets]
         results = self.find_offset_units(units, targets)
         if {r[0] for r in results} != {0}:
             return None
         paths = list(map(lambda r: r[1], results))
+        if self.fractional_units():
+            paths = list(map(lambda p: self._resolve_fractional_path(p), paths))
         return Unit(*paths)
 
-    def find_offset_units(self, units: dict, targets: list) -> list:
+    def find_offset_units(self, units: Union[dict, list], targets: list) -> list:
         def unit_reducer(t: list, name: str):
             attributes = units[name]
-            if isinstance(attributes, int):
+            if isinstance(attributes, (int, Fraction)):
                 start = self.starting_page(units, name)
-                length = (attributes - start) + 1
+                length = (attributes - start) + self.base_unit()
 
                 head = [e for e in t if e[0] == 0]
-                tail = [[0, p + [name, (start + o) - 1]] if o <= length else [o - length, p] for o, p in t if o != 0]
+                tail = [[0, p + [name, (start + o) - self.base_unit()]] if o <= length else [o - length, p] for o, p in t if o != 0]
                 return head + tail
             else:
                 head = [e for e in t if e[0] == 0]
@@ -138,3 +142,12 @@ def find_cycle(self, date: JewishDate):
     @staticmethod
     def _jewish_date(date):
         return date if isinstance(date, JewishDate) else JewishDate(date)
+
+    def _resolve_fractional_path(self, path: Union[list, Number]) -> Union[list, Number]:
+        if isinstance(path, Number):
+            index = int((path - int(path)) * len(self.fractional_units()))
+            return [int(path), self.fractional_units()[index]]
+        elif isinstance(path, list):
+            return path[:-1] + self._resolve_fractional_path(path[-1])
+        else:
+            return path

zmanim/limudim/unit.py

@@ -39,7 +39,16 @@ def _render_with_root(self, component: list) -> str:
 
     @staticmethod
     def _render_extension(extension: list) -> str:
-        return ':'.join(map(str, extension))
+        if len(extension) == 1:
+            return str(extension[0])
+        else:
+            delimiter = '' if Unit._is_character_extension(extension[-1]) else ':'
+            return Unit._render_extension(extension[:-1]) + delimiter + str(extension[-1])
+
+    @staticmethod
+    def _is_character_extension(component: Any) -> bool:
+        # single character extensions are appended directly as 'amud', R-to-L markers should be ignored
+        return isinstance(component, str) and not component.isnumeric() and len(component.replace(u'\u200f', '')) == 1
 
     def _render_secondary(self, second_component: list, first_component: list) -> str:
         if second_component is None: