added time related datatypes

Author: rsb-23

tests/test_icalendar.py

@@ -9,13 +9,13 @@
 
 from vobjectx import base
 from vobjectx.behavior import new_from_behavior
+from vobjectx.datatypes import Period
 from vobjectx.icalendar import (
     RecurringComponent,
     TimezoneComponent,
     VCalendar2_0,
     delta_to_offset,
     parse_dtstart,
-    string_to_period,
     string_to_text_values,
     timedelta_to_string,
 )
@@ -56,12 +56,12 @@ def test_string_to_text_values():
 
 def test_string_to_period():
     """Test datetime strings"""
-    assert string_to_period("19970101T180000Z/19970102T070000Z") == (
+    assert Period("19970101T180000Z/19970102T070000Z").value == (
         dt.datetime(1997, 1, 1, 18, 0, tzinfo=UTC_TZ),
         dt.datetime(1997, 1, 2, 7, 0, tzinfo=UTC_TZ),
     )
 
-    assert string_to_period("19970101T180000Z/PT1H") == (
+    assert Period("19970101T180000Z/PT1H").value == (
         dt.datetime(1997, 1, 1, 18, 0, tzinfo=UTC_TZ),
         dt.timedelta(0, 3600),
     )

vobjectx/datatypes/__init__.py

@@ -0,0 +1,13 @@
+from typing import Any, Protocol
+
+from .alias import duration_to_timedelta, string_to_date, string_to_date_time, string_to_period
+from .time_types import Date, DateTime, Duration, Period, Time
+
+
+# pylint: disable=r0903
+class DataType(Protocol):
+    text: str
+    value: Any
+
+    def _parse(self):
+        pass

vobjectx/datatypes/alias.py

@@ -0,0 +1,17 @@
+from .time_types import Date, DateTime, Duration, Period
+
+
+def duration_to_timedelta(duration: str):
+    return Duration(duration).value
+
+
+def string_to_date(s: str):
+    return Date(s).value
+
+
+def string_to_date_time(s: str, tzinfo=None, strict: bool = False):
+    return DateTime(s, tzinfo, strict=strict).value
+
+
+def string_to_period(s: str, tzinfo=None):
+    return Period(s, tzinfo=tzinfo).value

vobjectx/datatypes/time_types.py

@@ -0,0 +1,105 @@
+# pylint: disable=r0903
+import datetime as dt
+import re
+
+from vobjectx.exceptions import ParseError
+from vobjectx.registry import TzidRegistry
+
+
+def _is_duration(s: str) -> bool:
+    return "P" in s[:2].upper()
+
+
+class Date:
+    def __init__(self, date_: str):
+        self.text = date_
+        self._parse()
+
+    def _parse(self):
+        self.value: dt.date = dt.datetime.strptime(self.text, "%Y%m%d").date()
+
+
+class DateTime:
+    def __init__(self, date_time_: str, tzinfo: dt.tzinfo = None, strict: bool = False):
+        if not strict:
+            date_time_ = date_time_.strip()
+        self.text = date_time_
+        self.tzinfo = tzinfo
+        self._parse()
+
+    def _parse(self):
+        try:
+            _datetime = dt.datetime.strptime(self.text[:15], "%Y%m%dT%H%M%S")
+        except ValueError as e:
+            raise ParseError(f"'{self.text}' is not a valid DATE-TIME") from e
+
+        if len(self.text) > 15 and self.text[15] == "Z":
+            self.tzinfo = TzidRegistry.get("UTC")
+        self.value = _datetime.replace(tzinfo=self.tzinfo)
+
+
+class Duration:
+    def __init__(self, duration: str):
+        self.text = duration.strip()
+        self.value: dt.timedelta = dt.timedelta()
+        self._parse()
+
+    def _parse(self):
+        if "," in self.text:
+            raise ParseError("DURATION must have a single value.")
+
+        interval_map = {"W": "weeks", "D": "days", "H": "hours", "M": "minutes", "S": "seconds"}
+
+        _sign = -1 if self.text[0] == "-" else 1
+        params = {}
+        for part in re.findall(r"\d{0,2}[PTWDHMS]{0,2}", self.text):
+            if part and part[-1] in interval_map:
+                params[interval_map[part[-1]]] = int(part[:-1])
+        if not params:
+            raise ParseError(f"Invalid duration string : {self.text}")
+        self.value = _sign * dt.timedelta(**params)
+
+
+class Period:
+    def __init__(self, period: str, tzinfo: dt.tzinfo = None):
+        self.text = period
+        self.tzinfo = tzinfo
+
+        self.is_explicit = False
+        self.start_dt = None
+        self.end_dt = None
+        self.delta = None
+        self._parse()
+
+    def _parse(self):
+        start_dt, end_dt = self.text.split("/")
+        self.start_dt = DateTime(start_dt, self.tzinfo).value
+        if _is_duration(end_dt):
+            # period-start = date-time "/" dur-value
+            self.is_explicit = False
+            self.delta = Duration(end_dt).value
+        else:
+            # period-explicit = date-time "/" date-time
+            self.is_explicit = True
+            self.end_dt = DateTime(end_dt, self.tzinfo).value
+
+    @property
+    def value(self) -> tuple[dt.datetime, dt.datetime | dt.timedelta]:
+        return self.start_dt, self.delta or self.end_dt
+
+
+class Time:
+    def __init__(self, time: str, tzinfo: dt.tzinfo = None):
+        self.text = time
+        self.tzinfo = tzinfo
+        self._parse()
+
+    def _parse(self):
+        try:
+            _time = dt.datetime.strptime(self.text[:6], "%H%M%S").time()
+        except ValueError as e:
+            raise ParseError(f"'{self.text}' is not a valid TIME") from e
+
+        if len(self.text) > 6 and self.text[6] == "Z":
+            self.tzinfo = TzidRegistry.get("UTC")
+        self.value = _time.replace(tzinfo=self.tzinfo)

vobjectx/ical/__init__.py

@@ -1,8 +1 @@
-from .ical_parser import (
-    parse_dtstart,
-    string_to_date,
-    string_to_date_time,
-    string_to_durations,
-    string_to_period,
-    string_to_text_values,
-)
+from .ical_helper import date_to_datetime_, from_last_week_, parse_dtstart, string_to_text_values

vobjectx/ical/ical_helper.py

@@ -1,7 +1,11 @@
 import datetime as dt
 import math
 
-# -------------------- Helper subclasses ---------------------------------------
+from vobjectx import datatypes as vtypes
+from vobjectx.exceptions import ParseError
+from vobjectx.registry import TzidRegistry
+
+# -------------------- Helper funcs ---------------------------------------
 
 
 def date_to_datetime_(dt_obj: dt.datetime | dt.date) -> dt.datetime:
@@ -18,3 +22,63 @@ def from_last_week_(dt_: dt.datetime) -> int:
     time_diff = next_month - dt_
     days_gap = time_diff.days + bool(time_diff.seconds)
     return math.ceil(days_gap / 7)
+
+
+# -------------------- Parser funcs ---------------------------------------
+
+# DQUOTE included to work around iCal's penchant for backslash escaping it,
+# although it isn't actually supposed to be escaped according to rfc2445 TEXT
+ESCAPABLE_CHAR_LIST = '\\;,Nn"'
+
+
+def string_to_text_values(s: str, list_separator: str = ",", char_list: str = ESCAPABLE_CHAR_LIST) -> list[str]:
+    def escaped_char(ch: str) -> str:
+        if ch not in char_list:
+            # leave unrecognized escaped characters for later passes
+            return "\\" + ch
+        return "\n" if ch in "nN" else ch
+
+    current = []
+    results = []
+    to_escape = False
+    for char in s:
+        if to_escape:
+            current.append(escaped_char(char))
+            to_escape = False
+            continue
+
+        if char == "\\":
+            to_escape = True
+        elif char == list_separator:
+            current = "".join(current)
+            results.append(current)
+            current = []
+        else:
+            current.append(char)
+
+    if current or not results:
+        current = "".join(current)
+        results.append(current)
+    return results
+
+
+def parse_dtstart(contentline, allow_signature_mismatch: bool = False) -> dt.datetime | dt.date | None:
+    """
+    Convert a contentline's value into a date or date-time.
+
+    A variety of clients don't serialize dates with the appropriate VALUE parameter, so rather than failing on these
+    (technically invalid) lines, if allow_signature_mismatch is True, try to parse both varieties.
+    """
+    tzinfo = TzidRegistry.get(getattr(contentline, "tzid_param", None))
+    value_param = getattr(contentline, "value_param", "DATE-TIME").upper()
+    parsed_dtstart = None
+    if value_param == "DATE":
+        parsed_dtstart = vtypes.Date(contentline.value).value
+    elif value_param == "DATE-TIME":
+        try:
+            parsed_dtstart = vtypes.DateTime(contentline.value, tzinfo).value
+        except ParseError as e:
+            if not allow_signature_mismatch:
+                raise e
+            parsed_dtstart = vtypes.Date(contentline.value).value
+    return parsed_dtstart