icalcli 1.0.6__tar.gz → 1.1.2__tar.gz

{icalcli-1.0.6 → icalcli-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icalcli
-Version: 1.0.6
+Version: 1.1.2
 Summary: Icalendar Calendar Command Line Interface
 Home-page: https://github.com/jrvarma/icalcli
 Maintainer: Jayanth R. Varma
@@ -28,7 +28,7 @@ Requires-Dist: parsedatetime; extra == "parsedatetime"
 
 Unlike [gcalcli](https://github.com/insanum/gcalcli) which is tied to Google Calendar, `icalcli` is agnostic to (abstracts away from) the actual backend calendar service. It relies on a backend interface which interacts with the backend calendar to perform all the CRUD (Create, Retrieve, Update and Delete) operations on the actual calendar. The package includes two backends:
 
-* The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar. In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.
+* The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar (versions 1.0 and 2.0). In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.
 
 * The `file_backend` subpackage provides a backend interface to a calendar contained in a local `ics` file. This is useful as a viewer/editor of `ics` files. It is also useful to try out `icalci` without having any other backend configured.
 
@@ -55,6 +55,12 @@ The two included backends would also be useful to those who wish to write their
 pip install icalcli
 ```
 
+or via `pipx`:
+
+```sh
+pipx install icalcli
+```
+
 ### Install from source
 
 ```sh
@@ -62,6 +68,13 @@ git clone https://github.com/jrvarma/icalcli.git
 cd icalcli
 python setup.py install
 ```
+
+or via `pipx`:
+
+```sh
+pipx install . --editable
+```
+
 ## Usage
 
 ### Command line arguments
@@ -102,7 +115,7 @@ backend_interface = ICSInterface(["/path/to/ics-file-1", "/path/to/ics-file-2"])
 
 ```
 
-#### Example configuration for etesync_backend
+#### Example configuration for etesync_backend (etesync 1.0)
 
 This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.
 
@@ -121,6 +134,34 @@ backend_interface = EtesyncInterface(
 ```
 See the [Example code](https://github.com/jrvarma/icalcli/issues/1#issuecomment-979851222) for getting the  `uid` and `authToken` for the `etesync` calendar.
 
+#### Example configuration for etebase_backend (etesync 2.0)
+
+This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.
+
+```
+from icalcli import EtebaseInterface
+import json
+
+conf_file = '/path/to/json-file'
+with open(conf_file, 'r') as fp:
+    c = json.load(fp)
+
+backend_interface = EtebaseInterface(c['user'], c['server_url'], c['password'],
+                                     c['calendar_uid'], silent=False)
+```
+
+The `calendar_uid` can be obtained using the following code. This code assumes that the `dict c` has been populated with the credentials from the `json` file as above.
+
+```
+from etebase import Client, Account, FetchOptions
+
+client = Client(c['user'], c['server_url'])
+etebase = Account.login(client, c['user'], c['password'])
+col_mgr = etebase.get_collection_manager()
+print({col.uid: col.meta
+      for col in col_mgr.list("etebase.vevent").data})
+```
+
 ## Recurring events and default search period
 
 `icalcli` understands the `RRULE`, `RDATE`, `EXRULE`, `EXDATE` elements of the `icalendar` specification. These elements can be added while creating or editing events using `--rrule`, `--rdate`, `--exrule` and `--exdate` options.

{icalcli-1.0.6 → icalcli-1.1.2}/README.md

@@ -6,7 +6,7 @@
 
 Unlike [gcalcli](https://github.com/insanum/gcalcli) which is tied to Google Calendar, `icalcli` is agnostic to (abstracts away from) the actual backend calendar service. It relies on a backend interface which interacts with the backend calendar to perform all the CRUD (Create, Retrieve, Update and Delete) operations on the actual calendar. The package includes two backends:
 
-* The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar. In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.
+* The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar (versions 1.0 and 2.0). In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.
 
 * The `file_backend` subpackage provides a backend interface to a calendar contained in a local `ics` file. This is useful as a viewer/editor of `ics` files. It is also useful to try out `icalci` without having any other backend configured.
 
@@ -33,6 +33,12 @@ The two included backends would also be useful to those who wish to write their
 pip install icalcli
 ```
 
+or via `pipx`:
+
+```sh
+pipx install icalcli
+```
+
 ### Install from source
 
 ```sh
@@ -40,6 +46,13 @@ git clone https://github.com/jrvarma/icalcli.git
 cd icalcli
 python setup.py install
 ```
+
+or via `pipx`:
+
+```sh
+pipx install . --editable
+```
+
 ## Usage
 
 ### Command line arguments
@@ -80,7 +93,7 @@ backend_interface = ICSInterface(["/path/to/ics-file-1", "/path/to/ics-file-2"])
 
 ```
 
-#### Example configuration for etesync_backend
+#### Example configuration for etesync_backend (etesync 1.0)
 
 This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.
 
@@ -99,6 +112,34 @@ backend_interface = EtesyncInterface(
 ```
 See the [Example code](https://github.com/jrvarma/icalcli/issues/1#issuecomment-979851222) for getting the  `uid` and `authToken` for the `etesync` calendar.
 
+#### Example configuration for etebase_backend (etesync 2.0)
+
+This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.
+
+```
+from icalcli import EtebaseInterface
+import json
+
+conf_file = '/path/to/json-file'
+with open(conf_file, 'r') as fp:
+    c = json.load(fp)
+
+backend_interface = EtebaseInterface(c['user'], c['server_url'], c['password'],
+                                     c['calendar_uid'], silent=False)
+```
+
+The `calendar_uid` can be obtained using the following code. This code assumes that the `dict c` has been populated with the credentials from the `json` file as above.
+
+```
+from etebase import Client, Account, FetchOptions
+
+client = Client(c['user'], c['server_url'])
+etebase = Account.login(client, c['user'], c['password'])
+col_mgr = etebase.get_collection_manager()
+print({col.uid: col.meta
+      for col in col_mgr.list("etebase.vevent").data})
+```
+
 ## Recurring events and default search period
 
 `icalcli` understands the `RRULE`, `RDATE`, `EXRULE`, `EXDATE` elements of the `icalendar` specification. These elements can be added while creating or editing events using `--rrule`, `--rdate`, `--exrule` and `--exdate` options.

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli/__init__.py

@@ -4,7 +4,9 @@ __author__ = 'Jayanth Varma (modified gcalcli by Eric Davis et al.)'
 from icalcli.icalcli import IcalendarInterface  # noqa F401
 try:
     from icalcli.etesync_backend.etesync_crud import EtesyncCRUD  # noqa F401
-    from icalcli.etesync_backend.etesync_interface import EtesyncInterface  # noqa F401
+    from icalcli.etesync_backend.etesync_interface import EtesyncInterface  # noqa F
+    from icalcli.etesync_backend.etebase_crud import EtebaseCRUD  # noqa F401
+    from icalcli.etesync_backend.etebase_interface import EtebaseInterface  # noqa F401
 except ImportError:
     pass
 

icalcli-1.1.2/icalcli/etesync_backend/etebase_crud.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+
+# this is part of the etesync 2.0 backend
+# for etesync 1.0 backend see etesync_crud.py
+
+from etebase import Client, Account, FetchOptions, Base64Url
+from time import sleep, time
+import json
+
+# The EtesyncCRUD class exposes methods for each of the CRUD operations
+# (Create, Retrieve, Update and Delete) and for sync with the server.
+# It handles only one calendar
+
+# The class is initialized with user details, authToken and
+# EITHER the encryption password OR the cipher key.
+
+# Intended usage is that a calling program (a CLI) obtains user credentials
+# from terminal input or some secure storage (like a key ring)
+# and then creates an instance of EtesyncCRUD as follows:
+
+# crud = EtebaseCRUD(user, server_url, password, calendar_uid)
+
+# The CLI program can then perform CRUD operations by calling
+# crud.create_event, crud.retrieve_event,
+# crud.update_event and crud.delete_event
+
+# The CLI must explicitly call crud.sync when needed. For example:
+# (a) if the server has been updated from another device
+# (b) after any CRUD operation other than Retrieve
+
+# No exception handling is done. That is left to the CLI.
+
+
+class EtebaseCRUD:
+
+    def __init__(self, user, server_url, password, calendar_uid,
+                 cache_file=None, silent=True):
+        """Initialize
+
+        Parameters
+        ----------
+        user : etebase username
+        password : etebase password
+        server_url : url of etebase server
+        calendar_uid : uid of calendar
+        cache_file: path to the cache file or None
+        """
+        client = Client(user, server_url)
+        etebase = Account.login(client, user, password)
+        col_mgr = etebase.get_collection_manager()
+        collection = col_mgr.fetch(calendar_uid)
+        self.item_mgr = col_mgr.get_item_manager(collection)
+        self.items = {}
+        self.stoken = None
+        self.raw_events = []
+        self.cache_file = cache_file
+        self.load_cache()
+        self.sync(silent)
+        print("Reading all events")
+        self.get_all_events()
+
+    def create_event(self, event, event_uid):
+        """Create event
+
+        Parameters
+        ----------
+        event : iCalendar file as bytes
+        (calendar containing one event to be added)
+        event_uid : uid of event to be updated
+        """
+        item = self.item_mgr.create(
+            {
+                "name": event_uid,
+                "mtime": int(round(time() * 1000))
+            },
+            event
+        )
+        self.item_mgr.batch([item])
+
+    def update_event(self, event, event_uid):
+        """Edit event
+
+        Parameters
+        ----------
+        event : iCalendar file as bytes
+        (calendar containing one event to be updated)
+        event_uid : uid of event to be updated
+        """
+        item = self.item_mgr.fetch(self.event_uid_to_item_uid[event_uid])
+        assert item.meta['name'] == event_uid
+        item.content = event
+        # item.meta["mtime"] = int(round(time() * 1000))
+        self.item_mgr.batch([item])
+
+    def retrieve_event(self, event_uid):
+        r"""Retrieve event by uid
+
+        Parameters
+        ----------
+        event_uid : uid of event to be retrieved
+
+        Returns
+        -------
+        iCalendar file (as a string)
+        """
+        item = self.item_mgr.fetch(self.event_uid_to_item_uid[event_uid])
+        assert item.meta['name'] == event_uid
+        return item.content.decode()
+
+    def delete_event(self, event_uid):
+        """Delete event and sync calendar
+
+        Parameters
+        ----------
+        uid : uid of event to be deleted
+        """
+        item = self.item_mgr.fetch(self.event_uid_to_item_uid[event_uid])
+        assert item.meta['name'] == event_uid
+        item.meta["mtime"] = int(round(time() * 1000))
+        item.delete()
+        self.item_mgr.batch([item])
+
+    def get_all_events(self):
+        """Retrieve all events in calendar
+
+        Returns
+        -------
+        List of iCalendar files (as strings)
+        """
+        self.event_uid_to_item_uid = {
+            e.meta['name']: e.uid for e in self.items.values()}
+        self.raw_events = [e.content.decode()
+                           for e in self.items.values() if not e.deleted]
+
+    def sync(self, silent=False):
+        """Initialize
+
+        Parameters
+        ----------
+        silent : boolean whether to report sync attempt and success
+        """
+        silent or print("Syncing with server. Please wait")
+        msg = "etebase fetch attempt {:} failed. Will retry after {:} seconds"
+        delay = 5
+        done = False
+        chunk = 100
+        for i in range(5):
+            try:
+                while not done:
+                    items = self.item_mgr.list(
+                        FetchOptions().stoken(self.stoken).limit(chunk))
+                    self.items.update(
+                        {item.uid: item for item in items.data})
+                    self.stoken = items.stoken
+                    done = items.done
+                    # silent or print(".", end='')
+                break
+            except Exception:
+                silent or print(msg.format(i+1, delay))
+                sleep(delay)
+        if done:
+            silent or print("Syncing completed.")
+            self.save_cache()
+        else:
+            print("Syncing with server failed after 5 attempts")
+        return
+
+    def load_cache(self):
+        if self.cache_file:
+            d = json.load(open(self.cache_file))
+            if 'stoken' in d:
+                self.stoken = d['stoken']
+            if 'blobs' in d:
+                for cache_blob in d['blobs']:
+                    item = self.item_mgr.cache_load(
+                        Base64Url.from_base64(cache_blob))
+                    self.items[item.uid] = item
+
+    def save_cache(self):
+        if self.cache_file:
+            cache = dict(
+                stoken=self.stoken,
+                blobs=[Base64Url.to_base64(self.item_mgr.cache_save(item))
+                       for item in self.items.values()])
+            json.dump(cache, open(self.cache_file, 'w'))

icalcli-1.1.2/icalcli/etesync_backend/etebase_interface.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+# this is part of the etesync 2.0 backend
+# for etesync 1.0 backend see etesync_interface.py
+
+from icalcli.etesync_backend.etebase_crud import EtebaseCRUD
+from icalendar import Calendar
+
+
+# The EtebaseInterface class is basically a wrapper around the
+# EtebaseCRUD class from which it is derived
+# The CRUD operations (Create, Retrieve, Update and Delete)
+# work with icalendar events (VEVENT). While calling EtebaseCRUD methods,
+# both inputs and return values are converted to/from
+# ics calendar bytes/strings
+
+# The class is initialized with user details and credentials.
+
+# Intended usage is that a calling program obtains user credentials
+# from terminal input or some secure storage (like a key ring)
+# and then creates an instance of EtebaseCRUD as follows:
+
+# etes = EtebaseInterface(user, server_url, password, calendar_uid)
+
+# The calling program can then perform CRUD operations by calling
+# etes.create_event, etes.retrieve_event,
+# etes.update_event and etes.delete_event
+
+# The calling program must explicitly call sync() when the server
+# has been updated from another device
+# sync() is not needed after any CRUD operation
+
+# No exception handling is done. That is left to the calling program.
+
+
+class EtebaseInterface (EtebaseCRUD):
+    def __init__(self, user, server_url, password, calendar_uid,
+                 cache_file=None, silent=True):
+        r"""Initialize EtebaseInterface
+
+        Parameters
+        ----------
+        user : etebase username
+        password : etebase password
+        server_url : url of etebase server
+        calendar_uid : uid of calendar
+        """
+        super(EtebaseInterface, self).__init__(
+            user=user, server_url=server_url, password=password,
+            calendar_uid=calendar_uid, cache_file=cache_file, silent=silent)
+        print("Parsing all events")
+        self.all_events()
+
+    def all_events(self):
+        self.events = [Calendar.from_ical(ev).walk('VEVENT')[0]
+                       for ev in self.raw_events]
+
+    def create_event(self, event, vtimezone=None):
+        r"""Create event
+
+        Parameters
+        ----------
+        event : event to be added (iCalendar object)
+        """
+        ics = self.event_to_ics(event, vtimezone)
+        uid = event.decoded('uid').decode()
+        EtebaseCRUD.create_event(self, ics, uid)
+
+    def update_event(self, event, vtimezone=None):
+        r"""Update event
+
+        Parameters
+        ----------
+        event : event to be added (iCalendar object)
+        """
+        uid = event.decoded('uid').decode()
+        ics = self.event_to_ics(event, vtimezone)
+        EtebaseCRUD.update_event(self, ics, uid)
+
+    def event_to_ics(self, event, vtimezone=None):
+        r"""Make calendar byte array (ics) from event
+
+        Parameters
+        ----------
+        event : event to be added (iCalendar object)
+        """
+        cal = Calendar()
+        cal.add_component(event)
+        if vtimezone:
+            cal.add_component(vtimezone)
+        ics = cal.to_ical()
+        return ics
+
+    def sync(self, vtimezone=None):
+        r"""Sync with server and rebuild vevent list
+        """
+        EtebaseCRUD.sync(self)
+        self.all_events()

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli/etesync_backend/etesync_crud.py

@@ -1,5 +1,8 @@
 #!/usr/bin/env python
 
+# this is part of the etesync 1.0 backend
+# for etesync 2.0 backend see etebase_crud.py
+
 import etesync as api
 from time import sleep
 

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli/etesync_backend/etesync_interface.py

@@ -1,3 +1,8 @@
+#!/usr/bin/env python
+
+# this is part of the etesync 1.0 backend
+# for etesync 2.0 backend see etebase_interface.py
+
 from icalcli.etesync_backend.etesync_crud import EtesyncCRUD
 from icalendar import Calendar
 

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli/file_backend/ics_interface.py

@@ -61,9 +61,9 @@ class ICSInterface:
             return
         if self.backup:
             with NamedTemporaryFile(mode='w',
-                                    suffix=self.filepath.suffix,
-                                    prefix=self.filepath.name,
-                                    dir=self.filepath.parent,
+                                    suffix=self.filepaths[0].suffix,
+                                    prefix=self.filepaths[0].name,
+                                    dir=self.filepaths[0].parent,
                                     delete=False) as fp:
                 fp.write(self.ics)
         cal = Calendar()
@@ -72,6 +72,6 @@ class ICSInterface:
         if vtimezone:
             cal.add_component(vtimezone)
         self.ics = cal.to_ical().decode()
-        with open(self.filepath, 'w') as fp:
+        with open(self.filepaths[0], 'w') as fp:
             fp.write(self.ics)
         self.all_events()

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli/icalcli.py

@@ -1317,7 +1317,8 @@ class IcalendarInterface:
                         continue
                 self.backend_interface.delete_event(self.uid(event))
                 self.printer.msg("Event deleted\n")
-                self.backend_cache_dirty = True
+                if self.backend_interface.sync_after_edit:
+                    self.backend_cache_dirty = True
                 deleted += 1
             self.printer.msg(f'{deleted} events deleted\n')
 
@@ -1606,7 +1607,8 @@ class IcalendarInterface:
         self.printer.msg("Event %s\n" % ("updated" if old
                                          else "added"))
         self.iterate_events(None, [event], print_count=False)
-        self.backend_cache_dirty = True
+        if self.backend_interface.sync_after_edit:
+            self.backend_cache_dirty = True
         return True
 
     def raw_ics(self, original=None):
@@ -1721,6 +1723,14 @@ def repl(ecal=None):
             add_parser=get_add_parser(),
             backend_interface=config.backend_interface,
             printer=printer, **vars(FLAGS))
+        if not hasattr(ecal.backend_interface, "sync_after_edit"):
+            ecal.backend_interface.sync_after_edit = True
+            # The file and etesync 1.0 backends operate on the cache and
+            # they sync to server only when sync() is called
+            # Some backends may work directly on server
+            # and may require sync() only if server updated from another device
+            # Such backends can set the attribute sync_after_edit = False
+            # If attribute is missing, we assume it is True
         if hasattr(config, 'timezones') and 'tz' in config.timezones:
             IcalendarInterface.calendar_tz = config.timezones['tz']
         else:

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: icalcli
-Version: 1.0.6
+Version: 1.1.2
 Summary: Icalendar Calendar Command Line Interface
 Home-page: https://github.com/jrvarma/icalcli
 Maintainer: Jayanth R. Varma
@@ -28,7 +28,7 @@ Requires-Dist: parsedatetime; extra == "parsedatetime"
 
 Unlike [gcalcli](https://github.com/insanum/gcalcli) which is tied to Google Calendar, `icalcli` is agnostic to (abstracts away from) the actual backend calendar service. It relies on a backend interface which interacts with the backend calendar to perform all the CRUD (Create, Retrieve, Update and Delete) operations on the actual calendar. The package includes two backends:
 
-* The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar. In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.
+* The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar (versions 1.0 and 2.0). In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.
 
 * The `file_backend` subpackage provides a backend interface to a calendar contained in a local `ics` file. This is useful as a viewer/editor of `ics` files. It is also useful to try out `icalci` without having any other backend configured.
 
@@ -55,6 +55,12 @@ The two included backends would also be useful to those who wish to write their
 pip install icalcli
 ```
 
+or via `pipx`:
+
+```sh
+pipx install icalcli
+```
+
 ### Install from source
 
 ```sh
@@ -62,6 +68,13 @@ git clone https://github.com/jrvarma/icalcli.git
 cd icalcli
 python setup.py install
 ```
+
+or via `pipx`:
+
+```sh
+pipx install . --editable
+```
+
 ## Usage
 
 ### Command line arguments
@@ -102,7 +115,7 @@ backend_interface = ICSInterface(["/path/to/ics-file-1", "/path/to/ics-file-2"])
 
 ```
 
-#### Example configuration for etesync_backend
+#### Example configuration for etesync_backend (etesync 1.0)
 
 This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.
 
@@ -121,6 +134,34 @@ backend_interface = EtesyncInterface(
 ```
 See the [Example code](https://github.com/jrvarma/icalcli/issues/1#issuecomment-979851222) for getting the  `uid` and `authToken` for the `etesync` calendar.
 
+#### Example configuration for etebase_backend (etesync 2.0)
+
+This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.
+
+```
+from icalcli import EtebaseInterface
+import json
+
+conf_file = '/path/to/json-file'
+with open(conf_file, 'r') as fp:
+    c = json.load(fp)
+
+backend_interface = EtebaseInterface(c['user'], c['server_url'], c['password'],
+                                     c['calendar_uid'], silent=False)
+```
+
+The `calendar_uid` can be obtained using the following code. This code assumes that the `dict c` has been populated with the credentials from the `json` file as above.
+
+```
+from etebase import Client, Account, FetchOptions
+
+client = Client(c['user'], c['server_url'])
+etebase = Account.login(client, c['user'], c['password'])
+col_mgr = etebase.get_collection_manager()
+print({col.uid: col.meta
+      for col in col_mgr.list("etebase.vevent").data})
+```
+
 ## Recurring events and default search period
 
 `icalcli` understands the `RRULE`, `RDATE`, `EXRULE`, `EXDATE` elements of the `icalendar` specification. These elements can be added while creating or editing events using `--rrule`, `--rdate`, `--exrule` and `--exdate` options.

{icalcli-1.0.6 → icalcli-1.1.2}/icalcli.egg-info/SOURCES.txt

@@ -13,6 +13,8 @@ icalcli.egg-info/entry_points.txt
 icalcli.egg-info/requires.txt
 icalcli.egg-info/top_level.txt
 icalcli/etesync_backend/__init__.py
+icalcli/etesync_backend/etebase_crud.py
+icalcli/etesync_backend/etebase_interface.py
 icalcli/etesync_backend/etesync_crud.py
 icalcli/etesync_backend/etesync_interface.py
 icalcli/file_backend/__init__.py

{icalcli-1.0.6 → icalcli-1.1.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
     long_description = fh.read()
 
 setup(name='icalcli',
-      version='1.0.6',
+      version='1.1.2',
       maintainer='Jayanth R. Varma',
       maintainer_email='jrvarma@gmail.com',
       description='Icalendar Calendar Command Line Interface',