icalendar_light 1.1.0__py3-none-any.whl

icalendar_light/__init__.py

@@ -0,0 +1 @@
+VERSION = '1.1.0'

icalendar_light/casters.py

@@ -0,0 +1,56 @@
+from datetime import datetime
+from typing import Any
+
+from dateutil.parser import parse as parse_datestr
+from dateutil.tz import gettz
+from dateutil.utils import default_tzinfo
+from dateutil.rrule import rrulestr
+
+
+def cast_date(*, value: str, params: str, shared: dict) -> datetime:
+    """Cast date/datetime string into object.
+
+    :param value: Current value.
+    :param params: Additional value-related parameters.
+    :param shared: Global shared parameters.
+
+    """
+    param_key, _, param_val = params.partition('=')
+
+    date = parse_datestr(value)
+    tz = param_val if param_key == 'TZID' else shared['tz'] or 'UTC'
+
+    return default_tzinfo(date, gettz(tz))
+
+
+def cast_recurrence(*, value: str, params: str, shared: dict) -> Any:
+    """Parses recurrence rule string.
+
+    :param value: Current value.
+    :param params: Additional value-related parameters.
+    :param shared: Global shared parameters.
+
+    """
+    return rrulestr(value)
+
+
+def cast_default(*, value: str, params: str, shared: dict) -> str:
+    """Default caster, performing basic transformations.
+
+    :param value: Current value.
+    :param params: Additional value-related parameters.
+    :param shared: Global shared parameters.
+
+    """
+    return value.replace(r'\,', ',')
+
+
+def cast_int(*, value: str, params: str, shared: dict) -> int:
+    """Casts value to integer.
+
+    :param value: Current value.
+    :param params: Additional value-related parameters.
+    :param shared: Global shared parameters.
+
+    """
+    return int(value)

icalendar_light/cli.py

@@ -0,0 +1,33 @@
+import click
+from icalendar_light import VERSION
+from icalendar_light.toolbox import Calendar
+
+
+@click.group()
+@click.version_option(version=VERSION)
+def entry_point():
+    """icalendar_light command line utilities."""
+
+
+@entry_point.command()
+@click.argument('source')
+@click.option('--days', help='Number of days forward to show events', default=60)
+def upcoming(source, days):
+    """Shows upcoming events from a given calendar file or URL."""
+
+    if source.startswith(("http://", "https://")):
+        events = Calendar.iter_events_from_url(source, upcoming_days=days)
+
+    else:
+        events = Calendar.iter_events_from_file(source, upcoming_days=days)
+
+    for event in events:
+        click.secho(Calendar.event_stringify(event))
+
+
+def main():
+    entry_point(obj={})
+
+
+if __name__ == '__main__':
+    main()

icalendar_light/toolbox.py

