a
    %@c)3                     @   sL  d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlm	Z	 ddlm
Z
 ddlZd	d
 Zdd Zdd Zd6ddZdd ZedZedZedZedZedZedZdd Zd7ddZed Zd!d" Zd8d%d&Zd9d'd(ZG d)d* d*eZd+d, Zd-d. Z d/d0 Z!G d1d2 d2ej"Z#G d3d4 d4e$Z%dd5l&m'Z' dS ):a  This module parses and generates contentlines as defined in RFC 2445
(iCalendar), but will probably work for other MIME types with similar syntax.
Eg. RFC 2426 (vCard)

It is stupid in the sense that it treats the content purely as strings. No type
conversion is attempted.
    )unicode_literals)compat)CaselessDict)DEFAULT_ENCODING)SEQUENCE_TYPES)
to_unicodeNc                 C   sJ   t | tjtjfsJ | ddddddddd	d
dd
S )z=Format value according to iCalendar TEXT escaping rules.
    \N
\\\;\;,\,
\n
isinstancer   unicode_typeZ
bytes_typereplacetext r   S/var/www/dev/btcams2022/python_venv/lib/python3.9/site-packages/icalendar/parser.pyescape_char   s    r   c                 C   s   t | tjtjfsJ t | tjrV| ddddddddddd	d
S t | tjr| ddddddddddddS d S )Nr   r   r   r	   r   r   r   r   r   r
   s   \Ns   \n   
   
s   \,   ,s   \;   ;s   \\   \r   r   r   r   r   unescape_char!   s2    r    c                 C   sN   d }t | jdr| jj}n0t | jdrJz| j| }W n tyH   Y n0 |S )Nzonetzname)hasattrtzinfor!   r"   AttributeError)dtZtzidr   r   r   tzid_from_dt4   s    
r'   K   
 c              	      s   t tjsJ dvsJ zd W n ttfy@   Y n,0 | fddtdt d D S g }d}D ]:}t|t	}||7 }| kr|
| |}|
| qxd|S )a  Make a string folded as defined in RFC5545
    Lines of text SHOULD NOT be longer than 75 octets, excluding the line
    break.  Long content lines SHOULD be split into a multiple line
    representations using a line "folding" technique.  That is, a long
    line can be split between any two characters by inserting a CRLF
    immediately followed by a single linear white-space character (i.e.,
    SPACE or HTAB).
    r	   asciic                 3   s"   | ]}||  d   V  qdS )   Nr   ).0ilimitliner   r   	<genexpr>S   s   zfoldline.<locals>.<genexpr>r   r+    )r   r   r   encodeUnicodeEncodeErrorUnicodeDecodeErrorjoinrangelenr   append)r0   r/   Zfold_sepZ	ret_charsZ
byte_countcharZchar_byte_lenr   r.   r   foldlineA   s&    	
r;   c                 C   s   t | trt| S t| S )zReturns a parameter value.
    )r   r   q_joindquote)valuer   r   r   param_valueg   s    
r?   z[\w.-]+z[ -
-",:;]z
[ -
-"]s
   (?
)+[ 	]z
(?
)+[ 	]z\r?\nc                 C   s2   t | }t|dkr&| |d kr&d S t| d S )Nr+   r   )NAMEfindallr8   
ValueError)namematchr   r   r   validate_token|   s    
rE   Tc                 C   s"   |rt nt}|| rt| d S N)QUNSAFE_CHARUNSAFE_CHARrA   rB   )r>   quotedZ	validatorr   r   r   validate_param_value   s    
rJ   u
   [,;: ’']c                 C   s"   |  dd} t| rd|  S | S )z@Enclose parameter values containing [,;:] in double quotes.
    "'z"%s")r   QUOTABLEsearchvalr   r   r   r=      s    
r=   r   c           
      C   s   |dkr| gS g }d}t | }d}d}t|D ]r}| | }	|	dkrH| }|sv|	|krv|| ||  |d }|d7 }|d |ks||kr.|| |d   qq.|S )zISplits a string on char, taking double (q)uotes into considderation.
    r   rK   r+   N)r8   r7   r9   )
stsepmaxsplitresultcursorlengthZinquotesplitsr-   chr   r   r   q_split   s&    rZ   c                 C   s   | dd | D S )z>Joins a list on sep, quoting strings with QUOTABLE chars.
    c                 s   s   | ]}t |V  qd S rF   )r=   )r,   Zitmr   r   r   r1          zq_join.<locals>.<genexpr>r6   )lstrS   r   r   r   r<      s    r<   c                   @   s0   e Zd ZdZdd ZdddZeddd	Zd
S )
ParameterszParser and generator of Property parameter strings. It knows nothing of
    datatypes. Its main concern is textual structure.
    c                 C   s   |   S )zoIn rfc2445 keys are called parameters, so this is to be consitent
        with the naming conventions.
        )keysselfr   r   r   params   s    zParameters.paramsTc                 C   sr   g }t |  }|r|  |D ]F\}}t|}t|tjrF|t}|	 t}|
