dvrd-pydate 1.0.0__tar.gz

dvrd_pydate-1.0.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.1
+Name: dvrd_pydate
+Version: 1.0.0
+Summary: Dave van Rijn Development date extension
+Author-email: Dave van Rijn Development <develop@davevanrijn.nl>
+Project-URL: Homepage, https://github.com/Dave-van-Rijn-Development/dvrd-pydate.git
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+
+# dvrd_pydate
+
+This package provides `date` and `datetime` extensions with useful extra utility functions.
+The extensions are provided as the `PyDate(date)` and `PyDateTime(datetime, PyDate)` classes. All built-in `date` and
+`datetime` functions are still available through inheritance.
+
+## Initialization
+
+### from_value
+
+`PyDate` and `PyDateTime` objects can be constructed using the default `date`/`datetime` constructors or initializing
+functions. They can also easily be constructed from existing `date`/`datetime` objects or their `Py*` variants, using
+the staticmethod `from_value`.
+
+```python
+from datetime import datetime, date
+from dvrd_pydate import PyDate, PyDateTime
+
+date_value = date(2024, 1, 1)
+datetime_value = datetime(2024, 1, 1, 12, 0, 0, 0)
+
+# All valid initializers
+pydate_value = PyDate(2024, 1, 1)
+pydate_value = PyDate.fromisoformat('2024-01-01')
+pydate_value = PyDate.from_value(date_value)
+pydate_value = PyDate(pydate_value)
+
+pydatetime_value = PyDateTime(2024, 1, 1, 12, 0, 0, 0)
+pydatetime_value = PyDateTime.fromisoformat('2024-01-01:12:00:00.000')
+pydatetime_value = PyDateTime.from_value(datetime_value)
+pydatetime_value = PyDateTime.from_value(pydatetime_value)
+```
+
+| **Argument** | Type          | Required | Default | **Description**                                                                                                                   |
+|--------------|---------------|----------|---------|-----------------------------------------------------------------------------------------------------------------------------------|
+| value        | `date \| str` | No       | `None`  | Construct a new PyDate(Time) object from the given value. If value is `None`, `date.today()` or `datetime.now()` is used instead. |
+
+### clone
+
+Both classes provide a `clone` function, which simply clones the object into a new one. This function takes no
+arguments.
+
+## Iteration
+
+Both classes provide a staticmethod `iter` which returns a generator. The generator generates PyDate(Time)s with given
+interval. It is possible to supply a start date, end date and max amounts of steps to take. If both `end` and
+`max_steps` are given, the generator stops at whichever argument is reached first.
+
+```python
+from dvrd_pydate import PyDate, DatePart
+
+for date_value in PyDate.iter(end=PyDate.now().add(7, DatePart.DAYS)):
+    pass
+for date_value in PyDate.iter(max_steps=7):
+    # Does the same as the loop above
+    pass
+```
+
+| **Argument** | Type                                                       | Required | Default        | **Description**                                                                                                                             |
+|--------------|------------------------------------------------------------|----------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------|
+| start        | `date \| str`                                              | No       | `None`         | Start iterating from date(time). If `None`, uses date.today()` or `datetime.now()`                                                          |
+| end          | `date \| str`                                              | No       | `None`         | Optional date(time) to end the iteration at.                                                                                                |
+| step         | `DatePart \| TimePart \| tuple[int, DatePart \| TimePart]` | No       | `DatePart.DAY` | Interval to determine each new date(time) with. `PyDate` can only use `DatePart`, while `PyDateTime` can use both `DatePart` as `TimePart`. |
+| max_steps    | `int`                                                      | No       | None           | Max amount of date(time)s to generate.                                                                                                      |
+
+## Mutations
+
+Both classes provide functions to alter the date or time. All functions return a new instance, mutations are not done
+in-place. All functions can therefore also be chained together.
+
+### Add
+
+Add an amount of date/time part. `PyDate` only supports `DatePart` parts, while `PyDateTime` supports both `DatePart` (
+through inheritance) and `TimePart`.
+
+```python
+from dvrd_pydate import PyDate, PyDateTime, DatePart, TimePart
+
+date_value = PyDate.today()
+date_value = date_value.add(7, DatePart.DAYS)
+date_value = date_value.add(1, DatePart.WEEK)  # Same as above
+
+datetime_value = PyDateTime.now()
+datetime_value = datetime_value.add(1, DatePart.MONTH).add(30, TimePart.SECONDS)
+```
+
+| **Argument** | Type                   | Required | Default | **Description**                            |
+|--------------|------------------------|----------|---------|--------------------------------------------|
+| value        | `int`                  | Yes      | N/A     | The value to add to the current date(time) |
+| key          | `DatePart \| TimePart` | Yes      | N/A     | The part to add the value to               |
+
+### Subtract
+
+Subtract an amount of date/time part. `PyDate` only supports `DatePart` parts, while `PyDateTime` supports both
+`DatePart` (through inheritance) and `TimePart`.
+
+```python
+from dvrd_pydate import PyDate, PyDateTime, DatePart, TimePart
+
+date_value = PyDate.today()
+date_value = date_value.subtract(7, DatePart.DAYS)
+date_value = date_value.subtract(1, DatePart.WEEK)  # Does the same as above
+
+datetime_value = PyDateTime.now()
+datetime_value = datetime_value.subtract(1, DatePart.MONTH).subtract(30, TimePart.SECONDS)
+```
+
+#### Add/Subtract parts
+
+Each part also has its own `add` and `subtract` function. E.g. `add_days(2)`, `add_hours(3)`, `subtract_months(4)`, etc.
+Adding or subtracting with value `1` can also be achieved by using the utility functions `add_day()`, `add_hour()`,
+`subtract_month()`, etc. which calls the `add`/`subtract` functions with value `1`.
+
+## start_of / end_of
+
+Both classes provide the `start_of` and `end_of` functions to conveniently set the date(time) to the start of the given
+date/time part.
+
+```python
+from dvrd_pydate import PyDate, DatePart
+
+date_value = PyDate(2024, 2, 5)  # 5th of February 2024
+start_of_month = date_value.start_of(DatePart.MONTH)  # 1st of February 2024
+end_of_month = date_value.end_of(DatePart.MONTH)  # 29th of February 2024
+```
+
+| **Argument** | Type                   | Required | Default | Description                                           |
+|--------------|------------------------|----------|---------|-------------------------------------------------------|
+| part         | `DatePart \| TimePart` | Yes      | N/A     | Determines to which part the date(time) is mutated to |
+
+## Comparison
+
+Both classes provide convenient function to compare itself to another date(time). The following functions can be used:
+
+- `is_before`
+- `is_same_or_before`
+- `is_same`
+- `is_same_or_after`
+- `is_after`
+- `is_between`
+
+```python
+from dvrd_pydate import PyDate, DatePart
+
+date1 = PyDate(2024, 1, 1)
+date2 = PyDate(2024, 1, 15)
+
+date1.is_same(date2)  # Granularity defaults to DatePart.DAY, returns False
+date1.is_same(date2, DatePart.MONTH)  # True
+```
+
+All function return a `bool`. All functions except `is_between` take the following arguments:
+
+| **Argument** | Type                   | Required | Default        | Description                                                                                                                              |
+|--------------|------------------------|----------|----------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| other        | `date(time) \| str`    | Yes      | N/A            | Date(time) to compare to. Can also be a ISO date(time) string                                                                            |
+| granularity  | `DatePart \| TimePart` | No       | `DatePart.DAY` | Determines the exactness of the comparison. For example, this makes it easy to test if two dates are in the same month of the same year. |
+
+The `is_between` function tests if the object is in between given date(time)s. It is possible to exclude the given start
+and end date.
+
+```python
+from dvrd_pydate import PyDate, DatePart
+date1 = PyDate(2024, 1, 1)
+date2 = PyDate(2024, 1, 15)
+date3 = PyDate(2024, 1, 12)
+
+date3.is_between(date1, date2)  # True
+date2.is_between(date1, date2)  # True
+date2.is_between(date1, date2, to_inclusive=False)  # False
+```

dvrd_pydate-1.0.0/README.md

@@ -0,0 +1,171 @@
+# dvrd_pydate
+
+This package provides `date` and `datetime` extensions with useful extra utility functions.
+The extensions are provided as the `PyDate(date)` and `PyDateTime(datetime, PyDate)` classes. All built-in `date` and
+`datetime` functions are still available through inheritance.
+
+## Initialization
+
+### from_value
+
+`PyDate` and `PyDateTime` objects can be constructed using the default `date`/`datetime` constructors or initializing
+functions. They can also easily be constructed from existing `date`/`datetime` objects or their `Py*` variants, using
+the staticmethod `from_value`.
+
+```python
+from datetime import datetime, date
+from dvrd_pydate import PyDate, PyDateTime
+
+date_value = date(2024, 1, 1)
+datetime_value = datetime(2024, 1, 1, 12, 0, 0, 0)
+
+# All valid initializers
+pydate_value = PyDate(2024, 1, 1)
+pydate_value = PyDate.fromisoformat('2024-01-01')
+pydate_value = PyDate.from_value(date_value)
+pydate_value = PyDate(pydate_value)
+
+pydatetime_value = PyDateTime(2024, 1, 1, 12, 0, 0, 0)
+pydatetime_value = PyDateTime.fromisoformat('2024-01-01:12:00:00.000')
+pydatetime_value = PyDateTime.from_value(datetime_value)
+pydatetime_value = PyDateTime.from_value(pydatetime_value)
+```
+
+| **Argument** | Type          | Required | Default | **Description**                                                                                                                   |
+|--------------|---------------|----------|---------|-----------------------------------------------------------------------------------------------------------------------------------|
+| value        | `date \| str` | No       | `None`  | Construct a new PyDate(Time) object from the given value. If value is `None`, `date.today()` or `datetime.now()` is used instead. |
+
+### clone
+
+Both classes provide a `clone` function, which simply clones the object into a new one. This function takes no
+arguments.
+
+## Iteration
+
+Both classes provide a staticmethod `iter` which returns a generator. The generator generates PyDate(Time)s with given
+interval. It is possible to supply a start date, end date and max amounts of steps to take. If both `end` and
+`max_steps` are given, the generator stops at whichever argument is reached first.
+
+```python
+from dvrd_pydate import PyDate, DatePart
+
+for date_value in PyDate.iter(end=PyDate.now().add(7, DatePart.DAYS)):
+    pass
+for date_value in PyDate.iter(max_steps=7):
+    # Does the same as the loop above
+    pass
+```
+
+| **Argument** | Type                                                       | Required | Default        | **Description**                                                                                                                             |
+|--------------|------------------------------------------------------------|----------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------|
+| start        | `date \| str`                                              | No       | `None`         | Start iterating from date(time). If `None`, uses date.today()` or `datetime.now()`                                                          |
+| end          | `date \| str`                                              | No       | `None`         | Optional date(time) to end the iteration at.                                                                                                |
+| step         | `DatePart \| TimePart \| tuple[int, DatePart \| TimePart]` | No       | `DatePart.DAY` | Interval to determine each new date(time) with. `PyDate` can only use `DatePart`, while `PyDateTime` can use both `DatePart` as `TimePart`. |
+| max_steps    | `int`                                                      | No       | None           | Max amount of date(time)s to generate.                                                                                                      |
+
+## Mutations
+
+Both classes provide functions to alter the date or time. All functions return a new instance, mutations are not done
+in-place. All functions can therefore also be chained together.
+
+### Add
+
+Add an amount of date/time part. `PyDate` only supports `DatePart` parts, while `PyDateTime` supports both `DatePart` (
+through inheritance) and `TimePart`.
+
+```python
+from dvrd_pydate import PyDate, PyDateTime, DatePart, TimePart
+
+date_value = PyDate.today()
+date_value = date_value.add(7, DatePart.DAYS)
+date_value = date_value.add(1, DatePart.WEEK)  # Same as above
+
+datetime_value = PyDateTime.now()
+datetime_value = datetime_value.add(1, DatePart.MONTH).add(30, TimePart.SECONDS)
+```
+
+| **Argument** | Type                   | Required | Default | **Description**                            |
+|--------------|------------------------|----------|---------|--------------------------------------------|
+| value        | `int`                  | Yes      | N/A     | The value to add to the current date(time) |
+| key          | `DatePart \| TimePart` | Yes      | N/A     | The part to add the value to               |
+
+### Subtract
+
+Subtract an amount of date/time part. `PyDate` only supports `DatePart` parts, while `PyDateTime` supports both
+`DatePart` (through inheritance) and `TimePart`.
+
+```python
+from dvrd_pydate import PyDate, PyDateTime, DatePart, TimePart
+
+date_value = PyDate.today()
+date_value = date_value.subtract(7, DatePart.DAYS)
+date_value = date_value.subtract(1, DatePart.WEEK)  # Does the same as above
+
+datetime_value = PyDateTime.now()
+datetime_value = datetime_value.subtract(1, DatePart.MONTH).subtract(30, TimePart.SECONDS)
+```
+
+#### Add/Subtract parts
+
+Each part also has its own `add` and `subtract` function. E.g. `add_days(2)`, `add_hours(3)`, `subtract_months(4)`, etc.
+Adding or subtracting with value `1` can also be achieved by using the utility functions `add_day()`, `add_hour()`,
+`subtract_month()`, etc. which calls the `add`/`subtract` functions with value `1`.
+
+## start_of / end_of
+
+Both classes provide the `start_of` and `end_of` functions to conveniently set the date(time) to the start of the given
+date/time part.
+
+```python
+from dvrd_pydate import PyDate, DatePart
+
+date_value = PyDate(2024, 2, 5)  # 5th of February 2024
+start_of_month = date_value.start_of(DatePart.MONTH)  # 1st of February 2024
+end_of_month = date_value.end_of(DatePart.MONTH)  # 29th of February 2024
+```
+
+| **Argument** | Type                   | Required | Default | Description                                           |
+|--------------|------------------------|----------|---------|-------------------------------------------------------|
+| part         | `DatePart \| TimePart` | Yes      | N/A     | Determines to which part the date(time) is mutated to |
+
+## Comparison
+
+Both classes provide convenient function to compare itself to another date(time). The following functions can be used:
+
+- `is_before`
+- `is_same_or_before`
+- `is_same`
+- `is_same_or_after`
+- `is_after`
+- `is_between`
+
+```python
+from dvrd_pydate import PyDate, DatePart
+
+date1 = PyDate(2024, 1, 1)
+date2 = PyDate(2024, 1, 15)
+
+date1.is_same(date2)  # Granularity defaults to DatePart.DAY, returns False
+date1.is_same(date2, DatePart.MONTH)  # True
+```
+
+All function return a `bool`. All functions except `is_between` take the following arguments:
+
+| **Argument** | Type                   | Required | Default        | Description                                                                                                                              |
+|--------------|------------------------|----------|----------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| other        | `date(time) \| str`    | Yes      | N/A            | Date(time) to compare to. Can also be a ISO date(time) string                                                                            |
+| granularity  | `DatePart \| TimePart` | No       | `DatePart.DAY` | Determines the exactness of the comparison. For example, this makes it easy to test if two dates are in the same month of the same year. |
+
+The `is_between` function tests if the object is in between given date(time)s. It is possible to exclude the given start
+and end date.
+
+```python
+from dvrd_pydate import PyDate, DatePart
+date1 = PyDate(2024, 1, 1)
+date2 = PyDate(2024, 1, 15)
+date3 = PyDate(2024, 1, 12)
+
+date3.is_between(date1, date2)  # True
+date2.is_between(date1, date2)  # True
+date2.is_between(date1, date2, to_inclusive=False)  # False
+```