@@ -0,0 +1,240 @@
+from collections import namedtuple
+from datetime import datetime, timedelta
+import io
+from functools import partial
+from pathlib import Path
+from urllib.request import urlopen
+from typing import Generator, Union, Iterable
+
+from dateutil.tz import tzlocal
+
+from .casters import cast_date, cast_default, cast_recurrence, cast_int
+
+
+class Calendar:
+
+    _key_map = {
+        'UID': ('uid', None),
+        'SEQUENCE': ('sequence', cast_int),
+        'STATUS': ('status', None),  # CONFIRMED, TENTATIVE, CANCELLED
+        'CREATED': ('dt_created', cast_date),
+        'LAST-MODIFIED': ('dt_modified', cast_date),
+        'DTSTART': ('dt_start', cast_date),
+        'DTEND': ('dt_end', cast_date),
+        'DESCRIPTION': ('description', None),
+        'SUMMARY': ('summary', None),
+        'LOCATION': ('location', None),
+        'RRULE': ('recurrence', cast_recurrence),
+    }
+
+    _event_attrs = [
+        'uid',
+        'sequence',
+        'status',
+        'dt_created',
+        'dt_modified',
+        'dt_start',
+        'dt_end',
+        'description',
+        'summary',
+        'location',
+        'recurrence',
+    ]
+
+    Event = namedtuple('Event', _event_attrs)
+
+    @classmethod
+    def event_stringify(cls, event: Event) -> str:
+        """Create a string representation for an event object.
+
+        :param event:
+
+        """
+        location = event.location
+        if location:
+            location = f' [{location}]'
+
+        status = event.status
+        if status:
+            status = f' [{status}]'
+
+        out = f"{event.dt_start} - {event.dt_end} | {event.summary}{location or ''}{status or ''}"
+
+        return out
+
+    @classmethod
+    def iter_events_from_file(
+        cls,
+        filepath: Union[Path, str],
+        upcoming_days: int | None = None
+    ) -> Generator[Event, None, None]:
+        """Yields event objects from a given file.
+
+        :param filepath:
+        :param upcoming_days:
+
+        """
+        if upcoming_days is None:
+            func = cls.iter_events
+
+        else:
+            func = partial(cls.iter_events_upcoming, days_forward=upcoming_days)
+
+        with Path(f'{filepath}').open() as f:
+            yield from func(f)
+
+    @classmethod
+    def iter_events_from_url(
+        cls,
+        url: str,
+        upcoming_days: int | None = None
+    ) -> Generator[Event, None, None]:
+        """Yields event objects from a given URL.
+
+        :param url:
+        :param upcoming_days:
+
+        """
+        if upcoming_days is None:
+            func = cls.iter_events
+
+        else:
+            func = partial(cls.iter_events_upcoming, days_forward=upcoming_days)
+
+        with io.TextIOWrapper(urlopen(url), encoding="utf-8") as f:
+            yield from func(f)
+
+    @classmethod
+    def iter_events(cls, source: Iterable) -> Generator[Event, None, None]:
+        """Yields event objects from a given source.
+
+        .. note:: This won't yield recurrent events automatically, as `.iter_events_upcoming()` does.
+
+        :param source:
+
+        """
+        def init_event_data():
+            return {}.fromkeys(cls._event_attrs)
+
+        event_data = init_event_data()
+        in_event = False
+        last_key = ''
+
+        shared_params = {
+            'tz': None,
+        }
+
+        cls_event = cls.Event
+        key_map = cls._key_map
+
+        for line in source:
+            line = line.rstrip()
+
+            if line == 'BEGIN:VEVENT':
+                last_key = ''
+                in_event = True
+                event_data = init_event_data()
+                continue
+
+            if line == 'END:VEVENT':
+
+                yield cls_event(**event_data)
+
+                last_key = ''
+                in_event = False
+                continue
+
+            if not in_event:
+
+                if line.startswith('X-WR-TIMEZONE:'):
+                    shared_params['tz'] = line.partition(':')[2]
+
+                continue
+
+            if line.startswith(' '):
+                key = last_key
+                value = line[1:]
+                params = ''  # No params support for continuation.
+
+            else:
+                key, _, value = line.partition(':')
+                key, _, params = key.partition(';')
+
+            last_key = key
+            mapped = key_map.get(key)
+
+            if mapped is None:
+                continue
+
+            mapped_key, func_cast = mapped
+            func_cast = func_cast or cast_default
+
+            value = func_cast(value=value, params=params, shared=shared_params)
+
+            value_seen = event_data[mapped_key]
+
+            if value_seen is None:
+                value_seen = value
+
+            else:
+                # Continuation (folding) support.
+                value_seen = f"{value_seen}{value}"
+
+            event_data[mapped_key] = value_seen
+
+    @classmethod
+    def iter_events_recurrent(cls, *, event: Event, date_max: datetime) -> Generator[Event, None, None]:
+        """Builds and yields recurrent events for a given event till the date.
+
+        :param event:
+        :param date_max:
+
+        """
+        start = event.dt_start
+        end = event.dt_end
+
+        recurred = []
+
+        for recurrent_start in event.recurrence:
+
+            recurrent_start = recurrent_start.replace(
+                hour=start.hour,
+                minute=start.minute,
+                second=start.second,
+                tzinfo=start.tzinfo,
+            )
+
+            recurrent_end = recurrent_start.replace(
+                hour=end.hour,
+                minute=end.minute,
+                second=end.second,
+            )
+
+            recurred.append((recurrent_start, recurrent_end))
+
+            if recurrent_start >= date_max:
+                break
+
+        for recurrent_start, recurrent_end in recurred:
+            yield event._replace(dt_start=recurrent_start, dt_end=recurrent_end)
+
+    @classmethod
+    def iter_events_upcoming(cls, source: Iterable, *, days_forward=30) -> Generator[Event, None, None]:
+        """Yields upcoming event objects from a given source for nex N days.
+
+        .. note:: This will yield recurrent events automatically, in contrast to `.iter_events()`.
+
+        :param source:
+        :param days_forward:
+
+        """
+        now = datetime.now(tzlocal())
+        date_max = now + timedelta(days=days_forward)
+
+        for event in cls.iter_events(source):
+
+            if event.recurrence:
+                yield from cls.iter_events_recurrent(event=event, date_max=date_max)
+
+            elif now <= event.dt_start <= date_max:
+                yield event