|d |  q d|S )N   =r   )listitemssortr?   r   r   r   r3   r   upperr9   r6   )ra   sortedrU   re   keyr>   r   r   r   to_ical   s    
zParameters.to_icalFc           
      C   s  |  }t |dD ]}zt |ddd\}}t| g }t |dD ]d}|drx|drx|d}t|dd || q>t|d	d |r||  q>|| q>|s|||< n"t|dkr|d
 ||< n|||< W q t	y }	 zt	d||	f W Y d}	~	qd}	~	0 0 q|S )z2Parses the parameter format from ical text format.r   =r+   )rT   r   rK   T)rI   Fr   z&%r is not a valid parameter string: %sN)
rZ   rE   
startswithendswithstriprJ   r9   rg   r8   rB   )
clsrR   strictrU   paramri   rP   valsvexcr   r   r   	from_ical   s2    

zParameters.from_icalN)T)F)__name__
__module____qualname____doc__rb   rj   classmethodru   r   r   r   r   r^      s
   
r^   c                 C   s$   |  dd dd dd ddS )	Nr   %2Cz\:%3Ar   %3Br   %5Cr   rO   r   r   r   escape_string  s
    r   c                 C   s$   |  dd dd dd ddS )	Nr{   r   r|   :r}   r   r~   r
   r   rO   r   r   r   unescape_string  s
    r   c                 C   s$   t | trdd | D S t| S d S )Nc                 S   s   g | ]}t |qS r   )r   )r,   sr   r   r   
<listcomp>  r[   z+unescape_list_or_string.<locals>.<listcomp>)r   rd   r   rO   r   r   r   unescape_list_or_string  s    
r   c                       sR   e Zd ZdZdef fdd	ZedddZdd	 Zedd
dZ	dd Z
  ZS )ContentlinezWA content line is basically a string that can be folded and parsed into
    parts.
    Fc                    s8   t ||d}d|vsJ dtt| | |}||_|S )N)encodingr	   z;Content line can not contain unescaped new line characters.)r   superr   __new__rp   )ro   r>   rp   r   ra   	__class__r   r   r   $  s
    zContentline.__new__Tc                 C   st   t |tsJ t|dr"| }nt| }t|}t|}|rdt|j|d}| d|||f S | d||f S )z*Turn a parts into a content line.
        rj   )rh   z%s;%s:%sz%s:%s)r   r^   r#   rj   vTextr   )ro   rC   rb   valuesrh   r   r   r   
from_parts,  s    

zContentline.from_partsc              
   C   s$  zt | }d}d}d}t|D ]:\}}|sJ|dv r:|s:|}|dkrJ|sJ|}|dkr| }qt|d| }|svtdt| |r|d |krtdtj||d | | jd	}td
d t	|D }t||d d }	|||	fW S  ty }
 ztd| |
f W Y d}
~
n
d}
~
0 0 dS )zISplit the content line up into (name, parameters, values) parts.
        NFz:;r   rK   zKey name is requiredr+   zInvalid content linerp   c                 s   s"   | ]\}}t |t|fV  qd S rF   )r   r   )r,   ri   r>   r   r   r   r1   Y  s   z$Contentline.parts.<locals>.<genexpr>z5Content line could not be parsed into parts: '%s': %s)
r   	enumerater   rB   rE   r^   ru   rp   r   	iteritems)ra   rR   Z
name_splitZvalue_splitZ	in_quotesr-   rY   rC   rb   r   rt   r   r   r   partsA  sB    zContentline.partsc                 C   s   t |}| td||dS )zJUnfold the content lines in an iCalendar into long content lines.
        r2   r   )r   uFOLDsub)ro   Zicalrp   r   r   r   ru   e  s    zContentline.from_icalc                 C   s   t | tS )zXLong content lines are folded so they are less than 75 characters
        wide.
        )r;   r3   r   r`   r   r   r   rj   m  s    zContentline.to_ical)T)F)rv   rw   rx   ry   r   r   rz   r   r   ru   rj   __classcell__r   r   r   r   r      s   $r   c                   @   s$   e Zd ZdZdd Zedd ZdS )ContentlineszI assume that iCalendar files generally are a few kilobytes in size.
    Then this should be efficient. for Huge files, an iterator should probably
    be used instead.
    c                 C   s   d dd | D d S )zSimply join self.
        r   c                 s   s   | ]}|r|  V  qd S rF   )rj   r,   r0   r   r   r   r1   |  r[   z'Contentlines.to_ical.<locals>.<genexpr>r\   r`   r   r   r   rj   y  s    zContentlines.to_icalc                 C   s\   t |}z4td|}| dd t|D }|d |W S  tyV   tdY n0 dS )z,Parses a string into content lines.
        r2   c                 s   s   | ]}|rt |V  qd S rF   )r   r   r   r   r   r1     s   z)Contentlines.from_ical.<locals>.<genexpr>z&Expected StringType with content linesN)r   r   r   NEWLINEsplitr9   	ExceptionrB   )ro   rR   Zunfoldedlinesr   r   r   ru   ~  s    
zContentlines.from_icalN)rv   rw   rx   ry   rj   rz   ru   r   r   r   r   r   t  s   r   )r   )r(   r)   )T)r   rQ   )r   )(ry   
__future__r   Z	icalendarr   Zicalendar.caselessdictr   Zicalendar.parser_toolsr   r   r   rer   r    r'   r;   r?   compiler@   rH   rG   ZFOLDr   r   rE   rJ   rM   r=   rZ   r<   r^   r   r   r   r   r   rd   r   Zicalendar.propr   r   r   r   r   <module>   s>   
&









R
T