10 | {% endblock %}
11 |
--------------------------------------------------------------------------------
/tests/google_calendar_tests/test_colors_service.py:
--------------------------------------------------------------------------------
1 | from tests.google_calendar_tests.test_case_with_mocked_service import TestCaseWithMockedService
2 |
3 |
4 | class TestColorsService(TestCaseWithMockedService):
5 | def test_list_event_colors(self):
6 | event_colors = self.gc.list_event_colors()
7 | self.assertEqual(len(event_colors), 4)
8 |
9 | def test_list_calendar_colors(self):
10 | calendar_colors = self.gc.list_calendar_colors()
11 | self.assertEqual(len(calendar_colors), 5)
12 |
--------------------------------------------------------------------------------
/docs/source/_static/css/custom.css:
--------------------------------------------------------------------------------
1 | /* Newlines (\a) and spaces (\20) before each parameter */
2 | .sig-param::before {
3 | content: "\a\20\20\20\20\20\20\20\20\20\20\20\20\20\20\20\20";
4 | white-space: pre;
5 | }
6 |
7 | /* Newline after the last parameter (so the closing bracket is on a new line) */
8 | dt em.sig-param:last-of-type::after {
9 | content: "\a";
10 | white-space: pre;
11 | }
12 |
13 | /* To have blue background of width of the block (instead of width of content) */
14 | dl.class > dt:first-of-type {
15 | display: block !important;
16 | }
--------------------------------------------------------------------------------
/gcsa/_services/settings_service.py:
--------------------------------------------------------------------------------
1 | from gcsa._services.base_service import BaseService
2 | from gcsa.serializers.settings_serializer import SettingsSerializer
3 | from gcsa.settings import Settings
4 |
5 |
6 | class SettingsService(BaseService):
7 | """Settings management methods of the `GoogleCalendar`"""
8 |
9 | def get_settings(self) -> Settings:
10 | """Returns user settings for the authenticated user."""
11 | settings_list = list(self._list_paginated(self.service.settings().list))
12 | settings_json = {s['id']: s['value'] for s in settings_list}
13 | return SettingsSerializer.to_object(settings_json)
14 |
--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
1 | # Minimal makefile for Sphinx documentation
2 | #
3 |
4 | # You can set these variables from the command line.
5 | SPHINXOPTS =
6 | SPHINXBUILD = sphinx-build
7 | SOURCEDIR = source
8 | BUILDDIR = build
9 |
10 | # Put it first so that "make" without argument is like "make help".
11 | help:
12 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
13 |
14 | .PHONY: help Makefile
15 |
16 | # Catch-all target: route all unknown targets to Sphinx using the new
17 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
18 | %: Makefile
19 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
--------------------------------------------------------------------------------
/tests/google_calendar_tests/test_case_with_mocked_service.py:
--------------------------------------------------------------------------------
1 | from unittest.mock import patch
2 |
3 | from pyfakefs.fake_filesystem_unittest import TestCase
4 |
5 | from gcsa.google_calendar import GoogleCalendar
6 | from tests.google_calendar_tests.mock_services.mock_service import MockService
7 | from tests.google_calendar_tests.mock_services.util import MockToken
8 |
9 |
10 | class TestCaseWithMockedService(TestCase):
11 | def setUp(self):
12 | self.build_patcher = patch('googleapiclient.discovery.build', return_value=MockService())
13 | self.build_patcher.start()
14 |
15 | self.gc = GoogleCalendar(credentials=MockToken(valid=True))
16 |
17 | def tearDown(self):
18 | self.build_patcher.stop()
19 |
--------------------------------------------------------------------------------
/.github/workflows/tests.yml:
--------------------------------------------------------------------------------
1 | name: Tests
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 | pull_request:
8 |
9 | jobs:
10 | run:
11 |
12 | runs-on: ubuntu-latest
13 | strategy:
14 | matrix:
15 | python-version: [ '3.9', '3.10', '3.11', '3.12', '3.13' ]
16 | include:
17 | - python-version: '3.13'
18 | note: with-style-and-docs-checks
19 |
20 | steps:
21 | - uses: actions/checkout@v2
22 | - name: Set up Python ${{ matrix.python-version }}
23 | uses: actions/setup-python@v2
24 | with:
25 | python-version: ${{ matrix.python-version }}
26 |
27 | - name: Install tox
28 | run: pip install tox tox-gh-actions
29 |
30 | - name: Running tests
31 | run: tox
32 |
--------------------------------------------------------------------------------
/gcsa/_services/colors_service.py:
--------------------------------------------------------------------------------
1 | from gcsa._services.base_service import BaseService
2 |
3 |
4 | class ColorsService(BaseService):
5 | """Colors management methods of the `GoogleCalendar`"""
6 |
7 | def list_event_colors(self) -> dict:
8 | """A global palette of event colors, mapping from the color ID to its definition.
9 | An :py:class:`~gcsa.event.Event` may refer to one of these color IDs in its color_id field."""
10 | return self.service.colors().get().execute()['event']
11 |
12 | def list_calendar_colors(self) -> dict:
13 | """A global palette of calendar colors, mapping from the color ID to its definition.
14 | :py:class:`~gcsa.calendar.CalendarListEntry` resource refers to one of these color IDs in its color_id field."""
15 | return self.service.colors().get().execute()['calendar']
16 |
--------------------------------------------------------------------------------
/gcsa/serializers/person_serializer.py:
--------------------------------------------------------------------------------
1 | from gcsa.person import Person
2 | from .base_serializer import BaseSerializer
3 |
4 |
5 | class PersonSerializer(BaseSerializer):
6 | type_ = Person
7 |
8 | def __init__(self, person):
9 | super().__init__(person)
10 |
11 | @staticmethod
12 | def _to_json(person: Person):
13 | data = {
14 | 'email': person.email,
15 | 'displayName': person.display_name
16 | }
17 | return {k: v for k, v in data.items() if v is not None}
18 |
19 | @staticmethod
20 | def _to_object(json_person):
21 | return Person(
22 | email=json_person['email'],
23 | display_name=json_person.get('displayName', None),
24 | _id=json_person.get('id', None),
25 | _is_self=json_person.get('self', None)
26 | )
27 |
--------------------------------------------------------------------------------
/.github/workflows/code-cov.yml:
--------------------------------------------------------------------------------
1 | name: Code coverage
2 |
3 | on: [pull_request]
4 |
5 | jobs:
6 | run:
7 | # Don't run on PRs from forks
8 | if: github.event.pull_request.head.repo.full_name == github.repository
9 | runs-on: ubuntu-latest
10 |
11 | steps:
12 | - uses: actions/checkout@v2
13 | - name: Set up Python
14 | uses: actions/setup-python@v2
15 | with:
16 | python-version: '3.12'
17 |
18 | - name: Install dependencies
19 | run: pip install tox
20 |
21 | - name: Generate code coverage
22 | run: tox -e coverage
23 |
24 |
25 | - name: Post to GitHub
26 | uses: 5monkeys/cobertura-action@master
27 | with:
28 | path: coverage.xml
29 | repo_token: ${{ secrets.GITHUB_TOKEN }}
30 | minimum_coverage: 75
31 | skip_covered: false
32 |
--------------------------------------------------------------------------------
/gcsa/serializers/reminder_serializer.py:
--------------------------------------------------------------------------------
1 | from gcsa.reminders import Reminder, EmailReminder, PopupReminder
2 | from .base_serializer import BaseSerializer
3 |
4 |
5 | class ReminderSerializer(BaseSerializer):
6 | type_ = Reminder
7 |
8 | def __init__(self, reminder):
9 | super().__init__(reminder)
10 |
11 | @staticmethod
12 | def _to_json(reminder: Reminder):
13 | return {
14 | 'method': reminder.method,
15 | 'minutes': reminder.minutes_before_start
16 | }
17 |
18 | @staticmethod
19 | def _to_object(json_reminder):
20 | method = json_reminder['method']
21 | if method == 'email':
22 | return EmailReminder(int(json_reminder['minutes']))
23 | elif method == 'popup':
24 | return PopupReminder(int(json_reminder['minutes']))
25 | else:
26 | raise ValueError('Unexpected method "{}" for a reminder.'.format(method))
27 |
--------------------------------------------------------------------------------
/tests/test_util.py:
--------------------------------------------------------------------------------
1 | from unittest import TestCase
2 |
3 | from beautiful_date import Sept
4 |
5 | from gcsa.util.date_time_util import ensure_localisation
6 |
7 |
8 | class TestReminder(TestCase):
9 | def test_ensure_localisation(self):
10 | initial_date = 23 / Sept / 2022
11 | d = ensure_localisation(initial_date)
12 | # Shouldn't do anything to date
13 | self.assertEqual(initial_date, d)
14 |
15 | initial_date_time = initial_date[:]
16 | self.assertIsNone(initial_date_time.tzinfo)
17 | dt_with_tz = ensure_localisation(initial_date_time)
18 | self.assertIsNotNone(dt_with_tz.tzinfo)
19 | self.assertNotEqual(dt_with_tz, initial_date_time)
20 |
21 | dt_with_tz_unchanged = ensure_localisation(dt_with_tz)
22 | self.assertEqual(dt_with_tz, dt_with_tz_unchanged)
23 |
24 | with self.assertRaises(TypeError):
25 | ensure_localisation('Hello')
26 |
--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
1 | @ECHO OFF
2 |
3 | pushd %~dp0
4 |
5 | REM Command file for Sphinx documentation
6 |
7 | if "%SPHINXBUILD%" == "" (
8 | set SPHINXBUILD=sphinx-build
9 | )
10 | set SOURCEDIR=source
11 | set BUILDDIR=build
12 |
13 | if "%1" == "" goto help
14 |
15 | %SPHINXBUILD% >NUL 2>NUL
16 | if errorlevel 9009 (
17 | echo.
18 | echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
19 | echo.installed, then set the SPHINXBUILD environment variable to point
20 | echo.to the full path of the 'sphinx-build' executable. Alternatively you
21 | echo.may add the Sphinx directory to PATH.
22 | echo.
23 | echo.If you don't have Sphinx installed, grab it from
24 | echo.http://sphinx-doc.org/
25 | exit /b 1
26 | )
27 |
28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
29 | goto end
30 |
31 | :help
32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
33 |
34 | :end
35 | popd
36 |
--------------------------------------------------------------------------------
/tests/google_calendar_tests/test_settings_service.py:
--------------------------------------------------------------------------------
1 | from tests.google_calendar_tests.test_case_with_mocked_service import TestCaseWithMockedService
2 |
3 |
4 | class TestSettingsService(TestCaseWithMockedService):
5 | def test_get_settings(self):
6 | settings = self.gc.get_settings()
7 | self.assertTrue(settings.auto_add_hangouts)
8 | self.assertEqual(settings.date_field_order, 'DMY')
9 | self.assertEqual(settings.default_event_length, 45)
10 | self.assertTrue(settings.format24_hour_time)
11 | self.assertTrue(settings.hide_invitations)
12 | self.assertTrue(settings.hide_weekends)
13 | self.assertEqual(settings.locale, 'cz')
14 | self.assertTrue(settings.remind_on_responded_events_only)
15 | self.assertFalse(settings.show_declined_events)
16 | self.assertEqual(settings.timezone, 'Europe/Prague')
17 | self.assertFalse(settings.use_keyboard_shortcuts)
18 | self.assertEqual(settings.week_start, 1)
19 |
--------------------------------------------------------------------------------
/gcsa/serializers/acl_rule_serializer.py:
--------------------------------------------------------------------------------
1 | from gcsa.acl import AccessControlRule
2 | from gcsa.serializers.base_serializer import BaseSerializer
3 |
4 |
5 | class ACLRuleSerializer(BaseSerializer):
6 | type_ = AccessControlRule
7 |
8 | def __init__(self, access_control_rule):
9 | super().__init__(access_control_rule)
10 |
11 | @staticmethod
12 | def _to_json(acl_rule: AccessControlRule):
13 | data = {
14 | "id": acl_rule.id,
15 | "scope": {
16 | "type": acl_rule.scope_type,
17 | "value": acl_rule.scope_value
18 | },
19 | "role": acl_rule.role
20 | }
21 | data = ACLRuleSerializer._remove_empty_values(data)
22 | return data
23 |
24 | @staticmethod
25 | def _to_object(json_acl_rule):
26 | scope = json_acl_rule.get('scope', {})
27 | return AccessControlRule(
28 | acl_id=json_acl_rule.get('id'),
29 | scope_type=scope.get('type'),
30 | scope_value=scope.get('value'),
31 | role=json_acl_rule.get('role')
32 | )
33 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2017
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/gcsa/serializers/attachment_serializer.py:
--------------------------------------------------------------------------------
1 | from gcsa.attachment import Attachment
2 | from .base_serializer import BaseSerializer
3 |
4 |
5 | class AttachmentSerializer(BaseSerializer):
6 | type_ = Attachment
7 |
8 | def __init__(self, attachment):
9 | super().__init__(attachment)
10 |
11 | @staticmethod
12 | def _to_json(attachment: Attachment):
13 | res = {
14 | "fileUrl": attachment.file_url,
15 | "title": attachment.title,
16 | "mimeType": attachment.mime_type,
17 | }
18 |
19 | if attachment.file_id:
20 | res['fileId'] = attachment.file_id
21 | if attachment.icon_link:
22 | res['iconLink'] = attachment.icon_link
23 |
24 | return res
25 |
26 | @staticmethod
27 | def _to_object(json_attachment):
28 | return Attachment(
29 | file_url=json_attachment['fileUrl'],
30 | title=json_attachment.get('title', None),
31 | mime_type=json_attachment.get('mimeType', None),
32 | _icon_link=json_attachment.get('iconLink', None),
33 | _file_id=json_attachment.get('fileId', None)
34 | )
35 |
--------------------------------------------------------------------------------
/tests/google_calendar_tests/mock_services/mock_settings_requests.py:
--------------------------------------------------------------------------------
1 | from .util import executable
2 |
3 |
4 | class MockSettingsRequests:
5 | """Emulates GoogleCalendar.service.settings()"""
6 |
7 | @executable
8 | def list(self, **_):
9 | """Emulates GoogleCalendar.service.settings().list().execute()"""
10 | return {
11 | "nextPageToken": None,
12 | "items": [
13 | {'id': 'autoAddHangouts', 'value': True},
14 | {'id': 'dateFieldOrder', 'value': 'DMY'},
15 | {'id': 'defaultEventLength', 'value': 45},
16 | {'id': 'format24HourTime', 'value': True},
17 | {'id': 'hideInvitations', 'value': True},
18 | {'id': 'hideWeekends', 'value': True},
19 | {'id': 'locale', 'value': 'cz'},
20 | {'id': 'remindOnRespondedEventsOnly', 'value': True},
21 | {'id': 'showDeclinedEvents', 'value': False},
22 | {'id': 'timezone', 'value': 'Europe/Prague'},
23 | {'id': 'useKeyboardShortcuts', 'value': False},
24 | {'id': 'weekStart', 'value': 1}
25 | ]
26 | }
27 |
--------------------------------------------------------------------------------
/tests/google_calendar_tests/mock_services/mock_colors_requests.py:
--------------------------------------------------------------------------------
1 | from .util import executable
2 |
3 |
4 | class MockColorsRequests:
5 | """Emulates GoogleCalendar.service.colors()"""
6 |
7 | def __init__(self):
8 | self.test_colors = {
9 | 'event': {
10 | '1': {'background': '#a4bdfc', 'foreground': '#1d1d1d'},
11 | '2': {'background': '#7ae7bf', 'foreground': '#1d1d1d'},
12 | '3': {'background': '#dbadff', 'foreground': '#1d1d1d'},
13 | '4': {'background': '#ff887c', 'foreground': '#1d1d1d'},
14 | },
15 | 'calendar': {
16 | '1': {'background': '#ac725e', 'foreground': '#1d1d1d'},
17 | '2': {'background': '#d06b64', 'foreground': '#1d1d1d'},
18 | '3': {'background': '#f83a22', 'foreground': '#1d1d1d'},
19 | '4': {'background': '#fa573c', 'foreground': '#1d1d1d'},
20 | '5': {'background': '#fc573c', 'foreground': '#1d1d1d'},
21 | }
22 | }
23 |
24 | @executable
25 | def get(self, **_):
26 | """Emulates GoogleCalendar.service.colors().get().execute()"""
27 | return self.test_colors
28 |
--------------------------------------------------------------------------------
/docs/source/code/google_calendar.rst:
--------------------------------------------------------------------------------
1 | GoogleCalendar
2 | ==============
3 |
4 | .. autoclass:: gcsa.google_calendar.GoogleCalendar
5 | :members:
6 | get_events,
7 | get_instances,
8 | get_event,
9 | add_event,
10 | add_quick_event,
11 | update_event,
12 | import_event,
13 | move_event,
14 | delete_event,
15 | get_calendar,
16 | add_calendar,
17 | update_calendar,
18 | delete_calendar,
19 | clear_calendar,
20 | clear,
21 | get_calendar_list,
22 | get_calendar_list_entry,
23 | add_calendar_list_entry,
24 | update_calendar_list_entry,
25 | delete_calendar_list_entry,
26 | list_event_colors,
27 | list_calendar_colors,
28 | get_acl_rules,
29 | get_acl_rule,
30 | add_acl_rule,
31 | update_acl_rule,
32 | delete_acl_rule,
33 | get_free_busy,
34 | get_settings
35 | :undoc-members:
36 |
37 | .. autoclass:: gcsa.google_calendar.SendUpdatesMode
38 | :members:
39 | :undoc-members:
40 |
--------------------------------------------------------------------------------
/docs/source/settings.rst:
--------------------------------------------------------------------------------
1 | .. _settings:
2 |
3 | Settings
4 | ========
5 |
6 | You can retrieve user's settings for the given account with :py:meth:`~gcsa.google_calendar.GoogleCalendar.get_settings`.
7 |
8 | To do so, create a :py:class:`~gcsa.google_calendar.GoogleCalendar` instance (see :ref:`getting_started` to get your
9 | credentials):
10 |
11 | .. code-block:: python
12 |
13 | from gcsa.google_calendar import GoogleCalendar
14 |
15 | gc = GoogleCalendar()
16 |
17 |
18 | Following code will return a corresponding :py:class:`~gcsa.settings.Settings` object:
19 |
20 | .. code-block:: python
21 |
22 | from gcsa.google_calendar import GoogleCalendar
23 |
24 | gc = GoogleCalendar()
25 | settings = gc.get_settings()
26 | print(settings)
27 |
28 | .. code-block:: python
29 |
30 | User settings:
31 | auto_add_hangouts=true
32 | date_field_order=DMY
33 | default_event_length=60
34 | format24_hour_time=false
35 | hide_invitations=false
36 | hide_weekends=false
37 | locale=en
38 | remind_on_responded_events_only=false
39 | show_declined_events=true
40 | timezone=Europe/Prague
41 | use_keyboard_shortcuts=true
42 | week_start=1
43 |
44 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | envlist = pytest, code-cov, flake8, sphinx, mypy
3 |
4 | [gh-actions]
5 | python =
6 | 3.9: pytest
7 | 3.10: pytest
8 | 3.11: pytest
9 | 3.12: pytest
10 | 3.13: pytest, flake8, sphinx, mypy
11 |
12 | [flake8]
13 | max-line-length = 120
14 | per-file-ignores =
15 | # naming conventions broken by googleapiclient
16 | tests/google_calendar_tests/mock_services/*: N802,N803
17 |
18 | [coverage:report]
19 | exclude_lines =
20 | # Have to re-enable the standard pragma
21 | pragma: no cover
22 |
23 | # Don't complain if tests don't hit defensive assertion code:
24 | pass
25 | omit =
26 | */__init__.py
27 |
28 |
29 | [testenv:pytest]
30 | deps =
31 | pyfakefs
32 | pytest
33 | commands =
34 | pytest
35 |
36 | [testenv:coverage]
37 | deps =
38 | pyfakefs
39 | pytest
40 | pytest-cov
41 | commands =
42 | pytest --cov-report xml --cov=gcsa tests
43 |
44 | [testenv:flake8]
45 | deps =
46 | flake8
47 | pep8-naming
48 | commands =
49 | flake8 gcsa tests setup.py
50 |
51 | [testenv:mypy]
52 | deps =
53 | mypy
54 | commands =
55 | mypy --disable-error-code=import-untyped gcsa
56 |
57 | [testenv:sphinx]
58 | deps =
59 | sphinx
60 | sphinx_rtd_theme
61 | sphinxcontrib-googleanalytics
62 | commands =
63 | sphinx-build -W docs/source docs/build
64 |
--------------------------------------------------------------------------------
/docs/source/attachments.rst:
--------------------------------------------------------------------------------
1 | .. _attachments:
2 |
3 | Attachments
4 | -----------
5 |
6 | If you want to add attachment(s) to your event, just create :py:class:`~gcsa.attachment.Attachment` (s) and pass
7 | as a ``attachments`` parameter:
8 |
9 | .. code-block:: python
10 |
11 | from gcsa.attachment import Attachment
12 |
13 | attachment = Attachment(file_url='https://bit.ly/3lZo0Cc',
14 | title='My file',
15 | mime_type='application/vnd.google-apps.document')
16 |
17 | event = Event('Meeting',
18 | start=(22/Apr/2019)[12:00],
19 | attachments=attachment)
20 |
21 |
22 | You can pass multiple attachments at once in a list.
23 |
24 | .. code-block:: python
25 |
26 | event = Event('Meeting',
27 | start=(22/Apr/2019)[12:00],
28 | attachments=[attachment1, attachment2])
29 |
30 | To add attachment to an existing event use its :py:meth:`~gcsa.event.Event.add_attachment` method:
31 |
32 |
33 | .. code-block:: python
34 |
35 | event.add_attachment('My file',
36 | file_url='https://bit.ly/3lZo0Cc',
37 | mime_type='application/vnd.google-apps.document')
38 |
39 | Update event using :py:meth:`~gcsa.google_calendar.GoogleCalendar.update_event` method to save the changes.
40 |
--------------------------------------------------------------------------------
/gcsa/serializers/attendee_serializer.py:
--------------------------------------------------------------------------------
1 | from gcsa.attendee import Attendee
2 | from .base_serializer import BaseSerializer
3 |
4 |
5 | class AttendeeSerializer(BaseSerializer):
6 | type_ = Attendee
7 |
8 | def __init__(self, attendee):
9 | super().__init__(attendee)
10 |
11 | @staticmethod
12 | def _to_json(attendee: Attendee):
13 | data = {
14 | 'email': attendee.email,
15 | 'displayName': attendee.display_name,
16 | 'comment': attendee.comment,
17 | 'optional': attendee.optional,
18 | 'resource': attendee.is_resource,
19 | 'additionalGuests': attendee.additional_guests,
20 | 'responseStatus': attendee.response_status
21 | }
22 | return {k: v for k, v in data.items() if v is not None}
23 |
24 | @staticmethod
25 | def _to_object(json_attendee):
26 | return Attendee(
27 | email=json_attendee['email'],
28 | display_name=json_attendee.get('displayName', None),
29 | comment=json_attendee.get('comment', None),
30 | optional=json_attendee.get('optional', None),
31 | is_resource=json_attendee.get('resource', None),
32 | additional_guests=json_attendee.get('additionalGuests', None),
33 | _response_status=json_attendee.get('responseStatus', None)
34 | )
35 |
--------------------------------------------------------------------------------
/tests/google_calendar_tests/mock_services/mock_service.py:
--------------------------------------------------------------------------------
1 | from .mock_acl_requests import MockACLRequests
2 | from .mock_calendar_list_requests import MockCalendarListRequests
3 | from .mock_calendars_requests import MockCalendarsRequests
4 | from .mock_colors_requests import MockColorsRequests
5 | from .mock_events_requests import MockEventsRequests
6 | from .mock_free_busy_requests import MockFreeBusyRequests
7 | from .mock_settings_requests import MockSettingsRequests
8 |
9 |
10 | class MockService:
11 | """Emulates GoogleCalendar.service"""
12 |
13 | def __init__(self):
14 | self._events = MockEventsRequests()
15 | self._calendars = MockCalendarsRequests()
16 | self._calendar_list = MockCalendarListRequests()
17 | self._colors = MockColorsRequests()
18 | self._settings = MockSettingsRequests()
19 | self._acl = MockACLRequests()
20 | self._free_busy = MockFreeBusyRequests()
21 |
22 | def events(self):
23 | return self._events
24 |
25 | def calendars(self):
26 | return self._calendars
27 |
28 | def calendarList(self):
29 | return self._calendar_list
30 |
31 | def colors(self):
32 | return self._colors
33 |
34 | def settings(self):
35 | return self._settings
36 |
37 | def acl(self):
38 | return self._acl
39 |
40 | def freebusy(self):
41 | return self._free_busy
42 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Bug report
3 | about: Create a report to help us improve
4 | title: ''
5 | labels: ''
6 | assignees: ''
7 |
8 | ---
9 |
10 | [READ and REMOVE: Please create an issue only if you think that it's something that needs a fix or you have a
11 | suggestion/request for improvement. If you have a question or issue not caused by gcsa itself, please use
12 | the [discussions page](https://github.com/kuzmoyev/google-calendar-simple-api/discussions).]
13 |
14 | ## Bug description
15 |
16 | A clear and concise description of what the bug is.
17 |
18 | ## To Reproduce
19 |
20 | Steps to reproduce the behavior:
21 |
22 | 1. Installed the latest version with `pip install gcsa`
23 | 2. ...
24 |
25 | Code used:
26 |
27 | ```python
28 | from gcsa.google_calendar import GoogleCalendar
29 |
30 | ...
31 | ```
32 |
33 | ## Error or unexpected output
34 |
35 | The whole traceback in case of an error:
36 | ```
37 | Traceback (most recent call last):
38 | ...
39 | ```
40 |
41 | ## Expected behavior
42 |
43 | A clear and concise description of what you expected to happen.
44 |
45 | ## Screenshots
46 |
47 | If applicable, add screenshots to help explain your problem.
48 |
49 | ## Tech:
50 |
51 | - OS: [e.g. Linux/Windows/MacOS]
52 | - GCSA version: [e.g. 2.0.1]
53 | - Python version: [e.g. 3.12]
54 |
55 | ## Additional context
56 |
57 | Add any other context about the problem here.
58 |
--------------------------------------------------------------------------------
/tests/google_calendar_tests/mock_services/util.py:
--------------------------------------------------------------------------------
1 | import webbrowser
2 |
3 |
4 | class MockToken:
5 | def __init__(self, valid, refresh_token='refresh_token'):
6 | self.valid = valid
7 | self.expired = not valid
8 | self.refresh_token = refresh_token
9 |
10 | def refresh(self, _):
11 | self.valid = True
12 | self.expired = False
13 |
14 |
15 | class MockAuthFlow:
16 | def __init__(self, has_browser=True):
17 | self.has_browser = has_browser
18 |
19 | def run_local_server(self, *args, open_browser=True, **kwargs):
20 | if not self.has_browser and open_browser:
21 | raise webbrowser.Error
22 |
23 | return MockToken(valid=True)
24 |
25 |
26 | def executable(fn):
27 | """Decorator that stores data received from the function in object that returns that data when
28 | called its `execute` method. Emulates HttpRequest from googleapiclient."""
29 |
30 | class Executable:
31 | def __init__(self, data):
32 | self.data = data
33 |
34 | def execute(self):
35 | return self.data
36 |
37 | def wrapper(*args, **kwargs):
38 | data = fn(*args, **kwargs)
39 | return Executable(data)
40 |
41 | return wrapper
42 |
43 |
44 | def within(dt, time_min, time_max):
45 | return time_min <= dt <= time_max
46 |
47 |
48 | def time_range_within(tr, time_min, time_max):
49 | start, end = tr
50 | return within(start, time_min, time_max) and within(end, time_min, time_max)
51 |
--------------------------------------------------------------------------------
/tests/test_person.py:
--------------------------------------------------------------------------------
1 | from unittest import TestCase
2 |
3 | from gcsa.person import Person
4 | from gcsa.serializers.person_serializer import PersonSerializer
5 |
6 |
7 | class TestPerson(TestCase):
8 | def test_repr_str(self):
9 | person = Person(
10 | email='mail@gmail.com',
11 | display_name='Guest',
12 | _id='123123',
13 | _is_self=False
14 | )
15 | self.assertEqual(person.__repr__(), "