icalendar_light-1.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.5
+Name: icalendar_light
+Version: 1.1.0
+Summary: Light and easy iCalendar event reader
+Project-URL: Homepage, https://github.com/idlesign/icalendar_light
+Author-email: Igor Starikov <idlesign@yandex.ru>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: calendar,icalendar,ics
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: python-dateutil
+Provides-Extra: cli
+Requires-Dist: click; extra == 'cli'
+Description-Content-Type: text/markdown
+
+# icalendar_light
+
+<https://github.com/idlesign/icalendar_light>
+
+[![release](https://img.shields.io/pypi/v/icalendar_light.svg)](https://pypi.python.org/pypi/icalendar_light)
+[![lic](https://img.shields.io/pypi/l/icalendar_light.svg)](https://pypi.python.org/pypi/icalendar_light)
+[![coverage](https://img.shields.io/coveralls/idlesign/icalendar_light/master.svg)](https://coveralls.io/r/idlesign/icalendar_light)
+
+## Description
+
+*Light and easy iCalendar event reader*
+
+No fancy stuff, just iCalendar (`.ics`) events reading.
+
+* Uses `namedtuple` for event representation;
+* Features iterative event reading to be fast and minimize memory usage.
+
+## API
+
+```python
+from icalendar_light.toolbox import Calendar
+
+for event in Calendar.iter_events_from_file('my_calendar.ics'):
+    print(Calendar.event_stringify(event))
+
+# Or get events upcoming in next 5 days from iCalendar represented as lines:
+lines = []  # Let's imagine this one is not empty %)
+events = Calendar.iter_events_upcoming(lines, days_forward=5)
+```
+
+## CLI
+
+Requires `click` package (can be installed with: `pip install icalendar_light[cli]`).
+
+```shell
+# Show upcoming event for next 90 days
+$ icalendar_light upcoming my_calendar.ics --days 90
+```

icalendar_light-1.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+icalendar_light/__init__.py,sha256=mLogIM1sYODaWXnpkC3MUaWSWIRVFccFKS3YgKq5rDQ,18
+icalendar_light/casters.py,sha256=jiskWL9kdRLLKyuj7IarfyN3vPK5FhaOufSj7agMnXg,1522
+icalendar_light/cli.py,sha256=FOBBiPqtnZHwkXADwxzQPW-Nf5Y3A5DFj_kdX30_ODg,818
+icalendar_light/toolbox.py,sha256=z3kcJlYc9fWCob2c-HcB1V6WRiLYD1Ds_UXEJpmG5lQ,6508
+icalendar_light-1.1.0.dist-info/METADATA,sha256=Pia-lDhNAkGrgTn4Idf9g4KwkVDrVa8Yk3x-HOsOG1c,2226
+icalendar_light-1.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+icalendar_light-1.1.0.dist-info/entry_points.txt,sha256=1Oo0oNWceK6R5sYKx7GIRFSEDOUcmN3iXpZ5LcuJTzQ,61
+icalendar_light-1.1.0.dist-info/licenses/LICENSE,sha256=59Q1_jlD9UvIPZ31PWvHgYt7nA9NS7xiGMoeb6yzKIc,1508
+icalendar_light-1.1.0.dist-info/RECORD,,

icalendar_light-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

icalendar_light-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+icalendar_light = icalendar_light.cli:main

icalendar_light-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2020-2026, Igor `idle sign` Starikov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the icalendar_light nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+