i`dZddlZddlZddlZddlZddlZddlmZddlm Z m Z m Z ddl m Z dZdZ ddlZddlmZddlmZdd lmZd Zn##e$rddlZddlmZddlmZdd lmZd ZYnwxYwdd lmZdd lmZddl Z!dd l!m"Z"ddl#m$Z$ddl#m%Z&ddl#m'Z(ddl)m*Z*m+Z+m,Z,ddl m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:ddl;mej?dkrddl@mAZAnddlmAZAe r ddlBmCZCmDZDmEZE ddl.mFZG d+d ZHGd!d"e<ZIGd#d$e$ZJd%eKd&fd'Z%d,d)ZLd%e d$fd*Z'dS)-z Sync CalDAV client using niquests or requests library. This module provides the traditional synchronous API with protocol layer for XML building and response parsing. For async code, use: from caldav import aio N) TracebackType) TYPE_CHECKINGAnyOptional)unquoteF)AuthBase)Response)CaseInsensitiveDictT)Mapping)etree) __version__) BaseDAVClient) get_calendars) get_davclient)Calendar CalendarSet Principal) FeatureSet)CONNKEYS)cdavdav)error)to_wire)URL)HTTPBearerAuth)BaseDAVResponsecaldav) )Self)CalendarObjectResourceEventTodo)resolve_features ct|trt|}|rdt|vr|dfS|s4|r2dt|vr!|rtd||}|r|rddlm}m} |||t|tr|nd|} | rbt d | j d | j d | j r"td | j | j | j fSn^#|$r'} td | Yd} ~ n7d} ~ wt$r'} td| Yd} ~ nd} ~ wwxYw|dt} |r|rdt|vr d| vr| d}| ddd|| dd}|dfS)a Auto-construct URL from domain and features, with optional RFC6764 discovery. Args: url: User-provided URL, domain, or email address features: FeatureSet object or dict timeout: Timeout for RFC6764 well-known URI lookups ssl_verify_cert: SSL verification setting enable_rfc6764: Whether to attempt RFC6764 discovery username: Username to use for discovery if URL is not provided require_tls: Only accept TLS connections during discovery (default: True) Returns: A tuple of (url_string, discovered_username_or_None) The discovered_username will be extracted from email addresses like user@example.com /N@z7No URL provided, using username for RFC6764 discovery: r)DiscoveryErrordiscover_caldavT) identifiertimeoutssl_verify_cert require_tlszRFC6764 discovered service: z (source: )z Username discovered from email: zRFC6764 discovery failed: zRFC6764 discovery error: zauto-connect.urldomainschemehttps://basepath) isinstancedictrstrlogdebugcaldav.discoveryr)r*boolinfourlsourceusername Exception is_supportedget) r>featuresr,r-enable_rfc6764r@r.r)r* service_infoe url_hintss K/root/projects/butler/venv/lib/python3.11/site-packages/caldav/davclient.py _auto_urlrJ]s2(D!!(h'' sc#hhT{ 8s8}} 4 4 4 VHVVWWW7#7DDDDDDDD 7*?3=ot3T3T ^Z^' L  Ae<3Cee|Obeee (ZIIXAVXXYYY$(,*?@@  A 8 8 8 II6166 7 7 7 7 7 7 7 7 7 7 7 II5!55 6 6 6 6 6 6 6 6 7%%&8$??I "C"C3s88OO(i2G2G! ]]8W - - V V# Vy}}ZQS7T7T V VC ;s%?B D E%D11 E%>E  E%c`eZdZUdZdZedzed<dZedzed< d de de dddfd Z dS) DAVResponsea This class is a response from a DAV request. It is instantiated from the DAVClient class. End users of the library should not need to know anything about this class. Since we often get XML responses, it tries to parse it into `self.tree` Nresults sync_tokenresponse davclient DAVClientreturnc2|||dSN)_init_from_response)selfrOrPs rI__init__zDAVResponse.__init__s   955555rT) __name__ __module__ __qualname____doc__rMlist__annotations__rNr8r rrWrXrIrLrLs GTD[!Jd !!! ,0666K(6  666666rXrLc%eZdZUdZdZedzed<dZeed<dZ e ed< dKdedzdedzd edzd edzd e dzd edzd e dzde ezdee eefzdzdeeefde deezezde de dee dee dee ddf$dZdefdZ dLdedzdedzdedzddfdZdMdZdNdZdNd Zd!Zd"Zdefd#ZdNd$edzdee fd%Z! dOd&e d'e d(e d)e d*e"dzd+e"dzd,e dzd-e d.e"ded/fd0Z#dedzfd1Z$de fd2Z%de fd3Z&dedzfd4Z'de fd5Z(de fd6Z) dPdedzd8e de*fd9Z+dNded:ed;dde*fd<Z,dQded=ed8e dzde*fd>Z-dNded:ed;dde*fd?Z.dRded:ed;dde*fd@Z/dNded:edeeefde*fdAZ0dNded:edeeefde*fdBZ1dede*fdCZ2dede*fdDZ3dNdEeedzddfdFZ4 dSdedHed:edeeefde*f dIZ5 dTdedHed:edeeefde*f dJZ6dS)UrQa Basic client for webdav, uses the niquests lib; gives access to low-level operations towards the caldav server. Unless you have special needs, you should probably care most about the constructor (__init__), the principal method and the calendar method. Nproxyr>F huge_treer5Tr@passwordauth auth_typer,r-ssl_certheadersrDrEr.rate_limit_handlerate_limit_default_sleeprate_limit_max_sleeprRc | pi} t| } t| |_| |_ |jd}t j||_n(#t$rt j|_YnwxYwt||j|pd|| ||\}}t dt|ztj||_|i|}d|vr|jjdz|z}|d}t%|d kr|d z }t d |z||_t)d t*zd dd|_|j| pi|jj2t3|jj}t3|jj}|!||}t d|||_||_||_||_t;|jtr|jd|_|r|jrt?j dn|jr|!||_"||_#| |_$|j%|_t dt|zd|_&|jdtN}|4|r0|(drd}d|vr|d}d|vr|d}nd}||_)||_*||_+dS)a Sets up a HTTPConnection object towards the server in the url. Args: url: A fully qualified url, domain name, or email address. Can be omitted if username is an email address (RFC6764 discovery will use the username). Examples: - Full URL: `https://caldav.example.com/dav/` - Domain: `example.com` (will attempt RFC6764 discovery if enable_rfc6764=True) - Email: `user@example.com` (will attempt RFC6764 discovery if enable_rfc6764=True) - URL with auth: `scheme://user:pass@hostname:port` - Omit URL: Use `username='user@example.com'` for discovery username: Username for authentication. If url is omitted and username contains @, RFC6764 discovery will be attempted using the username as email address. proxy: A string defining a proxy server: `scheme://hostname:port`. Scheme defaults to http, port defaults to 8080. auth: A niquests.auth.AuthBase or requests.auth.AuthBase object, may be passed instead of username/password. username and password should be passed as arguments or in the URL timeout and ssl_verify_cert are passed to niquests.request. if auth_type is given, the auth-object will be auto-created. Auth_type can be ``bearer``, ``digest`` or ``basic``. Things are likely to work without ``auth_type`` set, but if nothing else the number of requests to the server will be reduced, and some servers may require this to squelch warnings of unexpected HTML delivered from the server etc. ssl_verify_cert can be the path of a CA-bundle or False. huge_tree: boolean, enable XMLParser huge_tree to handle big events, beware of security issues, see : https://lxml.de/api/lxml.etree.XMLParser-class.html features: The default, None, will in version 2.x enable all existing workarounds in the code for backward compability. Otherwise it will expect a FeatureSet or a dict as defined in `caldav.compatibility_hints` and use that to figure out what workarounds are needed. enable_rfc6764: boolean, enable RFC6764 DNS-based service discovery for CalDAV/CardDAV. Default: True. When enabled and a domain or email address is provided as url, the library will attempt to discover the CalDAV service using: 1. DNS SRV records (_caldavs._tcp / _caldav._tcp) 2. DNS TXT records for path information 3. Well-Known URIs (/.well-known/caldav) Set to False to disable automatic discovery and rely only on feature hints. SECURITY: See require_tls parameter for security considerations. require_tls: boolean, require TLS (HTTPS) for discovered services. Default: True. When True, RFC6764 discovery will ONLY accept HTTPS connections, preventing DNS-based downgrade attacks where malicious DNS could redirect to unencrypted HTTP. Set to False ONLY if you need to support non-TLS servers and trust your DNS infrastructure. This parameter has no effect if enable_rfc6764=False. rate_limit_handle: boolean, whether to automatically sleep and retry when the server responds with 429 Too Many Requests or 503 Service Unavailable. Default: False (raise RateLimitError immediately). rate_limit_default_sleep: int or None, fallback sleep duration in seconds when the server's 429 response does not include a parseable Retry-After header. None (default) means raise RateLimitError rather than sleeping when no Retry-After is provided. rate_limit_max_sleep: int or None, maximum number of seconds to sleep when rate limited, regardless of the server's Retry-After value. None (default) means there is no cap and the server-requested delay is respected as-is. The niquests library will honor a .netrc-file, if such a file exists username and password may be omitted. THe niquest library will honor standard proxy environmental variables like HTTP_PROXY, HTTPS_PROXY and ALL_PROXY. See https://niquests.readthedocs.io/en/latest/user/advanced.html#proxies If the caldav server is behind a proxy or replies with html instead of xml when returning 401, warnings will be printed which might be unwanted. Check auth parameter for details. zhttp.multiplexing) multiplexedr%)r,r-rEr@r.zurl: Nr3:z:8080zinit - proxy: %szpython-caldav/ztext/xmlztext/xml, text/calendar)z User-Agentz Content-TypeAcceptz(Using discovered username from RFC6764: utf-8zNboth auth object and auth_type sent to DAVClient. The latter will be ignored.z self.url: z rate-limitenableT default_sleep max_sleepF),_resolve_featuresrrDrbrBrequestsSessionsession TypeErrorrJr9r:r8r objectifyr>r1splitlenrar r rgupdater@rrcrdrer6encodeloggingrbuild_auth_objectr,r-rfunauth _principalr7rCrhrirj)rVr>rar@rcrdrer,r-rfrgrbrDrEr.rhrirjrldiscovered_username_proxyp rate_limits rIrWzDAVClient.__init__sZ-R%X.."8,, " .-445HIIK#+ DDDDLL . . .#+--DLLL .$-  MMr+)#$ $ $    'CHH$%%%=%%  FE!!5058  S!!A1vv{{'! II(F3 4 4 4DJ+.< *3      GMr*** 8  (tx011Htx011H   3 ?*H IIKKK L L L     " dmS ) ) : M0099DM  %DN % M`    ^ %  " " $ $ $ .  8??$$ ,S)***]// dCC  $ *jnnX66 *$(!"j00/9//J,*,,+5k+B($)!!2(@%$8!!!s4A%%"B  B ct|dr; |n%#t$r||YnwxYw|S)Nsetup)hasattrrrxrVs rI __enter__zDAVClient.__enter__ws` 4 ! ! ! !  ! ! ! 4      ! s'A A exc_type exc_value tracebackc|t|dr= |dS#t$r||YdSwxYwdS)Nteardown)closerrrx)rVrrrs rI__exit__zDAVClient.__exit__sy 4 $ $ $ $  $ $ $ d###### $ $ $s<AAc8|jdS)z8 Closes the DAVClient's session object. N)rwrrs rIrzDAVClient.closes rXc||}||j|}|jdkr+t j|jd|jd|j|| S)a= Search for principals on the server. Instead of returning the current logged-in principal, this method attempts to query for all principals (or principals matching a name). This may or may not work depending on the permissions and implementation of the calendar server. Args: name: Optional name filter to search for specific principals Returns: List of Principal objects found on the server Raises: ReportError: If the server doesn't support principal search i, z - ) _build_principal_search_queryreportr>statusr ReportErrorreasonraw _parse_principal_search_response_find_objects_and_props)rVnamebodyrOs rIsearch_principalszDAVClient.search_principalss$11$77;;tx.. ?c ! !#x$[$[$[$[X\$[$[\\ \44X5U5U5W5WXXXrXcftjdtd||S)z Deprecated. Use :meth:`search_principals` instead. This method searches for principals on the server. z;principals() is deprecated, use search_principals() insteadrn) stacklevel)r)warningswarnDeprecationWarningr)rVrs rI principalszDAVClient.principalss?  I     %%4%000rXcD|jst|d|i||_|jS)a` Legacy method. Use :meth:`get_principal` for new code. Convenience method, it gives a bit more object-oriented feel to write client.principal() than Principal(client). This method returns a :class:`caldav.Principal` object, with higher-level methods for dealing with the principals calendars. client)rr)rVlargskwargss rI principalzDAVClient.principals0 G'eFtFvFFDOrXc tdd|i|S)a>Returns a calendar object. Typically, a URL should be given as a named parameter (url) No network traffic will be initiated by this method. If you don't know the URL of the calendar, use client.principal().calendar(...) instead, or client.principal().get_calendars() rr_)r)rVrs rIcalendarzDAVClient.calendars..t.v...rXc*|S)awGet the principal (user) for this CalDAV connection. This is the recommended method for new code. It provides API consistency between sync and async clients. Returns: Principal object for the authenticated user. Example:: principal = client.get_principal() calendars = principal.get_calendars() )rrs rI get_principalzDAVClient.get_principals~~rXrcddlm}ddlm}|}t |jjd}||j }|st |j} |}|j d}||j }fd|DS)aGet all calendars for the given principal. This method fetches calendars from the principal's calendar-home-set and returns a list of Calendar objects. Args: principal: Principal object (if None, fetches principal first) Returns: List of Calendar objects. Example: principal = client.get_principal() calendars = client.get_calendars(principal) for cal in calendars: print(f"Calendar: {cal.get_display_name()}") r)(_extract_calendars_from_propfind_results)'_extract_calendar_home_set_from_resultsN)propsdepthcTg|]$}t|j|j|j%S))rr>rid)rr>rcal_id).0r=rVs rI z+DAVClient.get_calendars..!s@    DdhTY4; O O O   rX) !caldav.operations.calendarset_opsrcaldav.operations.principal_opsrrpropfindr8r>CALENDAR_HOME_SET_PROPSrM_make_absolute_urlCALENDAR_LIST_PROPS)rVrextract_calendarsextract_home_setrOcalendar_home_urlcalendar_infoss` rIrzDAVClient.get_calendarss3$              ((I==   .!   -,X-=>>  3!$IM 2 2 !334EFF== *!  +*8+;<<    &    rXreventtodojournalstartendinclude_completedexpandrr!c ,|jd|||||||d| S)aSearch a calendar for events, todos, or journals. This method provides a clean interface to calendar search. Args: calendar: Calendar to search event: Search for events (VEVENT) todo: Search for todos (VTODO) journal: Search for journals (VJOURNAL) start: Start of date range end: End of date range include_completed: Include completed todos (default: False for todos) expand: Expand recurring events **kwargs: Additional search parameters Returns: List of Event/Todo/Journal objects. Example: # Get all events in January 2024 events = client.search_calendar( calendar, event=True, start=datetime(2024, 1, 1), end=datetime(2024, 1, 31), ) )rrrrrrrr_)search) rVrrrrrrrrrs rIsearch_calendarzDAVClient.search_calendar&sDNx  /      rXc ||j}n7#t$r*|t |j}YnwxYw|jddS)z Legacy method. Use :meth:`supports_dav` for new code. Does a probe towards the server and returns the DAV header if it says it supports RFC4918 / DAV, or None otherwise. DAVN)optionsrr>rAr8rgrC)rVrOs rIcheck_dav_supportzDAVClient.check_dav_supportXsz 3 ||DNN$4$4$899HH 3 3 3||CMM22HHH 3##E4000s,/1A#"A#c:|}|duod|vS)z Legacy method. Use :meth:`supports_caldav` for new code. Does a probe towards the server and returns True if it says it supports RFC4791 / CalDAV. Nzcalendar-accessrrV support_lists rIcheck_cdav_supportzDAVClient.check_cdav_supportjs+--// 4'M,=,MMrXc:|}|duod|vS)z Legacy method. Use :meth:`supports_scheduling` for new code. Does a probe towards the server and returns True if it says it supports RFC6638 / CalDAV Scheduling. Nzcalendar-auto-schedulerrs rIcheck_scheduling_supportz"DAVClient.check_scheduling_supportts+--// 4'T,D ,TTrXc*|S)alCheck if the server supports WebDAV (RFC4918). This is the recommended method for new code. It provides API consistency between sync and async clients. Returns: The DAV header value if supported, None otherwise. Example:: if client.supports_dav(): print("Server supports WebDAV") rrs rI supports_davzDAVClient.supports_davs%%'''rXc*|S)atCheck if the server supports CalDAV (RFC4791). This is the recommended method for new code. It provides API consistency between sync and async clients. Returns: True if the server supports CalDAV, False otherwise. Example:: if client.supports_caldav(): calendars = client.get_calendars() )rrs rIsupports_caldavzDAVClient.supports_caldavs&&(((rXc*|S)aCheck if the server supports CalDAV Scheduling (RFC6638). This is the recommended method for new code. It provides API consistency between sync and async clients. Returns: True if the server supports CalDAV Scheduling, False otherwise. Example:: if client.supports_scheduling(): # Server supports free-busy lookups and scheduling pass )rrs rIsupports_schedulingzDAVClient.supports_schedulings,,...rXrrcddlm}d}|6t|tr||d}n|}dt |i}||pt |jd||}|jdvrd|j r]dd l m }t|j tr|j n|j d} || |j|j|_|S) av Send a propfind request. Parameters ---------- url : URL url for the root of the propfind. props : str or List[str] XML body string (old interface) or list of property names (new interface). depth : int maximum recursion depth Returns ------- DAVResponse r)_build_propfind_bodyr5NrpDepthPROPFIND))_parse_propfind_response)caldav.protocol.xml_buildersrr6r]decoder8requestr>r_rawcaldav.protocol.xml_parsersrbytesr}rbrM) rVr>rrrrrgrOr raw_bytess rIrzDAVClient.propfinds, FEEEEE  %&& ++E2299'BBCJJ'<< 4s48}}j$PP ?j ( (X] ( L L L L L L",HM5!A!Ad x}G[G[\cGdGd  878?H,>  H rXrdummyc0||d|S)z Send a proppatch request. Args: url: url for the root of the propfind. body: XML propertyupdate request dummy: compatibility parameter Returns: DAVResponse PROPPATCHrrVr>rrs rI proppatchzDAVClient.proppatchs||Cd333rXqueryc\|dt|ini}||d||S)aL Send a report request. Args: url: url for the root of the propfind. query: XML request depth: maximum recursion depth. None means don't send Depth header (required for calendar-multiget per RFC 4791 section 7.9). Returns DAVResponse NrREPORT)r8r)rVr>rrrgs rIrzDAVClient.reports6,1+<7CJJ''"||C5':::rXc0||d|S)a Send a MKCOL request. MKCOL is basically not used with caldav, one should use MKCALENDAR instead. However, some calendar servers MAY allow "subcollections" to be made in a calendar, by using the MKCOL query. As for 2020-05, this method is not exercised by test code or referenced anywhere else in the caldav library, it's included just for the sake of completeness. And, perhaps this DAVClient class can be used for vCards and other WebDAV purposes. Args: url: url for the root of the mkcol body: XML request dummy: compatibility parameter Returns: DAVResponse MKCOLrrs rImkcolzDAVClient.mkcols*||C$///rXc0||d|S)z Send a mkcalendar request. Args: url: url for the root of the mkcalendar body: XML request dummy: compatibility parameter Returns: DAVResponse MKCALENDARrrs rI mkcalendarzDAVClient.mkcalendars||Ct444rXc2||d||S)z% Send a put request. PUTrrVr>rrgs rIputz DAVClient.put$s||Cg666rXc2||d||S)z& Send a POST request. POSTrrs rIpostzDAVClient.post*s||Cw777rXc0||ddS)z( Send a delete request. DELETEr5rrVr>s rIdeletezDAVClient.delete0s||C2...rXc0||ddS)z* Send an options request. OPTIONSr5rrs rIrzDAVClient.options6s||CB///rX auth_typesc||}|j}t|tr|d}|dkr,t j|j||_dS|dkr,t j |j||_dS|dkrt||_dSdS)a$Build authentication object for the requests/niquests library. Uses shared auth type selection logic from BaseDAVClient, then creates the appropriate auth object for this HTTP library. Args: auth_types: List of acceptable auth types from server. rpdigestbasicbearerN) _select_auth_typercr6rrrurdHTTPDigestAuthr@ HTTPBasicAuthr)rVr rercs rIrzDAVClient.build_auth_object<s**:66 = h & & 0w//H   44T]HMMDIII ' ! ! 33DM8LLDIII ( " "&x00DIII# "rXGETmethodc d |||||S#tj$r}|jstj|j|j|j}|r||dz z }||j ||jkrtj || ||||||zcYd}~Sd}~wwxYw)aJ Send a generic HTTP request. Uses the sync session directly for all operations. Args: url: The URL to request method: HTTP method (GET, PUT, DELETE, etc.) body: Request body headers: Optional headers dict Returns: DAVResponse rnN) _sync_requestrRateLimitErrorrhcompute_sleep_secondsretry_after_secondsrirjtimesleepr)rVr>rrrgrate_limit_time_sleptrG sleep_secondss rIrzDAVClient.requestUs, c%%c64AA A# c c c) !7%-)M % ;!6!:: $)5)D,EEE J} % % %<<VT7rrrgurl_objcombined_headersrr r_headersrOs rIrzDAVClient._sync_requestsn%)$9$9#vtW$U$U!! : !~tz2G II(G4 5 5 5 L  LL$L' ! ( 22  #AM3w<<}A]A]^^^  & &q}i @ @ B  % %i0B&C D D D%%c64AA A =J & &  + +CLL! < < <q$''rX)r5NNNNNNTNNFNTTNNN)NNN)rRNrT)FFFNNNF)NNr)r5r)r5N)rr5Nr)rr5N)7rYrZr[r\rar8r^r>rrbr<rinttupler rr7rrWr r BaseExceptionrrrrrrrrrr]rrrrrrrrrrrLrrrrrrrrrrrrr_rXrIrQrQsE3:COOOIt ## $ $"&*15%),0# ,026.2%o9o9 4Zo9Tzo9* o9 * o9 o o9:o9to9o9c3h'$.o9c"o9o9t#c)o9o9o9 $D>!o9"#+3-#o9$'sm%o9& 'o9o9o9o9b4*.*.*. $ $$& $!4' $!4' $  $ $ $ $ YYYY6 1 1 1 1    / / /  y    9 9 y4'79 4>9 9 9 9 | )-0 0 0 0  0  0 Tz 0 4Z0  $;0 0 0  & '0 0 0 0 d13:1111$NDNNNNU$UUUU(cDj(((( ))))) /T////& .. 4Z. .  ....` 4 4S 4 4D 4K 4 4 4 4;;#;c;sTz;+;;;; 000C00 0000. 5 5c 5 5$ 5+ 5 5 5 577s7#7S0A7[7777 88838c1B8k8888 /#/+//// 030;0000 11DI,<111118%) (c(c (c(c (c c" (c (c(c(c(cZ%) ,, ,, , c" ,  ,,,,,,rXrQrRrc &ttfi|S)a Get calendars from a CalDAV server with configuration from multiple sources. This is a convenience wrapper around :func:`caldav.base_client.get_calendars` that uses DAVClient. Args: calendar_url: URL(s) or ID(s) of specific calendars to fetch. calendar_name: Name(s) of specific calendars to fetch by display name. check_config_file: Whether to look for config files (default: True). config_file: Explicit path to config file. config_section: Section name in config file. testconfig: Whether to use test server configuration. environment: Whether to read from environment variables (default: True). name: Name of test server to use (for testconfig). raise_errors: If True, raise exceptions on errors; if False, log and skip. **config_data: Connection parameters (url, username, password, etc.) Returns: List of Calendar objects matching the criteria. Example:: from caldav import get_calendars # Get all calendars calendars = get_calendars(url="https://...", username="...", password="...") # Get specific calendar by name calendars = get_calendars(calendar_name="Work", url="...", ...) )_base_get_calendarsrQrs rIrrs@ y 3 3F 3 33rXCalendarResultc nddlm}ttfi|}|r|dnd}|||jS)a Get a single calendar from a CalDAV server. This is a convenience function for the common case where only one calendar is needed. Returns a CalendarResult that can be used as a context manager. Args: Same as :func:`get_calendars`. Returns: CalendarResult wrapping a Calendar object (or None if not found). Use as context manager to auto-close the connection. Example:: from caldav import get_calendar with get_calendar(calendar_name="Work", url="...", ...) as calendar: if calendar: events = calendar.date_search(start=..., end=...) r)r1N)r)caldav.base_clientr1r/rQr)rr1 calendarsrs rI get_calendarr5sU.211111#I8888I(2y||dH >(9+; < < <rVs  //////////    &&&&&&((((((777777MMOOO&&&&&&((((((777777MMM $#####!!!!,,,,,,CCCCCCCCCCCC>>>>>>>>>>111111#"""""%%%%%%%%//////******++++++g!!g&&&&&&&RQQQQQQQQQQ&@?????  CCCCL66666/666,r r r r r  r r r j 4tJ/ 4 4 4 4F====< 4x 4 4 4 4 4 4 4sA A+*A+