Bump jinja2 from 3.1.3 to 3.1.4

Bumps [jinja2](https://github.com/pallets/jinja) from 3.1.3 to 3.1.4.
- [Release notes](https://github.com/pallets/jinja/releases)
- [Changelog](https://github.com/pallets/jinja/blob/main/CHANGES.rst)
- [Commits](https://github.com/pallets/jinja/compare/3.1.3...3.1.4)

---
updated-dependencies:
- dependency-name: jinja2
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

.git_archival.txt

@@ -1 +0,0 @@
-ref-names: $Format:%D$

.gitattributes

@@ -1 +0,0 @@
-.git_archival.txt  export-subst

.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+- package-ecosystem: pip
+  directory: "/"
+  schedule:
+    interval: monthly
+    time: '02:00'
+  open-pull-requests-limit: 10
+  target-branch: develop

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,33 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [develop, ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [develop]
+  schedule:
+    - cron: '0 12 10 * *'
+
+jobs:
+  analyse:
+    name: Analyse
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      # Override language selection by uncommenting this and choosing your languages
+      with:
+        languages: python
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/pythonpackage.yml

@@ -13,30 +13,47 @@ on:
 jobs:
   build:
 
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
     strategy:
       max-parallel: 4
       matrix:
-        python-version: [3.5, 3.6, 3.7, 3.8]
+        python-version: ['3.9', '3.10', '3.11', '3.12']
 
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r requirements.txt
+    - name: Upgrade pip
+      run: python -m pip install --upgrade pip
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Install deps
+      run: poetry install --with dev
     - name: Lint with flake8
       run: |
-        pip install flake8
         # stop the build if there are Python syntax errors or undefined names
-        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        poetry run flake8 sync_ics2gcal --count --select=E9,F63,F7,F82 --show-source --statistics
         # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        poetry run flake8 sync_ics2gcal --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
     - name: Test with pytest
+      run: poetry run pytest -v
+
+    - name: Check type annotations with mypy
       run: |
-        pip install pytest
-        pytest -v
+        mkdir mypy_report
+        poetry run mypy --pretty --html-report mypy_report/ .
+
+    - name: Check type annotations with mypy strict mode (not failing)
+      run: |
+        poetry run mypy --strict --pretty . || true
+
+    - name: Check formatting with black
+      run: poetry run black --check --diff --color .
+
+    - name: Upload mypy report
+      uses: actions/upload-artifact@v2
+      with:
+        name: mypy_report
+        path: mypy_report/

.github/workflows/pythonpublish.yml

@@ -8,19 +8,21 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Python
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v2
       with:
         python-version: '3.x'
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install setuptools setuptools_scm setuptools_scm_git_archive wheel twine
-    - name: Build and publish
+    - name: Upgrade pip
+      run: python -m pip install --upgrade pip
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Install deps
+      run: poetry install --with dev
+    - name: Build
+      run: poetry build
+    - name: Publish
       env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.pypi_token }}
+        POETRY_PYPI_TOKEN_PYPI: ${{ secrets.pypi_token }}
       run: |
-        python setup.py sdist bdist_wheel
-        twine upload dist/*
+        poetry publish -n

.github/workflows/reviewdog.yml

@@ -0,0 +1,49 @@
+name: reviewdog
+
+on:
+  pull_request:
+    branches:
+    - master
+    - develop
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.x
+
+    - name: Upgrade pip
+      run: python -m pip install --upgrade pip
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+
+    - name: Install deps
+      run: poetry install --with dev
+
+    - name: setup mypy
+      run: |
+        mkdir tmp_bin/
+        echo "#!/bin/sh" > tmp_bin/mypy
+        echo "poetry run mypy \$@" >> tmp_bin/mypy
+        chmod +x tmp_bin/mypy
+        echo "$(pwd)/tmp_bin" >> $GITHUB_PATH
+
+    - uses: tsuyoshicho/action-mypy@v3
+      with:
+       reporter: github-pr-review
+       level: warning
+
+    - name: format with black
+      run: poetry run black .
+
+    - name: suggester / black
+      uses: reviewdog/action-suggester@v1
+      with:
+        tool_name: black

.gitignore

@@ -2,8 +2,17 @@ config.yml
 service-account.json
 *.pyc
 my-test*.ics
-.vscode/*
+.vscode/
+.idea/
+.venv/
+.pytest_cache/
+.mypy_cache/
 /dist/
 /*.egg-info/
 /build/
 /.eggs/
+venv/
+mypy_report/
+tmp_bin/
+docs/build/
+

.readthedocs.yml

@@ -0,0 +1,16 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+  jobs:
+    post_create_environment:
+      - pip install poetry
+    post_install:
+      # VIRTUAL_ENV needs to be set manually for now.
+      # See https://github.com/readthedocs/readthedocs.org/pull/11152/
+      - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH poetry install --with docs
+
+sphinx:
+  configuration: docs/source/conf.py

.travis.yml

@@ -1,10 +0,0 @@
-language: python
-
-python:
-  - "3.5"
-  - "3.6"
-  - "3.7"
-  - "3.8"
-
-script:
-  - pytest -v

MANIFEST.in

@@ -1,7 +0,0 @@
-include pyproject.toml
-
-# Include the README
-include *.md
-
-# Include the license file
-include LICENSE

README.md

@@ -1,10 +1,8 @@
 # sync_ics2gcal
 
 [![PyPI version](https://badge.fury.io/py/sync-ics2gcal.svg)](https://badge.fury.io/py/sync-ics2gcal)
-[![Build Status](https://travis-ci.org/b4tman/sync_ics2gcal.svg?branch=master)](https://travis-ci.org/b4tman/sync_ics2gcal)
-[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=b4tman/sync_ics2gcal)](https://dependabot.com)
-[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fb4tman%2Fsync_ics2gcal.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fb4tman%2Fsync_ics2gcal?ref=badge_shield)
 ![Python package status](https://github.com/b4tman/sync_ics2gcal/workflows/Python%20package/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/sync-ics2gcal/badge/?version=latest)](https://sync-ics2gcal.readthedocs.io/en/latest/?badge=latest)
 
 Python scripts for sync .ics file with Google calendar
 
@@ -12,21 +10,26 @@ Python scripts for sync .ics file with Google calendar
 
 To install from [PyPI](https://pypi.org/project/sync-ics2gcal/) with [pip](https://pypi.python.org/pypi/pip), run:
 
-```
+```sh
 pip install sync-ics2gcal
 ```
 
+Or download source code and install using poetry:
 
-Or download source code and install:
-
-```
-python setup.py install
+```sh
+# install poetry
+pip install poetry
+# install project and deps to virtualenv
+poetry install
+# run
+poetry run sync-ics2gcal
 ```
 
 ## Configuration
 
 ### Create application in Google API Console
-1. Create a new project: https://console.developers.google.com/project
+
+1. Create a new project: [console.developers.google.com/project](https://console.developers.google.com/project)
 2. Choose the new project from the top right project dropdown (only if another project is selected)
 3. In the project Dashboard, choose "Library"
 4. Find and Enable "Google Calendar API"
@@ -38,15 +41,20 @@ python setup.py install
 10. Edit service account and click "Create key", choose JSON and download key file.
 
 ### Create working directory
+
 For example: `/home/user/myfolder`.
+
 1. Save service account key in file `service-account.json`.
 2. Download [sample config](https://github.com/b4tman/sync_ics2gcal/blob/develop/sample-config.yml) and save to file `config.yml`. For example:
-```
+
+```sh
 wget https://raw.githubusercontent.com/b4tman/sync_ics2gcal/develop/sample-config.yml -O config.yml
 ```
+
 3. *(Optional)* Place source `.ics` file, `my-calendar.ics` for example.
 
 ### Configuration parameters
+
 * `start_from` - start date:
   * full format datetime, `2018-04-03T13:23:25.000001Z` for example
   * or just `now`
@@ -55,36 +63,41 @@ wget https://raw.githubusercontent.com/b4tman/sync_ics2gcal/develop/sample-confi
 * `google_id` - target google calendar id, `my-calendar@group.calendar.google.com` for example
 * `source` - source `.ics` filename, `my-calendar.ics` for example
 
-
 ## Usage
 
 ### Manage calendars
 
-```
-manage-ics2gcal <subcommand> [-h] [options]
+```sh
+manage-ics2gcal GROUP | COMMAND
 ```
 
-subcomands:
+**GROUPS**:
+
+* **property** - get/set properties (see [CalendarList resource](https://developers.google.com/calendar/v3/reference/calendarList#resource)), subcommands:
+  - **get** - get calendar property
+  - **set** - set calendar property
+
+**COMMANDS**:
+
 * **list** - list calendars
 * **create** - create calendar
 * **add_owner** - add owner to calendar
 * **remove** - remove calendar
 * **rename** - rename calendar
 
+
 Use **-h** for more info.
 
 ### Sync calendar
 
 just type:
-```
+
+```sh
 sync-ics2gcal
 ```
 
-
 ## How it works
 
 ![How it works](how-it-works.png)
 
-
-## License
-[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fb4tman%2Fsync_ics2gcal.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fb4tman%2Fsync_ics2gcal?ref=badge_large)
+Documentation is available at [sync-ics2gcal.readthedocs.io](https://sync-ics2gcal.readthedocs.io).

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= poetry run sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=poetry run sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/source/conf.py

@@ -0,0 +1,40 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+import importlib
+from typing import List
+
+
+project = "sync_ics2gcal"
+copyright = "2023, b4tman"
+author = "b4tman"
+version = importlib.metadata.version("sync_ics2gcal")
+release = version
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "myst_parser",
+    "sphinx.ext.autodoc",
+    "sphinx_design",
+    "sphinx.ext.viewcode",
+    "sphinx_copybutton",
+    "sphinx.ext.githubpages",
+]
+
+templates_path = ["_templates"]
+exclude_patterns: List[str] = []
+
+source_suffix = [".rst", ".md"]
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "sphinx_rtd_theme"
+html_static_path = ["_static"]

docs/source/index.rst

@@ -0,0 +1,22 @@
+.. sync_ics2gcal documentation master file, created by
+   sphinx-quickstart on Sat Aug 20 22:19:59 2023.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to sync_ics2gcal's documentation!
+=========================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+   
+   readme_link
+   reference
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

docs/source/modules.rst

@@ -0,0 +1,7 @@
+sync_ics2gcal
+=============
+
+.. toctree::
+   :maxdepth: 4
+
+   sync_ics2gcal

docs/source/readme_link.md

@@ -0,0 +1,3 @@
+```{include} ../../README.md
+```
+

docs/source/reference.rst

@@ -0,0 +1,6 @@
+-------------
+Reference
+-------------
+
+.. include:: modules.rst
+

docs/source/sync_ics2gcal.rst

@@ -0,0 +1,53 @@
+sync\_ics2gcal package
+======================
+
+Submodules
+----------
+
+sync\_ics2gcal.gcal module
+--------------------------
+
+.. automodule:: sync_ics2gcal.gcal
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+sync\_ics2gcal.ical module
+--------------------------
+
+.. automodule:: sync_ics2gcal.ical
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+sync\_ics2gcal.manage\_calendars module
+---------------------------------------
+
+.. automodule:: sync_ics2gcal.manage_calendars
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+sync\_ics2gcal.sync module
+--------------------------
+
+.. automodule:: sync_ics2gcal.sync
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+sync\_ics2gcal.sync\_calendar module
+------------------------------------
+
+.. automodule:: sync_ics2gcal.sync_calendar
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Module contents
+---------------
+
+.. automodule:: sync_ics2gcal
+   :members:
+   :undoc-members:
+   :show-inheritance:

pyproject.toml

@@ -1,3 +1,67 @@
+[tool.poetry]
+name = "sync_ics2gcal"
+version = "0.1.4"
+description = "Sync ics file with Google calendar"
+authors = ["Dmitry Belyaev <b4tm4n@mail.ru>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/b4tman/sync_ics2gcal"
+repository = "https://github.com/b4tman/sync_ics2gcal"
+keywords = ["icalendar", "sync", "google", "calendar"]
+classifiers = [
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: OS Independent',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+google-auth = "2.29.0"
+google-api-python-client = "2.127.0"
+icalendar = "5.0.12"
+pytz = "2024.1"
+PyYAML = "6.0.1"
+fire = "0.6.0"
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.docs]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=7.4,<9.0"
+flake8 = ">=5.0.4,<8.0.0"
+black = ">=23.7,<25.0"
+mypy = ">=0.960"
+types-python-dateutil = "^2.8.19"
+types-pytz = ">=2021.3.8"
+types-PyYAML = "^6.0.12"
+lxml = ">=4.9.3,<6.0.0"
+
+[tool.poetry.group.docs.dependencies]
+sphinx = ">=7.1,<7.4"
+myst-parser = ">=2,<4"
+sphinx-rtd-theme = ">=1.2.2,<3.0.0"
+sphinx-copybutton = "^0.5.2"
+sphinx-design = "^0.5.0"
+
+[tool.poetry.scripts]
+sync-ics2gcal = "sync_ics2gcal.sync_calendar:main"
+manage-ics2gcal = "sync_ics2gcal.manage_calendars:main"
+
 [build-system]
-requires = ["setuptools>=40.8.0", "wheel", "setuptools_scm"]
-build-backend = "setuptools.build_meta"
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[[tool.mypy.overrides]]
+module = [
+    'icalendar',
+    'google.*',
+    'googleapiclient',
+    'fire'
+]
+ignore_missing_imports = true

requirements.txt

@@ -1,5 +0,0 @@
-google-auth==1.11.0
-google-api-python-client==1.7.11
-icalendar==4.0.4
-pytz==2019.3
-PyYAML==5.3

setup.cfg

@@ -1,7 +0,0 @@
-[metadata]
-license_files = LICENSE
-
-[options]
-setup_requires =
-  setuptools_scm
-  setuptools_scm_git_archive

setup.py

@@ -1,44 +0,0 @@
-import setuptools
-
-with open('README.md', 'r') as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name='sync-ics2gcal',
-    author='Dmitry Belyaev',
-    author_email='b4tm4n@mail.ru',
-    license='MIT',
-    description='Sync ics file with Google calendar',
-    long_description=long_description,
-    long_description_content_type='text/markdown',
-    url='https://github.com/b4tman/sync_ics2gcal',
-    use_scm_version={
-        'fallback_version': '0.1',
-        'local_scheme': 'no-local-version'
-    },
-    setup_requires=['setuptools_scm', 'setuptools_scm_git_archive'],
-    packages=setuptools.find_packages(exclude=['tests']),
-    classifiers=[
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: OS Independent',
-
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-    ],
-    python_requires='>=3.5',
-    install_requires = [
-        'google-auth>=1.5.0',
-        'google-api-python-client>=1.7.0',
-        'icalendar>=4.0.1',
-        'pytz',
-        'PyYAML>=3.13'
-    ],
-    entry_points={
-        "console_scripts": [
-            "sync-ics2gcal = sync_ics2gcal.sync_calendar:main",
-            "manage-ics2gcal = sync_ics2gcal.manage_calendars:main",
-        ]
-    }
-)

sync_ics2gcal/__init__.py

@@ -1,14 +1,44 @@
-
-from .ical import (
-    CalendarConverter,
-    EventConverter
-)
+from .ical import CalendarConverter, EventConverter, DateDateTime
 
 from .gcal import (
     GoogleCalendarService,
-    GoogleCalendar
+    GoogleCalendar,
+    EventData,
+    EventList,
+    EventTuple,
+    EventDataKey,
+    EventDateOrDateTime,
+    EventDate,
+    EventDateTime,
+    EventsSearchResults,
+    ACLRule,
+    ACLScope,
+    CalendarData,
+    BatchRequestCallback,
 )
 
-from .sync import (
-    CalendarSync
-)
+from .sync import CalendarSync, ComparedEvents
+
+__all__ = [
+    "ical",
+    "gcal",
+    "sync",
+    "CalendarConverter",
+    "EventConverter",
+    "DateDateTime",
+    "GoogleCalendarService",
+    "GoogleCalendar",
+    "EventData",
+    "EventList",
+    "EventTuple",
+    "EventDataKey",
+    "EventDateOrDateTime",
+    "EventDate",
+    "EventDateTime",
+    "EventsSearchResults",
+    "ACLRule",
+    "ACLScope",
+    "CalendarData",
+    "CalendarSync",
+    "ComparedEvents",
+]

sync_ics2gcal/gcal.py

@@ -1,5 +1,17 @@
 import logging
-import sys
+from datetime import datetime
+from typing import (
+    List,
+    Dict,
+    Any,
+    Callable,
+    Tuple,
+    Optional,
+    Union,
+    TypedDict,
+    Literal,
+    NamedTuple,
+)
 
 import google.auth
 from google.oauth2 import service_account
@@ -7,7 +19,80 @@ from googleapiclient import discovery
 from pytz import utc
 
 
-class GoogleCalendarService():
+class EventDate(TypedDict, total=False):
+    date: str
+    timeZone: str
+
+
+class EventDateTime(TypedDict, total=False):
+    dateTime: str
+    timeZone: str
+
+
+EventDateOrDateTime = Union[EventDate, EventDateTime]
+
+
+class ACLScope(TypedDict, total=False):
+    type: str
+    value: str
+
+
+class ACLRule(TypedDict, total=False):
+    scope: ACLScope
+    role: str
+
+
+class CalendarData(TypedDict, total=False):
+    id: str
+    summary: str
+    description: str
+    timeZone: str
+
+
+class EventData(TypedDict, total=False):
+    id: str
+    summary: str
+    description: str
+    start: EventDateOrDateTime
+    end: EventDateOrDateTime
+    iCalUID: str
+    location: str
+    status: str
+    created: str
+    updated: str
+    sequence: int
+    transparency: str
+    visibility: str
+
+
+EventDataKey = Union[
+    Literal["id"],
+    Literal["summary"],
+    Literal["description"],
+    Literal["start"],
+    Literal["end"],
+    Literal["iCalUID"],
+    Literal["location"],
+    Literal["status"],
+    Literal["created"],
+    Literal["updated"],
+    Literal["sequence"],
+    Literal["transparency"],
+    Literal["visibility"],
+]
+EventList = List[EventData]
+EventTuple = Tuple[EventData, EventData]
+
+
+class EventsSearchResults(NamedTuple):
+    exists: List[EventTuple]
+    new: List[EventData]
+
+
+BatchRequestCallback = Callable[[str, Any, Optional[Exception]], None]
+
+
+class GoogleCalendarService:
     """class for make google calendar service Resource
 
     Returns:
@@ -15,254 +100,304 @@ class GoogleCalendarService():
     """
 
     @staticmethod
-    def default():
+    def default() -> discovery.Resource:
         """make service Resource from default credentials (authorize)
         ( https://developers.google.com/identity/protocols/application-default-credentials )
         ( https://googleapis.dev/python/google-auth/latest/reference/google.auth.html#google.auth.default )
-
-        Returns:
-            service Resource
         """
 
-        scopes = ['https://www.googleapis.com/auth/calendar']
+        scopes = ["https://www.googleapis.com/auth/calendar"]
         credentials, _ = google.auth.default(scopes=scopes)
-        service = discovery.build('calendar', 'v3', credentials=credentials)
+        service = discovery.build(
+            "calendar", "v3", credentials=credentials, cache_discovery=False
+        )
         return service
-    
+
     @staticmethod
-    def from_srv_acc_file(service_account_file):
-        """make service Resource from service account filename (authorize)
+    def from_srv_acc_file(service_account_file: str) -> discovery.Resource:
+        """make service Resource from service account filename (authorize)"""
 
-        Returns:
-            service Resource
-        """
-
-        scopes = ['https://www.googleapis.com/auth/calendar']
-        credentials = service_account.Credentials.from_service_account_file(service_account_file)
+        scopes = ["https://www.googleapis.com/auth/calendar"]
+        credentials = service_account.Credentials.from_service_account_file(
+            service_account_file
+        )
         scoped_credentials = credentials.with_scopes(scopes)
-        service = discovery.build('calendar', 'v3', credentials=scoped_credentials)
+        service = discovery.build(
+            "calendar", "v3", credentials=scoped_credentials, cache_discovery=False
+        )
         return service
-    
+
     @staticmethod
-    def from_config(config):
+    def from_config(config: Optional[Dict[str, str]] = None) -> discovery.Resource:
         """make service Resource from config dict
 
         Arguments:
-        config -- dict() config with keys:
-                    (optional) service_account: - service account filename
-                    if key not in dict then default credentials will be used
-                    ( https://developers.google.com/identity/protocols/application-default-credentials )
 
-        Returns:
-            service Resource
+        **config** -- config with keys:
+
+        (optional) service_account: - service account filename
+        if key not in dict then default credentials will be used
+        ( https://developers.google.com/identity/protocols/application-default-credentials )
+
+        -- **None**: default credentials will be used
         """
 
-        if 'service_account' in config:
-            service = GoogleCalendarService.from_srv_acc_file(config['service_account'])
+        if config is not None and "service_account" in config:
+            service_account_filename: str = config["service_account"]
+            service = GoogleCalendarService.from_srv_acc_file(service_account_filename)
         else:
             service = GoogleCalendarService.default()
         return service
 
-def select_event_key(event):
+
+def select_event_key(event: EventData) -> Optional[str]:
     """select event key for logging
-    
+
     Arguments:
         event -- event resource
-    
+
     Returns:
         key name or None if no key found
     """
 
-    key = None
-    if 'iCalUID' in event:
-        key = 'iCalUID'
-    elif 'id' in event:
-        key = 'id'
+    key: Optional[str] = None
+    if "iCalUID" in event:
+        key = "iCalUID"
+    elif "id" in event:
+        key = "id"
     return key
 
 
-class GoogleCalendar():
-    """class to interact with calendar on google
-    """
+class GoogleCalendar:
+    """class to interact with calendar on Google"""
 
-    logger = logging.getLogger('GoogleCalendar')
+    logger = logging.getLogger("GoogleCalendar")
 
-    def __init__(self, service, calendarId):
-        self.service = service
-        self.calendarId = calendarId
+    def __init__(self, service: discovery.Resource, calendar_id: Optional[str]):
+        self.service: discovery.Resource = service
+        self.calendar_id: str = str(calendar_id)
 
-    def _make_request_callback(self, action, events_by_req):
+    def _make_request_callback(
+        self, action: str, events_by_req: EventList
+    ) -> BatchRequestCallback:
         """make callback for log result of batch request
-        
+
         Arguments:
             action -- action name
             events_by_req -- list of events ordered by request id
-        
+
         Returns:
             callback function
         """
 
-        def callback(request_id, response, exception):
-            event = events_by_req[int(request_id)]
-            key = select_event_key(event)
+        def callback(
+            request_id: str, response: Any, exception: Optional[Exception]
+        ) -> None:
+            event: EventData = events_by_req[int(request_id)]
+            event_key: Optional[str] = select_event_key(event)
+            key: str = event_key if event_key is not None else ""
 
             if exception is not None:
-                self.logger.error('failed to %s event with %s: %s, exception: %s',
-                                  action, key, event.get(key), str(exception))
+                self.logger.error(
+                    "failed to %s event with %s: %s, exception: %s",
+                    action,
+                    key,
+                    event.get(key),
+                    str(exception),
+                )
             else:
-                resp_key = select_event_key(response)
+                resp_key: Optional[str] = select_event_key(response)
                 if resp_key is not None:
                     event = response
                     key = resp_key
-                self.logger.info('event %s ok, %s: %s',
-                                 action, key, event.get(key))
+                self.logger.info("event %s ok, %s: %s", action, key, event.get(key))
+
         return callback
 
-    def list_events_from(self, start):
-        """ list events from calendar, where start date >= start
-        """
-        fields = 'nextPageToken,items(id,iCalUID,updated)'
-        events = []
-        page_token = None
-        timeMin = utc.normalize(start.astimezone(utc)).replace(
-            tzinfo=None).isoformat() + 'Z'
+    def list_events_from(self, start: datetime) -> EventList:
+        """list events from calendar, where start date >= start"""
+        fields: str = "nextPageToken,items(id,iCalUID,updated)"
+        events: EventList = []
+        page_token: Optional[str] = None
+        time_min: str = (
+            utc.normalize(start.astimezone(utc)).replace(tzinfo=None).isoformat() + "Z"
+        )
         while True:
-            response = self.service.events().list(calendarId=self.calendarId, pageToken=page_token,
-                                                  singleEvents=True, timeMin=timeMin, fields=fields).execute()
-            if 'items' in response:
-                events.extend(response['items'])
-                page_token = response.get('nextPageToken')
+            response = (
+                self.service.events()
+                .list(
+                    calendarId=self.calendar_id,
+                    pageToken=page_token,
+                    singleEvents=True,
+                    timeMin=time_min,
+                    fields=fields,
+                )
+                .execute()
+            )
+            if "items" in response:
+                events.extend(response["items"])
+                page_token = response.get("nextPageToken")
                 if not page_token:
                     break
-        self.logger.info('%d events listed', len(events))
+        self.logger.info("%d events listed", len(events))
         return events
 
-    def find_exists(self, events):
-        """ find existing events from list, by 'iCalUID' field
+    def find_exists(self, events: EventList) -> EventsSearchResults:
+        """find existing events from list, by 'iCalUID' field
 
         Arguments:
             events {list} -- list of events
 
         Returns:
-            tuple -- (events_exist, events_not_found)
+            EventsSearchResults -- (events_exist, events_not_found)
                   events_exist - list of tuples: (new_event, exists_event)
         """
 
-        fields = 'items(id,iCalUID,updated)'
-        events_by_req = []
-        exists = []
-        not_found = []
+        fields: str = "items(id,iCalUID,updated)"
+        events_by_req: EventList = []
+        exists: List[EventTuple] = []
+        not_found: EventList = []
 
-        def list_callback(request_id, response, exception):
-            found = False
-            event = events_by_req[int(request_id)]
+        def list_callback(
+            request_id: str, response: Any, exception: Optional[Exception]
+        ) -> None:
+            found: bool = False
+            cur_event: EventData = events_by_req[int(request_id)]
             if exception is None:
-                found = ([] != response['items'])
+                found = [] != response["items"]
             else:
-                self.logger.error('exception %s, while listing event with UID: %s', str(
-                    exception), event['iCalUID'])
+                self.logger.error(
+                    "exception %s, while listing event with UID: %s",
+                    str(exception),
+                    cur_event["iCalUID"],
+                )
             if found:
-                exists.append(
-                    (event, response['items'][0]))
+                exists.append((cur_event, response["items"][0]))
             else:
                 not_found.append(events_by_req[int(request_id)])
 
         batch = self.service.new_batch_http_request(callback=list_callback)
-        i = 0
+        i: int = 0
         for event in events:
             events_by_req.append(event)
-            batch.add(self.service.events().list(calendarId=self.calendarId,
-                                                 iCalUID=event['iCalUID'], showDeleted=True, fields=fields), request_id=str(i))
+            batch.add(
+                self.service.events().list(
+                    calendarId=self.calendar_id,
+                    iCalUID=event["iCalUID"],
+                    showDeleted=True,
+                    fields=fields,
+                ),
+                request_id=str(i),
+            )
             i += 1
         batch.execute()
-        self.logger.info('%d events exists, %d not found',
-                         len(exists), len(not_found))
-        return exists, not_found
+        self.logger.info("%d events exists, %d not found", len(exists), len(not_found))
+        return EventsSearchResults(exists, not_found)
 
-    def insert_events(self, events):
-        """ insert list of events
+    def insert_events(self, events: EventList) -> None:
+        """insert list of events
 
         Arguments:
             events  - events list
         """
 
-        fields = 'id'
-        events_by_req = []
+        fields: str = "id"
+        events_by_req: EventList = []
 
-        insert_callback = self._make_request_callback('insert', events_by_req)
+        insert_callback = self._make_request_callback("insert", events_by_req)
         batch = self.service.new_batch_http_request(callback=insert_callback)
-        i = 0
+        i: int = 0
         for event in events:
             events_by_req.append(event)
-            batch.add(self.service.events().insert(
-                calendarId=self.calendarId, body=event, fields=fields), request_id=str(i))
+            batch.add(
+                self.service.events().insert(
+                    calendarId=self.calendar_id, body=event, fields=fields
+                ),
+                request_id=str(i),
+            )
             i += 1
         batch.execute()
 
-    def patch_events(self, event_tuples):
-        """ patch (update) events
+    def patch_events(self, event_tuples: List[EventTuple]) -> None:
+        """patch (update) events
 
         Arguments:
             event_tuples  -- list of tuples: (new_event, exists_event)
         """
 
-        fields = 'id'
-        events_by_req = []
+        fields: str = "id"
+        events_by_req: EventList = []
 
-        patch_callback = self._make_request_callback('patch', events_by_req)
+        patch_callback = self._make_request_callback("patch", events_by_req)
         batch = self.service.new_batch_http_request(callback=patch_callback)
-        i = 0
+        i: int = 0
         for event_new, event_old in event_tuples:
-            if 'id' not in event_old:
+            if "id" not in event_old:
                 continue
             events_by_req.append(event_new)
-            batch.add(self.service.events().patch(
-                calendarId=self.calendarId, eventId=event_old['id'], body=event_new), fields=fields, request_id=str(i))
+            batch.add(
+                self.service.events().patch(
+                    calendarId=self.calendar_id, eventId=event_old["id"], body=event_new
+                ),
+                fields=fields,
+                request_id=str(i),
+            )
             i += 1
         batch.execute()
 
-    def update_events(self, event_tuples):
-        """ update events
+    def update_events(self, event_tuples: List[EventTuple]) -> None:
+        """update events
 
         Arguments:
             event_tuples  -- list of tuples: (new_event, exists_event)
         """
 
-        fields = 'id'
-        events_by_req = []
+        fields: str = "id"
+        events_by_req: EventList = []
 
-        update_callback = self._make_request_callback('update', events_by_req)
+        update_callback = self._make_request_callback("update", events_by_req)
         batch = self.service.new_batch_http_request(callback=update_callback)
-        i = 0
+        i: int = 0
         for event_new, event_old in event_tuples:
-            if 'id' not in event_old:
+            if "id" not in event_old:
                 continue
             events_by_req.append(event_new)
-            batch.add(self.service.events().update(
-                calendarId=self.calendarId, eventId=event_old['id'], body=event_new, fields=fields), request_id=str(i))
+            batch.add(
+                self.service.events().update(
+                    calendarId=self.calendar_id,
+                    eventId=event_old["id"],
+                    body=event_new,
+                    fields=fields,
+                ),
+                request_id=str(i),
+            )
             i += 1
         batch.execute()
 
-    def delete_events(self, events):
-        """ delete events
+    def delete_events(self, events: EventList) -> None:
+        """delete events
 
         Arguments:
             events  -- list of events
         """
 
-        events_by_req = []
+        events_by_req: EventList = []
 
-        delete_callback = self._make_request_callback('delete', events_by_req)
+        delete_callback = self._make_request_callback("delete", events_by_req)
         batch = self.service.new_batch_http_request(callback=delete_callback)
-        i = 0
+        i: int = 0
         for event in events:
             events_by_req.append(event)
-            batch.add(self.service.events().delete(
-                calendarId=self.calendarId, eventId=event['id']), request_id=str(i))
+            batch.add(
+                self.service.events().delete(
+                    calendarId=self.calendar_id, eventId=event["id"]
+                ),
+                request_id=str(i),
+            )
             i += 1
         batch.execute()
 
-    def create(self, summary, timeZone=None):
+    def create(self, summary: str, time_zone: Optional[str] = None) -> Any:
         """create calendar
 
         Arguments:
@@ -275,44 +410,35 @@ class GoogleCalendar():
             calendar Resource
         """
 
-        calendar = {'summary': summary}
-        if timeZone is not None:
-            calendar['timeZone'] = timeZone
+        calendar = CalendarData(summary=summary)
+        if time_zone is not None:
+            calendar["timeZone"] = time_zone
 
         created_calendar = self.service.calendars().insert(body=calendar).execute()
-        self.calendarId = created_calendar['id']
+        self.calendar_id = created_calendar["id"]
         return created_calendar
 
-    def delete(self):
-        """delete calendar
-        """
+    def delete(self) -> None:
+        """delete calendar"""
 
-        self.service.calendars().delete(calendarId=self.calendarId).execute()
+        self.service.calendars().delete(calendarId=self.calendar_id).execute()
 
-    def make_public(self):
-        """make calendar puplic
-        """
+    def make_public(self) -> None:
+        """make calendar public"""
 
-        rule_public = {
-            'scope': {
-                'type': 'default',
-            },
-            'role': 'reader'
-        }
-        return self.service.acl().insert(calendarId=self.calendarId, body=rule_public).execute()
+        rule_public = ACLRule(scope=ACLScope(type="default"), role="reader")
+        self.service.acl().insert(
+            calendarId=self.calendar_id, body=rule_public
+        ).execute()
 
-    def add_owner(self, email):
+    def add_owner(self, email: str) -> None:
         """add calendar owner by email
 
         Arguments:
             email -- email to add
         """
 
-        rule_owner = {
-            'scope': {
-                'type': 'user',
-                'value': email,
-            },
-            'role': 'owner'
-        }
-        return self.service.acl().insert(calendarId=self.calendarId, body=rule_owner).execute()
+        rule_owner = ACLRule(scope=ACLScope(type="user", value=email), role="owner")
+        self.service.acl().insert(
+            calendarId=self.calendar_id, body=rule_owner
+        ).execute()

sync_ics2gcal/ical.py

@@ -1,12 +1,25 @@
 import datetime
 import logging
+from typing import Union, Dict, Callable, Optional, Mapping, TypedDict
 
 from icalendar import Calendar, Event
 from pytz import utc
 
+from .gcal import (
+    EventData,
+    EventList,
+    EventDateOrDateTime,
+    EventDateTime,
+    EventDate,
+    EventDataKey,
+)
 
-def format_datetime_utc(value):
+DateDateTime = Union[datetime.date, datetime.datetime]
+
+
+def format_datetime_utc(value: DateDateTime) -> str:
     """utc datetime as string from date or datetime value
+
     Arguments:
         value -- date or datetime value
 
@@ -14,54 +27,57 @@ def format_datetime_utc(value):
         utc datetime value as string in iso format
     """
     if not isinstance(value, datetime.datetime):
-        value = datetime.datetime(
-            value.year, value.month, value.day, tzinfo=utc)
+        value = datetime.datetime(value.year, value.month, value.day, tzinfo=utc)
     value = value.replace(microsecond=1)
-    return utc.normalize(value.astimezone(utc)).replace(tzinfo=None).isoformat() + 'Z'
+
+    return utc.normalize(value.astimezone(utc)).replace(tzinfo=None).isoformat() + "Z"
 
 
-def gcal_date_or_dateTime(value, check_value=None):
-    """date or dateTime to gcal (start or end dict)
+def gcal_date_or_datetime(
+    value: DateDateTime, check_value: Optional[DateDateTime] = None
+) -> EventDateOrDateTime:
+    """date or datetime to gcal (start or end dict)
+
     Arguments:
-        value -- date or datetime value
-        check_value - date or datetime to choise result type (if not None)
+        value: date or datetime
+        check_value: optional for choose result type
 
     Returns:
-        dict { 'date': ... } or { 'dateTime': ... }
+         { 'date': ... } or { 'dateTime': ... }
     """
 
     if check_value is None:
         check_value = value
 
-    result = {}
+    result: EventDateOrDateTime
     if isinstance(check_value, datetime.datetime):
-        result['dateTime'] = format_datetime_utc(value)
+        result = EventDateTime(dateTime=format_datetime_utc(value))
     else:
         if isinstance(check_value, datetime.date):
             if isinstance(value, datetime.datetime):
                 value = datetime.date(value.year, value.month, value.day)
-        result['date'] = value.isoformat()
+        result = EventDate(date=value.isoformat())
     return result
 
 
-class EventConverter(Event):
+class EventConverter(Event):  # type: ignore
     """Convert icalendar event to google calendar resource
     ( https://developers.google.com/calendar/v3/reference/events#resource-representations )
     """
 
-    def _str_prop(self, prop):
+    def _str_prop(self, prop: str) -> str:
         """decoded string property
 
         Arguments:
-            prop - propperty name
+            prop - property name
 
         Returns:
             string value
         """
 
-        return self.decoded(prop).decode(encoding='utf-8')
+        return str(self.decoded(prop).decode(encoding="utf-8"))
 
-    def _datetime_str_prop(self, prop):
+    def _datetime_str_prop(self, prop: str) -> str:
         """utc datetime as string from property
 
         Arguments:
@@ -73,8 +89,8 @@ class EventConverter(Event):
 
         return format_datetime_utc(self.decoded(prop))
 
-    def _gcal_start(self):
-        """ event start dict from icalendar event
+    def _gcal_start(self) -> EventDateOrDateTime:
+        """event start dict from icalendar event
 
         Raises:
             ValueError -- if DTSTART not date or datetime
@@ -83,10 +99,10 @@ class EventConverter(Event):
             dict
         """
 
-        value = self.decoded('DTSTART')
-        return gcal_date_or_dateTime(value)
+        value = self.decoded("DTSTART")
+        return gcal_date_or_datetime(value)
 
-    def _gcal_end(self):
+    def _gcal_end(self) -> EventDateOrDateTime:
         """event end dict from icalendar event
 
         Raises:
@@ -95,25 +111,31 @@ class EventConverter(Event):
             dict
         """
 
-        result = None
-        if 'DTEND' in self:
-            value = self.decoded('DTEND')
-            result = gcal_date_or_dateTime(value)
-        elif 'DURATION' in self:
-            start_val = self.decoded('DTSTART')
-            duration = self.decoded('DURATION')
+        result: EventDateOrDateTime
+        if "DTEND" in self:
+            value = self.decoded("DTEND")
+            result = gcal_date_or_datetime(value)
+        elif "DURATION" in self:
+            start_val = self.decoded("DTSTART")
+            duration = self.decoded("DURATION")
             end_val = start_val + duration
 
-            result = gcal_date_or_dateTime(end_val, check_value=start_val)
+            result = gcal_date_or_datetime(end_val, check_value=start_val)
         else:
-            raise ValueError('no DTEND or DURATION')
+            raise ValueError("no DTEND or DURATION")
         return result
 
-    def _put_to_gcal(self, gcal_event, prop, func, ics_prop=None):
-        """get property from ical event if exist, and put to gcal event
+    def _put_to_gcal(
+        self,
+        gcal_event: EventData,
+        prop: EventDataKey,
+        func: Callable[[str], str],
+        ics_prop: Optional[str] = None,
+    ) -> None:
+        """get property from ical event if existed, and put to gcal event
 
         Arguments:
-            gcal_event -- dest event
+            gcal_event -- destination event
             prop -- property name
             func -- function to convert
             ics_prop -- ical property name (default: {None})
@@ -124,61 +146,56 @@ class EventConverter(Event):
         if ics_prop in self:
             gcal_event[prop] = func(ics_prop)
 
-    def to_gcal(self):
+    def convert(self) -> EventData:
         """Convert
 
         Returns:
             dict - google calendar#event resource
         """
 
-        event = {
-            'iCalUID': self._str_prop('UID')
-        }
+        event: EventData = EventData(
+            iCalUID=self._str_prop("UID"),
+            start=self._gcal_start(),
+            end=self._gcal_end(),
+        )
 
-        event['start'] = self._gcal_start()
-        event['end'] = self._gcal_end()
-
-        self._put_to_gcal(event, 'summary', self._str_prop)
-        self._put_to_gcal(event, 'description', self._str_prop)
-        self._put_to_gcal(event, 'location', self._str_prop)
-        self._put_to_gcal(event, 'created', self._datetime_str_prop)
+        self._put_to_gcal(event, "summary", self._str_prop)
+        self._put_to_gcal(event, "description", self._str_prop)
+        self._put_to_gcal(event, "location", self._str_prop)
+        self._put_to_gcal(event, "created", self._datetime_str_prop)
+        self._put_to_gcal(event, "updated", self._datetime_str_prop, "LAST-MODIFIED")
         self._put_to_gcal(
-            event, 'updated', self._datetime_str_prop, 'LAST-MODIFIED')
-        self._put_to_gcal(
-            event, 'transparency', lambda prop: self._str_prop(prop).lower(), 'TRANSP')
+            event, "transparency", lambda prop: self._str_prop(prop).lower(), "TRANSP"
+        )
 
         return event
 
 
-class CalendarConverter():
-    """Convert icalendar events to google calendar resources
-    """
+class CalendarConverter:
+    """Convert icalendar events to google calendar resources"""
 
-    logger = logging.getLogger('CalendarConverter')
+    logger = logging.getLogger("CalendarConverter")
 
-    def __init__(self, calendar=None):
-        self.calendar = calendar
+    def __init__(self, calendar: Optional[Calendar] = None):
+        self.calendar: Optional[Calendar] = calendar
 
-    def load(self, filename):
-        """ load calendar from ics file 
-        """
-        with open(filename, 'r', encoding='utf-8') as f:
+    def load(self, filename: str) -> None:
+        """load calendar from ics file"""
+        with open(filename, "r", encoding="utf-8") as f:
             self.calendar = Calendar.from_ical(f.read())
-            self.logger.info('%s loaded', filename)
+            self.logger.info("%s loaded", filename)
 
-    def loads(self, string):
-        """ load calendar from ics string
-        """
+    def loads(self, string: str) -> None:
+        """load calendar from ics string"""
         self.calendar = Calendar.from_ical(string)
 
-    def events_to_gcal(self):
-        """Convert events to google calendar resources
-        """
+    def events_to_gcal(self) -> EventList:
+        """Convert events to google calendar resources"""
 
-        ics_events = self.calendar.walk(name='VEVENT')
-        self.logger.info('%d events readed', len(ics_events))
+        calendar: Calendar = self.calendar
+        ics_events = calendar.walk(name="VEVENT")
+        self.logger.info("%d events read", len(ics_events))
 
-        result = list(
-            map(lambda event: EventConverter(event).to_gcal(), ics_events))
-        self.logger.info('%d events converted', len(result))
+        result = list(map(lambda event: EventConverter(event).convert(), ics_events))
+        self.logger.info("%d events converted", len(result))
         return result

sync_ics2gcal/manage_calendars.py

@@ -1,103 +1,154 @@
-import argparse
-import datetime
 import logging.config
+from typing import Optional, Dict, Any, List
 
+import fire
 import yaml
-from pytz import utc
 
 from . import GoogleCalendar, GoogleCalendarService
 
 
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="manage google calendars in service account")
-    command_subparsers = parser.add_subparsers(help='command', dest='command')
-    command_subparsers.add_parser('list', help='list calendars')
-    parser_create = command_subparsers.add_parser(
-        'create', help='create calendar')
-    parser_create.add_argument(
-        'summary', action='store', help='new calendar summary')
-    parser_create.add_argument('--timezone', action='store',
-                               default=None, required=False, help='new calendar timezone')
-    parser_create.add_argument(
-        '--public', default=False, action='store_true', help='make calendar public')
-    parser_add_owner = command_subparsers.add_parser(
-        'add_owner', help='add owner to calendar')
-    parser_add_owner.add_argument('id', action='store', help='calendar id')
-    parser_add_owner.add_argument(
-        'owner_email', action='store', help='new owner email')
-    parser_remove = command_subparsers.add_parser(
-        'remove', help='remove calendar')
-    parser_remove.add_argument(
-        'id', action='store', help='calendar id to remove')
-    parser_rename = command_subparsers.add_parser(
-        'rename', help='rename calendar')
-    parser_rename.add_argument(
-        'id', action='store', help='calendar id')
-    parser_rename.add_argument(
-        'summary', action='store', help='new summary')
-    
-    args = parser.parse_args()
-    if args.command is None:
-        parser.print_usage()
-    return args
+def load_config(filename: str) -> Optional[Dict[str, Any]]:
+    result: Optional[Dict[str, Any]] = None
+    try:
+        with open(filename, "r", encoding="utf-8") as f:
+            result = yaml.safe_load(f)
+    except FileNotFoundError:
+        pass
 
-
-def load_config():
-    with open('config.yml', 'r', encoding='utf-8') as f:
-        result = yaml.safe_load(f)
     return result
 
 
-def list_calendars(service):
-    response = service.calendarList().list(fields='items(id,summary)').execute()
-    for calendar in response.get('items'):
-        print('{summary}: {id}'.format_map(calendar))
+class PropertyCommands:
+    """get/set google calendar properties"""
+
+    def __init__(self, _service: Any) -> None:
+        self._service = _service
+
+    def get(self, calendar_id: str, property_name: str) -> None:
+        """get calendar property
+
+        Args:
+            calendar_id: calendar id
+            property_name: property key
+        """
+        response = (
+            self._service.calendarList()
+            .get(calendarId=calendar_id, fields=property_name)
+            .execute()
+        )
+        print(response.get(property_name))
+
+    def set(self, calendar_id: str, property_name: str, property_value: str) -> None:
+        """set calendar property
+
+        Args:
+            calendar_id: calendar id
+            property_name: property key
+            property_value: property value
+        """
+        body = {property_name: property_value}
+        response = (
+            self._service.calendarList()
+            .patch(body=body, calendarId=calendar_id)
+            .execute()
+        )
+        print(response)
 
 
-def create_calendar(service, summary, timezone, public):
-    calendar = GoogleCalendar(service, None)
-    calendar.create(summary, timezone)
-    if public:
-        calendar.make_public()
-    print('{}: {}'.format(summary, calendar.calendarId))
+class Commands:
+    """manage google calendars in service account"""
+
+    def __init__(self, config: str = "config.yml"):
+        """
+
+        Args:
+            config(str): config filename
+        """
+        self._config: Optional[Dict[str, Any]] = load_config(config)
+        if self._config is not None and "logging" in self._config:
+            logging.config.dictConfig(self._config["logging"])
+        self._service = GoogleCalendarService.from_config(self._config)
+        self.property = PropertyCommands(self._service)
+
+    def list(self, show_hidden: bool = False, show_deleted: bool = False) -> None:
+        """list calendars
+
+        Args:
+            show_hidden: show hidden calendars
+            show_deleted: show deleted calendars
+        """
+
+        fields: str = "nextPageToken,items(id,summary)"
+        calendars: List[Dict[str, Any]] = []
+        page_token: Optional[str] = None
+        while True:
+            calendars_api = self._service.calendarList()
+            response = calendars_api.list(
+                fields=fields,
+                pageToken=page_token,
+                showHidden=show_hidden,
+                showDeleted=show_deleted,
+            ).execute()
+            if "items" in response:
+                calendars.extend(response["items"])
+                page_token = response.get("nextPageToken")
+                if page_token is None:
+                    break
+        for calendar in calendars:
+            print("{summary}: {id}".format_map(calendar))
+
+    def create(
+        self, summary: str, timezone: Optional[str] = None, public: bool = False
+    ) -> None:
+        """create calendar
+
+        Args:
+            summary: new calendar summary
+            timezone: new calendar timezone
+            public: make calendar public
+        """
+        calendar = GoogleCalendar(self._service, None)
+        calendar.create(summary, timezone)
+        if public:
+            calendar.make_public()
+        print("{}: {}".format(summary, calendar.calendar_id))
+
+    def add_owner(self, calendar_id: str, email: str) -> None:
+        """add owner to calendar
+
+        Args:
+            calendar_id: calendar id
+            email: new owner email
+        """
+        calendar = GoogleCalendar(self._service, calendar_id)
+        calendar.add_owner(email)
+        print("to {} added owner: {}".format(calendar_id, email))
+
+    def remove(self, calendar_id: str) -> None:
+        """remove calendar
+
+        Args:
+            calendar_id: calendar id
+        """
+        calendar = GoogleCalendar(self._service, calendar_id)
+        calendar.delete()
+        print("removed: {}".format(calendar_id))
+
+    def rename(self, calendar_id: str, summary: str) -> None:
+        """rename calendar
+
+        Args:
+            calendar_id: calendar id
+            summary:
+        """
+        calendar = {"summary": summary}
+        self._service.calendars().patch(body=calendar, calendarId=calendar_id).execute()
+        print("{}: {}".format(summary, calendar_id))
 
 
-def add_owner(service, id, owner_email):
-    calendar = GoogleCalendar(service, id)
-    calendar.add_owner(owner_email)
-    print('to {} added owner: {}'.format(id, owner_email))
+def main() -> None:
+    fire.Fire(Commands, name="manage-ics2gcal")
 
 
-def remove_calendar(service, id):
-    calendar = GoogleCalendar(service, id)
-    calendar.delete()
-    print('removed: {}'.format(id))
-
-def rename_calendar(service, id, summary):
-    calendar = {'summary': summary}
-    service.calendars().patch(body=calendar, calendarId=id).execute()
-    print('{}: {}'.format(summary, id))
-
-def main():
-    args = parse_args()
-    config = load_config()
-
-    if 'logging' in config:
-        logging.config.dictConfig(config['logging'])
-
-    service = GoogleCalendarService.from_config(config)
-
-    if 'list' == args.command:
-        list_calendars(service)
-    elif 'create' == args.command:
-        create_calendar(service, args.summary, args.timezone, args.public)
-    elif 'add_owner' == args.command:
-        add_owner(service, args.id, args.owner_email)
-    elif 'remove' == args.command:
-        remove_calendar(service, args.id)
-    elif 'rename' == args.command:
-        rename_calendar(service, args.id, args.summary)
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

sync_ics2gcal/sync.py

@@ -1,111 +1,144 @@
 import datetime
-import dateutil.parser
 import logging
 import operator
+from typing import List, Dict, Set, Tuple, Union, Callable, NamedTuple
+
+import dateutil.parser
 from pytz import utc
 
+from .gcal import (
+    GoogleCalendar,
+    EventData,
+    EventList,
+    EventTuple,
+    EventDataKey,
+    EventDateOrDateTime,
+    EventDate,
+)
+from .ical import CalendarConverter, DateDateTime
 
-class CalendarSync():
-    """class for syncronize calendar with google
-    """
 
-    logger = logging.getLogger('CalendarSync')
+class ComparedEvents(NamedTuple):
+    """Compared events"""
 
-    def __init__(self, gcalendar, converter):
-        self.gcalendar = gcalendar
-        self.converter = converter
+    added: EventList
+    changed: List[EventTuple]
+    deleted: EventList
+
+
+class CalendarSync:
+    """class for synchronize calendar with Google"""
+
+    logger = logging.getLogger("CalendarSync")
+
+    def __init__(self, gcalendar: GoogleCalendar, converter: CalendarConverter):
+        self.gcalendar: GoogleCalendar = gcalendar
+        self.converter: CalendarConverter = converter
+        self.to_insert: EventList = []
+        self.to_update: List[EventTuple] = []
+        self.to_delete: EventList = []
 
     @staticmethod
-    def _events_list_compare(items_src, items_dst, key='iCalUID'):
-        """ compare list of events by key
+    def _events_list_compare(
+        items_src: EventList, items_dst: EventList, key: EventDataKey = "iCalUID"
+    ) -> ComparedEvents:
+        """compare list of events by key
 
         Arguments:
             items_src {list of dict} -- source events
-            items_dst {list of dict} -- dest events
+            items_dst {list of dict} -- destination events
             key {str} -- name of key to compare (default: {'iCalUID'})
 
         Returns:
-            tuple -- (items_to_insert, 
-                      items_to_update, 
-                      items_to_delete)
+            ComparedEvents -- (added, changed, deleted)
         """
 
-        def get_key(item): return item[key]
+        def get_key(item: EventData) -> str:
+            return str(item[key])
 
-        keys_src = set(map(get_key, items_src))
-        keys_dst = set(map(get_key, items_dst))
+        keys_src: Set[str] = set(map(get_key, items_src))
+        keys_dst: Set[str] = set(map(get_key, items_dst))
 
         keys_to_insert = keys_src - keys_dst
         keys_to_update = keys_src & keys_dst
         keys_to_delete = keys_dst - keys_src
 
-        def items_by_keys(items, key_name, keys):
-            return list(filter(lambda item: item[key_name] in keys, items))
+        def items_by_keys(items: EventList, keys: Set[str]) -> EventList:
+            return list(filter(lambda item: get_key(item) in keys, items))
 
-        items_to_insert = items_by_keys(items_src, key, keys_to_insert)
-        items_to_delete = items_by_keys(items_dst, key, keys_to_delete)
+        items_to_insert = items_by_keys(items_src, keys_to_insert)
+        items_to_delete = items_by_keys(items_dst, keys_to_delete)
 
-        to_upd_src = items_by_keys(items_src, key, keys_to_update)
-        to_upd_dst = items_by_keys(items_dst, key, keys_to_update)
+        to_upd_src = items_by_keys(items_src, keys_to_update)
+        to_upd_dst = items_by_keys(items_dst, keys_to_update)
         to_upd_src.sort(key=get_key)
         to_upd_dst.sort(key=get_key)
         items_to_update = list(zip(to_upd_src, to_upd_dst))
 
-        return items_to_insert, items_to_update, items_to_delete
+        return ComparedEvents(items_to_insert, items_to_update, items_to_delete)
 
-    def _filter_events_to_update(self):
-        """ filter 'to_update' events by 'updated' datetime
-        """
+    def _filter_events_to_update(self) -> None:
+        """filter 'to_update' events by 'updated' datetime"""
 
-        def filter_updated(event_tuple):
+        def filter_updated(event_tuple: EventTuple) -> bool:
             new, old = event_tuple
-            return dateutil.parser.parse(new['updated']) > dateutil.parser.parse(old['updated'])
+            if "updated" not in new or "updated" not in old:
+                return True
+            new_date = dateutil.parser.parse(new["updated"])
+            old_date = dateutil.parser.parse(old["updated"])
+            return new_date > old_date
 
         self.to_update = list(filter(filter_updated, self.to_update))
 
     @staticmethod
-    def _filter_events_by_date(events, date, op):
-        """ filter events by start datetime
+    def _filter_events_by_date(
+        events: EventList,
+        date: DateDateTime,
+        op: Callable[[DateDateTime, DateDateTime], bool],
+    ) -> EventList:
+        """filter events by start datetime
 
         Arguments:
             events -- events list
             date {datetime} -- datetime to compare
-            op {operator} -- comparsion operator
+            op {operator} -- comparison operator
 
         Returns:
-            list of filtred events
+            list of filtered events
         """
 
-        def filter_by_date(event):
+        def filter_by_date(event: EventData) -> bool:
             date_cmp = date
-            event_start = event['start']
-            event_date = None
+            event_start: EventDateOrDateTime = event["start"]
+            event_date: Union[DateDateTime, str, None] = None
             compare_dates = False
 
-            if 'date' in event_start:
-                event_date = event_start['date']
+            if "date" in event_start:
+                event_date = event_start["date"]  # type: ignore
                 compare_dates = True
-            elif 'dateTime' in event_start:
-                event_date = event_start['dateTime']
-            
-            event_date = dateutil.parser.parse(event_date)
+            elif "dateTime" in event_start:
+                event_date = event_start["dateTime"]  # type: ignore
+
+            event_date = dateutil.parser.parse(str(event_date))
             if compare_dates:
                 date_cmp = datetime.date(date.year, date.month, date.day)
-                event_date = datetime.date(event_date.year, event_date.month, event_date.day)
+                event_date = datetime.date(
+                    event_date.year, event_date.month, event_date.day
+                )
 
             return op(event_date, date_cmp)
 
         return list(filter(filter_by_date, events))
 
     @staticmethod
-    def _tz_aware_datetime(date):
-        """make tz aware datetime from datetime/date (utc if no tzinfo)
+    def _tz_aware_datetime(date: DateDateTime) -> datetime.datetime:
+        """make tz aware datetime from datetime/date (utc if no tz-info)
 
         Arguments:
-            date - date or datetime / with or without tzinfo
+            date - date or datetime / with or without tz-info
 
         Returns:
-            datetime with tzinfo
+            datetime with tz-info
         """
 
         if not isinstance(date, datetime.datetime):
@@ -114,8 +147,8 @@ class CalendarSync():
             date = date.replace(tzinfo=utc)
         return date
 
-    def prepare_sync(self, start_date):
-        """prepare sync lists by comparsion of events
+    def prepare_sync(self, start_date: DateDateTime) -> None:
+        """prepare sync lists by comparison of events
 
         Arguments:
             start_date -- date/datetime to start sync
@@ -128,46 +161,52 @@ class CalendarSync():
 
         # divide source events by start datetime
         events_src_pending = CalendarSync._filter_events_by_date(
-            events_src, start_date, operator.ge)
+            events_src, start_date, operator.ge
+        )
         events_src_past = CalendarSync._filter_events_by_date(
-            events_src, start_date, operator.lt)
+            events_src, start_date, operator.lt
+        )
 
-        events_src = None
-
-        # first events comparsion
-        self.to_insert, self.to_update, self.to_delete = CalendarSync._events_list_compare(
-            events_src_pending, events_dst)
-
-        events_src_pending, events_dst = None, None
+        # first events comparison
+        (
+            self.to_insert,
+            self.to_update,
+            self.to_delete,
+        ) = CalendarSync._events_list_compare(events_src_pending, events_dst)
 
         # find in events 'to_delete' past events from source, for update (move to past)
         _, add_to_update, self.to_delete = CalendarSync._events_list_compare(
-            events_src_past, self.to_delete)
+            events_src_past, self.to_delete
+        )
         self.to_update.extend(add_to_update)
 
-        events_src_past = None
-
         # find if events 'to_insert' exists in gcalendar, for update them
-        add_to_update, self.to_insert = self.gcalendar.find_exists(
-            self.to_insert)
+        add_to_update, self.to_insert = self.gcalendar.find_exists(self.to_insert)
         self.to_update.extend(add_to_update)
 
-        add_to_update = None
-
         # exclude outdated events from 'to_update' list, by 'updated' field
         self._filter_events_to_update()
 
-        self.logger.info('prepared to sync: ( insert: %d, update: %d, delete: %d )',
-                         len(self.to_insert), len(self.to_update), len(self.to_delete))
+        self.logger.info(
+            "prepared to sync: ( insert: %d, update: %d, delete: %d )",
+            len(self.to_insert),
+            len(self.to_update),
+            len(self.to_delete),
+        )
 
-    def apply(self):
-        """apply sync (insert, update, delete), using prepared lists of events
-        """
+    def clear(self) -> None:
+        """clear prepared sync lists (insert, update, delete)"""
+        self.to_insert.clear()
+        self.to_update.clear()
+        self.to_delete.clear()
+
+    def apply(self) -> None:
+        """apply sync (insert, update, delete), using prepared lists of events"""
 
         self.gcalendar.insert_events(self.to_insert)
         self.gcalendar.update_events(self.to_update)
         self.gcalendar.delete_events(self.to_delete)
 
-        self.logger.info('sync done')
+        self.clear()
 
-        self.to_insert, self.to_update, self.to_delete = [], [], []
+        self.logger.info("sync done")

sync_ics2gcal/sync_calendar.py

@@ -1,51 +1,53 @@
+from typing import Dict, Any, Union
+
 import yaml
 
 import dateutil.parser
 import datetime
 import logging
 import logging.config
-from . import (
-    CalendarConverter,
-    GoogleCalendarService,
-    GoogleCalendar,
-    CalendarSync
-)
+from . import CalendarConverter, GoogleCalendarService, GoogleCalendar, CalendarSync
 
-def load_config():
-    with open('config.yml', 'r', encoding='utf-8') as f:
+ConfigDate = Union[str, datetime.datetime]
+
+
+def load_config() -> Dict[str, Any]:
+    with open("config.yml", "r", encoding="utf-8") as f:
         result = yaml.safe_load(f)
-    return result
+    return result  # type: ignore
 
 
-def get_start_date(date_str):
-    result = datetime.datetime(1,1,1)
-    if 'now' == date_str:
+def get_start_date(date: ConfigDate) -> datetime.datetime:
+    if isinstance(date, datetime.datetime):
+        return date
+    if "now" == date:
         result = datetime.datetime.utcnow()
     else:
-        result = dateutil.parser.parse(date_str)
+        result = dateutil.parser.parse(date)
     return result
 
 
-def main():
+def main() -> None:
     config = load_config()
 
-    if 'logging' in config:
-        logging.config.dictConfig(config['logging'])
+    if "logging" in config:
+        logging.config.dictConfig(config["logging"])
 
-    calendarId = config['calendar']['google_id']
-    ics_filepath = config['calendar']['source']
+    calendar_id: str = config["calendar"]["google_id"]
+    ics_filepath: str = config["calendar"]["source"]
 
-    start = get_start_date(config['start_from'])
+    start = get_start_date(config["start_from"])
 
     converter = CalendarConverter()
     converter.load(ics_filepath)
 
     service = GoogleCalendarService.from_config(config)
-    gcalendar = GoogleCalendar(service, calendarId)
+    gcalendar = GoogleCalendar(service, calendar_id)
 
     sync = CalendarSync(gcalendar, converter)
     sync.prepare_sync(start)
     sync.apply()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

tests/test_converter.py

@@ -1,93 +1,146 @@
+import datetime
+from typing import Tuple, Any
+
 import pytest
+from pytz import timezone, utc
 
 from sync_ics2gcal import CalendarConverter
+from sync_ics2gcal.ical import format_datetime_utc
 
 uid = "UID:uisgtr8tre93wewe0yr8wqy@test.com"
-only_start_date = uid + """
+only_start_date = (
+    uid
+    + """
 DTSTART;VALUE=DATE:20180215
 """
-date_val = only_start_date + """
+)
+date_val = (
+    only_start_date
+    + """
 DTEND;VALUE=DATE:20180217
 """
-date_duration = only_start_date + """
+)
+date_duration = (
+    only_start_date
+    + """
 DURATION:P2D
 """
-datetime_utc_val = uid + """
+)
+datetime_utc_val = (
+    uid
+    + """
 DTSTART;VALUE=DATE-TIME:20180319T092001Z
 DTEND:20180321T102501Z
 """
-datetime_utc_duration = uid + """
+)
+datetime_utc_duration = (
+    uid
+    + """
 DTSTART;VALUE=DATE-TIME:20180319T092001Z
 DURATION:P2DT1H5M
 """
-created_updated = date_val + """
+)
+created_updated = (
+    date_val
+    + """
 CREATED:20180320T071155Z
 LAST-MODIFIED:20180326T120235Z
 """
+)
 
 
-def ics_test_cal(content):
+def ics_test_cal(content: str) -> str:
     return "BEGIN:VCALENDAR\r\n{}END:VCALENDAR\r\n".format(content)
 
 
-def ics_test_event(content):
+def ics_test_event(content: str) -> str:
     return ics_test_cal("BEGIN:VEVENT\r\n{}END:VEVENT\r\n".format(content))
 
 
-def test_empty_calendar():
+def test_empty_calendar() -> None:
     converter = CalendarConverter()
     converter.loads(ics_test_cal(""))
     evnts = converter.events_to_gcal()
     assert evnts == []
 
 
-def test_empty_event():
+def test_empty_event() -> None:
     converter = CalendarConverter()
     converter.loads(ics_test_event(""))
     with pytest.raises(KeyError):
         converter.events_to_gcal()
 
 
-def test_event_no_end():
+def test_event_no_end() -> None:
     converter = CalendarConverter()
     converter.loads(ics_test_event(only_start_date))
     with pytest.raises(ValueError):
         converter.events_to_gcal()
 
 
-@pytest.fixture(params=[
-    ("date", ics_test_event(date_val), '2018-02-15', '2018-02-17'),
-    ("date", ics_test_event(date_duration), '2018-02-15', '2018-02-17'),
-    ("dateTime", ics_test_event(datetime_utc_val),
-     '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z'),
-    ("dateTime", ics_test_event(datetime_utc_duration), '2018-03-19T09:20:01.000001Z', '2018-03-21T10:25:01.000001Z')],
-    ids=['date values', 'date duration',
-         'datetime utc values', 'datetime utc duration']
+@pytest.fixture(
+    params=[
+        ("date", ics_test_event(date_val), "2018-02-15", "2018-02-17"),
+        ("date", ics_test_event(date_duration), "2018-02-15", "2018-02-17"),
+        (
+            "dateTime",
+            ics_test_event(datetime_utc_val),
+            "2018-03-19T09:20:01.000001Z",
+            "2018-03-21T10:25:01.000001Z",
+        ),
+        (
+            "dateTime",
+            ics_test_event(datetime_utc_duration),
+            "2018-03-19T09:20:01.000001Z",
+            "2018-03-21T10:25:01.000001Z",
+        ),
+    ],
+    ids=[
+        "date values",
+        "date duration",
+        "datetime utc values",
+        "datetime utc duration",
+    ],
 )
-def param_events_start_end(request):
+def param_events_start_end(request: Any) -> Any:
     return request.param
 
 
-def test_event_start_end(param_events_start_end):
+def test_event_start_end(param_events_start_end: Tuple[str, str, str, str]) -> None:
     (date_type, ics_str, start, end) = param_events_start_end
     converter = CalendarConverter()
     converter.loads(ics_str)
     events = converter.events_to_gcal()
     assert len(events) == 1
     event = events[0]
-    assert event['start'] == {
-        date_type: start
-    }
-    assert event['end'] == {
-        date_type: end
-    }
+    assert event["start"] == {date_type: start}
+    assert event["end"] == {date_type: end}
 
 
-def test_event_created_updated():
+def test_event_created_updated() -> None:
     converter = CalendarConverter()
     converter.loads(ics_test_event(created_updated))
     events = converter.events_to_gcal()
     assert len(events) == 1
     event = events[0]
-    assert event['created'] == '2018-03-20T07:11:55.000001Z'
-    assert event['updated'] == '2018-03-26T12:02:35.000001Z'
+    assert event["created"] == "2018-03-20T07:11:55.000001Z"
+    assert event["updated"] == "2018-03-26T12:02:35.000001Z"
+
+
+@pytest.mark.parametrize(
+    "value,expected_str",
+    [
+        (
+            datetime.datetime(2022, 6, 3, 13, 52, 15, 1, utc),
+            "2022-06-03T13:52:15.000001Z",
+        ),
+        (
+            datetime.datetime(2022, 6, 3, 13, 52, 15, 1, timezone("Europe/Moscow")),
+            "2022-06-03T11:22:15.000001Z",
+        ),
+        (datetime.date(2022, 6, 3), "2022-06-03T00:00:00.000001Z"),
+    ],
+    ids=["utc", "with timezone", "date"],
+)
+def test_format_datetime_utc(value: datetime.datetime, expected_str: str) -> None:
+    assert format_datetime_utc(value) == expected_str

tests/test_sync.py

@@ -3,92 +3,97 @@ import hashlib
 import operator
 from copy import deepcopy
 from random import shuffle
+from typing import Union, List, Dict, Optional, AnyStr
 
 import dateutil.parser
 import pytest
 from pytz import timezone, utc
 
-from sync_ics2gcal import CalendarSync
+from sync_ics2gcal import CalendarSync, DateDateTime
+from sync_ics2gcal.gcal import EventDateOrDateTime, EventData, EventList
 
 
-def sha1(string):
-    if isinstance(string, str):
-        string = string.encode('utf8')
+def sha1(s: AnyStr) -> str:
     h = hashlib.sha1()
-    h.update(string)
+    h.update(str(s).encode("utf8") if isinstance(s, str) else s)
     return h.hexdigest()
 
 
-def gen_events(start, stop, start_time, no_time=False):
+def gen_events(
+    start: int,
+    stop: int,
+    start_time: DateDateTime,
+    no_time: bool = False,
+) -> EventList:
+    duration: datetime.timedelta
+    date_key: str
+    date_end: str
     if no_time:
-        start_time = datetime.date(
-            start_time.year, start_time.month, start_time.day)
+        start_time = datetime.date(start_time.year, start_time.month, start_time.day)
         duration = datetime.date(1, 1, 2) - datetime.date(1, 1, 1)
         date_key = "date"
-        suff = ''
+        date_end = ""
     else:
-        start_time = utc.normalize(
-            start_time.astimezone(utc)).replace(tzinfo=None)
-        duration = datetime.datetime(
-            1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1)
+        start_time = utc.normalize(start_time.astimezone(utc)).replace(tzinfo=None)  # type: ignore
+        duration = datetime.datetime(1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1)
         date_key = "dateTime"
-        suff = 'Z'
+        date_end = "Z"
 
-    result = []
+    result: EventList = []
     for i in range(start, stop):
         event_start = start_time + (duration * i)
         event_end = event_start + duration
 
-        updated = event_start
+        updated: DateDateTime = event_start
         if no_time:
             updated = datetime.datetime(
-                updated.year, updated.month, updated.day, 0, 0, 0, 1, tzinfo=utc)
+                updated.year, updated.month, updated.day, 0, 0, 0, 1, tzinfo=utc
+            )
 
-        event = {
-            'summary': 'test event __ {}'.format(i),
-            'location': 'la la la {}'.format(i),
-            'description': 'test TEST -- test event {}'.format(i),
+        event: EventData = {
+            "summary": "test event __ {}".format(i),
+            "location": "la la la {}".format(i),
+            "description": "test TEST -- test event {}".format(i),
             "iCalUID": "{}@test.com".format(sha1("test - event {}".format(i))),
-            "updated": updated.isoformat() + 'Z',
-            "created": updated.isoformat() + 'Z'
+            "updated": updated.isoformat() + "Z",
+            "created": updated.isoformat() + "Z",
+            "start": {date_key: event_start.isoformat() + date_end},  # type: ignore
+            "end": {date_key: event_end.isoformat() + date_end},  # type: ignore
         }
-        event['start'] = {date_key: event_start.isoformat() + suff}
-        event['end'] = {date_key: event_end.isoformat() + suff}
         result.append(event)
     return result
 
 
-def gen_list_to_compare(start, stop):
-    result = []
+def gen_list_to_compare(start: int, stop: int) -> EventList:
+    result: EventList = []
     for i in range(start, stop):
-        result.append({'iCalUID': 'test{:06d}'.format(i)})
+        result.append({"iCalUID": "test{:06d}".format(i)})
     return result
 
 
-def get_start_date(event):
-    event_start = event['start']
-    start_date = None
+def get_start_date(event: EventData) -> DateDateTime:
+    event_start: EventDateOrDateTime = event["start"]
+    start_date: Optional[str] = None
     is_date = False
-    if 'date' in event_start:
-        start_date = event_start['date']
+    if "date" in event_start:
+        start_date = event_start["date"]  # type: ignore
         is_date = True
-    if 'dateTime' in event_start:
-        start_date = event_start['dateTime']
+    if "dateTime" in event_start:
+        start_date = event_start["dateTime"]  # type: ignore
 
-    result = dateutil.parser.parse(start_date)
+    result: DateDateTime = dateutil.parser.parse(str(start_date))
     if is_date:
         result = datetime.date(result.year, result.month, result.day)
 
     return result
 
 
-def test_compare():
-    part_len = 20
+def test_compare() -> None:
+    part_len: int = 20
     # [1..2n]
     lst_src = gen_list_to_compare(1, 1 + part_len * 2)
     # [n..3n]
-    lst_dst = gen_list_to_compare(
-        1 + part_len, 1 + part_len * 3)
+    lst_dst = gen_list_to_compare(1 + part_len, 1 + part_len * 3)
 
     lst_src_rnd = deepcopy(lst_src)
     lst_dst_rnd = deepcopy(lst_dst)
@@ -96,15 +101,14 @@ def test_compare():
     shuffle(lst_src_rnd)
     shuffle(lst_dst_rnd)
 
-    to_ins, to_upd, to_del = CalendarSync._events_list_compare(
-        lst_src_rnd, lst_dst_rnd)
+    to_ins, to_upd, to_del = CalendarSync._events_list_compare(lst_src_rnd, lst_dst_rnd)
 
     assert len(to_ins) == part_len
     assert len(to_upd) == part_len
     assert len(to_del) == part_len
 
-    assert sorted(to_ins, key=lambda x: x['iCalUID']) == lst_src[:part_len]
-    assert sorted(to_del, key=lambda x: x['iCalUID']) == lst_dst[part_len:]
+    assert sorted(to_ins, key=lambda x: x["iCalUID"]) == lst_src[:part_len]
+    assert sorted(to_del, key=lambda x: x["iCalUID"]) == lst_dst[part_len:]
 
     to_upd_ok = list(zip(lst_src[part_len:], lst_dst[:part_len]))
     assert len(to_upd) == len(to_upd_ok)
@@ -112,35 +116,29 @@ def test_compare():
         assert item in to_upd
 
 
-@pytest.mark.parametrize("no_time", [True, False], ids=['date', 'dateTime'])
-def test_filter_events_by_date(no_time):
-    msk = timezone('Europe/Moscow')
+@pytest.mark.parametrize("no_time", [True, False], ids=["date", "dateTime"])
+def test_filter_events_by_date(no_time: bool) -> None:
+    msk = timezone("Europe/Moscow")
     now = utc.localize(datetime.datetime.utcnow())
     msk_now = msk.normalize(now.astimezone(msk))
 
     part_len = 5
 
     if no_time:
-        duration = datetime.date(
-            1, 1, 2) - datetime.date(1, 1, 1)
+        duration = datetime.date(1, 1, 2) - datetime.date(1, 1, 1)
     else:
-        duration = datetime.datetime(
-            1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1)
+        duration = datetime.datetime(1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1)
 
-    date_cmp = msk_now + (duration * part_len)
+    date_cmp: DateDateTime = msk_now + (duration * part_len)
 
     if no_time:
-        date_cmp = datetime.date(
-            date_cmp.year, date_cmp.month, date_cmp.day)
+        date_cmp = datetime.date(date_cmp.year, date_cmp.month, date_cmp.day)
 
-    events = gen_events(
-        1, 1 + (part_len * 2), msk_now, no_time)
+    events = gen_events(1, 1 + (part_len * 2), msk_now, no_time)
     shuffle(events)
 
-    events_pending = CalendarSync._filter_events_by_date(
-        events, date_cmp, operator.ge)
-    events_past = CalendarSync._filter_events_by_date(
-        events, date_cmp, operator.lt)
+    events_pending = CalendarSync._filter_events_by_date(events, date_cmp, operator.ge)
+    events_past = CalendarSync._filter_events_by_date(events, date_cmp, operator.lt)
 
     assert len(events_pending) == 1 + part_len
     assert len(events_past) == part_len - 1
@@ -152,26 +150,52 @@ def test_filter_events_by_date(no_time):
         assert get_start_date(event) < date_cmp
 
 
-def test_filter_events_to_update():
-    msk = timezone('Europe/Moscow')
+def test_filter_events_to_update() -> None:
+    msk = timezone("Europe/Moscow")
     now = utc.localize(datetime.datetime.utcnow())
     msk_now = msk.normalize(now.astimezone(msk))
 
-    one_hour = datetime.datetime(
-        1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1)
+    one_hour = datetime.datetime(1, 1, 1, 2) - datetime.datetime(1, 1, 1, 1)
     date_upd = msk_now + (one_hour * 5)
 
     count = 10
     events_old = gen_events(1, 1 + count, msk_now)
     events_new = gen_events(1, 1 + count, date_upd)
 
-    sync1 = CalendarSync(None, None)
+    sync1 = CalendarSync(None, None)  # type: ignore
     sync1.to_update = list(zip(events_new, events_old))
     sync1._filter_events_to_update()
 
-    sync2 = CalendarSync(None, None)
+    sync2 = CalendarSync(None, None)  # type: ignore
     sync2.to_update = list(zip(events_old, events_new))
     sync2._filter_events_to_update()
 
     assert len(sync1.to_update) == count
     assert sync2.to_update == []
+
+
+def test_filter_events_no_updated() -> None:
+    """
+    test filtering events that not have 'updated' field
+    such events should always pass the filter
+    """
+    now = datetime.datetime.utcnow()
+    yesterday = now - datetime.timedelta(days=-1)
+
+    count = 10
+    events_old = gen_events(1, 1 + count, now)
+    events_new = gen_events(1, 1 + count, now)
+
+    # 1/2 updated=yesterday, 1/2 no updated field
+    i = 0
+    for event in events_new:
+        if 0 == i % 2:
+            event["updated"] = yesterday.isoformat() + "Z"
+        else:
+            del event["updated"]
+        i += 1
+
+    sync = CalendarSync(None, None)  # type: ignore
+    sync.to_update = list(zip(events_old, events_new))
+    sync._filter_events_to_update()
+    assert len(sync.to_update) == count // 2