dvrd_pydate-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "dvrd_pydate"
+version = "1.0.0"
+description = "Dave van Rijn Development date extension"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "Dave van Rijn Development", email = "develop@davevanrijn.nl" }]
+
+[project.urls]
+Homepage = "https://github.com/Dave-van-Rijn-Development/dvrd-pydate.git"
+
+[project.optional-dependencies]
+test = [
+    'coverage'
+]
+
+[build-system]
+requires = ["setuptools>=62.6", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.coverage.run]
+omit = [
+    "*/tests/*"
+]

dvrd_pydate-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dvrd_pydate-1.0.0/src/dvrd_pydate/__init__.py

@@ -0,0 +1,3 @@
+from .pydate import PyDate
+from .pydatetime import PyDateTime
+from .enums import DatePart, TimePart

dvrd_pydate-1.0.0/src/dvrd_pydate/enums.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class DatePart(Enum):
+    YEAR = 'year'
+    YEARS = 'years'
+    MONTH = 'month'
+    MONTHS = 'months'
+    DAY = 'day'
+    DAYS = 'days'
+    WEEK = 'week'
+    WEEKS = 'weeks'
+
+
+class TimePart(Enum):
+    HOUR = 'hour'
+    HOURS = 'hours'
+    MINUTE = 'minute'
+    MINUTES = 'minutes'
+    SECOND = 'second'
+    SECONDS = 'seconds'
+    MICROSECOND = 'microsecond'
+    MICROSECONDS = 'microseconds'

dvrd_pydate-1.0.0/src/dvrd_pydate/pydate.py

@@ -0,0 +1,215 @@
+from calendar import monthrange
+from datetime import date, timedelta
+from typing import Self, Generator
+
+from dvrd_pydate.enums import DatePart, TimePart
+
+days_in_week = 7
+months_in_year = 12
+
+
+class PyDate(date):
+    @staticmethod
+    def from_value(value: date | str = None):
+        if isinstance(value, str):
+            value = date.fromisoformat(value)
+        elif value is None:
+            value = date.today()
+        return PyDate(value.year, value.month, value.day)
+
+    @staticmethod
+    def iter(*, start: date | str = None, end: date | str | None = None,
+             step: DatePart | TimePart | tuple[int, DatePart | TimePart] = DatePart.DAY, max_steps: int = None) -> \
+            Generator["PyDate", None, None]:
+        if max_steps == 0:
+            # Raises StopIteration
+            return
+        if isinstance(step, TimePart):
+            raise KeyError('Cannot use time parts in PyDate')
+        elif isinstance(step, tuple):
+            if isinstance((step_key := step[1]), TimePart):
+                raise KeyError('Cannot use time parts in PyDate')
+            step_value = step[0]
+        else:
+            step_value = 1
+            step_key = step
+
+        if start is None:
+            start = date.today()
+        current = PyDate.from_value(start)
+        end_value = None if end is None else PyDate.from_value(end)
+        current_step = 0
+        while end_value is None or current < end_value:
+            yield current
+            current_step += 1
+            if max_steps is not None and current_step == max_steps:
+                break
+            current = current.add(value=step_value, key=step_key)
+
+    @property
+    def max_day(self) -> int:
+        return monthrange(self.year, self.month)[1]
+
+    def add(self, value: int, key: DatePart) -> Self:
+        if key in [DatePart.YEAR, DatePart.YEARS]:
+            return self.add_years(value)
+        elif key in [DatePart.MONTH, DatePart.MONTHS]:
+            return self.add_months(value)
+        elif key in [DatePart.WEEK, DatePart.WEEKS]:
+            return self.add_weeks(value)
+        elif key in [DatePart.DAY, DatePart.DAYS]:
+            return self.add_days(value)
+        else:
+            raise KeyError(f'Key "{key}" cannot be used in PyDate')
+
+    def subtract(self, value: int, key: DatePart) -> Self:
+        if key in [DatePart.YEAR, DatePart.YEARS]:
+            return self.subtract_years(value)
+        elif key in [DatePart.MONTH, DatePart.MONTHS]:
+            return self.subtract_months(value)
+        elif key in [DatePart.WEEK, DatePart.WEEKS]:
+            return self.subtract_weeks(value)
+        elif key in [DatePart.DAY, DatePart.DAYS]:
+            return self.subtract_days(value)
+        else:
+            raise KeyError(f'Key "{key}" cannot be used in PyDate')
+
+    def add_years(self, value: int) -> Self:
+        return self.replace(year=self.year + value)
+
+    def add_year(self) -> Self:
+        return self.add_years(1)
+
+    def subtract_years(self, value: int) -> Self:
+        return self.replace(year=self.year - value)
+
+    def subtract_year(self) -> Self:
+        return self.subtract_years(1)
+
+    def add_months(self, value: int) -> Self:
+        new_date = self.clone()
+        add_years, month_value = divmod(new_date.month + value, months_in_year + 1)
+        if add_years:
+            month_value += 1
+        year = new_date.year + add_years
+        max_date = monthrange(year, month_value)[1]
+        return new_date.replace(year=new_date.year + add_years, month=month_value, day=min(max_date, new_date.day))
+
+    def add_month(self) -> Self:
+        return self.add_months(1)
+
+    def subtract_months(self, value: int) -> Self:
+        new_date = self.clone()
+        subtract_years, remaining_months = divmod(value, months_in_year)
+        if subtract_years:
+            new_date = new_date.subtract_years(subtract_years)
+        if (month_value := new_date.month - remaining_months) < 1:
+            new_date = new_date.subtract_year()
+            month_value = 12 - abs(month_value)
+        max_date = monthrange(new_date.year, month_value)[1]
+        return new_date.replace(month=month_value, day=min(new_date.day, max_date))
+
+    def subtract_month(self) -> Self:
+        return self.subtract_months(1)
+
+    def add_weeks(self, value: int) -> Self:
+        return self + timedelta(weeks=value)
+
+    def add_week(self) -> Self:
+        return self.add_weeks(1)
+
+    def subtract_weeks(self, value: int) -> Self:
+        return self - timedelta(weeks=value)
+
+    def subtract_week(self) -> Self:
+        return self.subtract_weeks(1)
+
+    def add_days(self, value: int) -> Self:
+        return self + timedelta(days=value)
+
+    def add_day(self) -> Self:
+        return self.add_days(1)
+
+    def subtract_days(self, value: int) -> Self:
+        return self - timedelta(days=value)
+
+    def subtract_day(self) -> Self:
+        return self.subtract_days(1)
+
+    def clone(self) -> "PyDate":
+        return type(self).from_value(self)
+
+    def start_of(self, part: DatePart | TimePart) -> Self:
+        if isinstance(part, TimePart):
+            raise KeyError('Time part cannot be used in PyDate')
+        if part in [DatePart.YEAR, DatePart.YEARS]:
+            return self.replace(month=1, day=1)
+        elif part in [DatePart.MONTH, DatePart.MONTHS]:
+            return self.replace(day=1)
+        elif part in [DatePart.WEEK, DatePart.WEEKS]:
+            current_weekday = self.weekday()
+            return self.replace(day=self.day - current_weekday)
+        elif part in [DatePart.DAY, DatePart.DAYS]:
+            return self
+        else:
+            raise KeyError(f'Unsupported start_of part {part}')
+
+    def end_of(self, part: DatePart | TimePart) -> Self:
+        if isinstance(part, TimePart):
+            raise KeyError('Time part cannot be used in PyDate')
+        if part in [DatePart.YEAR, DatePart.YEARS]:
+            return self.replace(month=12, day=31)
+        elif part in [DatePart.MONTH, DatePart.MONTHS]:
+            return self.replace(day=self.max_day)
+        elif part in [DatePart.WEEK, DatePart.WEEKS]:
+            current_day = self.weekday()
+            return self.replace(day=self.day + 6 - current_day)
+        elif part in [DatePart.DAY, DatePart.DAYS]:
+            return self
+        else:
+            raise KeyError(f'Unsupported end_of part {part}')
+
+    def is_before(self, other: date | str, granularity: DatePart | TimePart = DatePart.DAY) -> bool:
+        if not isinstance(other, PyDate):
+            other = PyDate.from_value(other)
+        return self.start_of(granularity) < other.start_of(granularity)
+
+    def is_same_or_before(self, other: date | str, granularity: DatePart | TimePart = DatePart.DAY) -> bool:
+        if not isinstance(other, PyDate):
+            other = PyDate.from_value(other)
+        return self.start_of(granularity) <= other.start_of(granularity)
+
+    def is_same(self, other: date | str, granularity: DatePart | TimePart = DatePart.DAY) -> bool:
+        if not isinstance(other, PyDate):
+            other = PyDate.from_value(other)
+        return self.start_of(granularity) == other.start_of(granularity)
+
+    def is_same_or_after(self, other: date | str, granularity: DatePart | TimePart = DatePart.DAY) -> bool:
+        if not isinstance(other, PyDate):
+            other = PyDate.from_value(other)
+        return self.start_of(granularity) >= other.start_of(granularity)
+
+    def is_after(self, other: date | str, granularity: DatePart | TimePart = DatePart.DAY) -> bool:
+        if not isinstance(other, PyDate):
+            other = PyDate.from_value(other)
+        return self.start_of(granularity) > other.start_of(granularity)
+
+    def is_between(self, other1: date | str, other2: date | str, *, granularity: DatePart = DatePart.DAY,
+                   from_inclusive: bool = True, to_inclusive: bool = True) -> bool:
+        if not isinstance(other1, PyDate):
+            other1 = PyDate.from_value(other1)
+        if not isinstance(other2, PyDate):
+            other2 = PyDate.from_value(other2)
+        from_date = min(other1, other2)
+        to_date = max(other1, other2)
+        if from_inclusive:
+            if not self.is_same_or_after(from_date, granularity):
+                return False
+        elif not self.is_after(from_date, granularity):
+            return False
+        if to_inclusive:
+            if not self.is_same_or_before(to_date, granularity):
+                return False
+        elif not self.is_before(to_date, granularity):
+            return False
+        return True