ClickUp Operator
by noahvanhart
- .venv
- Lib
- site-packages
- pydantic
- __pycache__
�
�MMg�@ � �4 � U d Z ddlmZ ddlZddlmZmZ ddlmZm Z m
Z
m Z m Z ddl
mZmZ ddlmZmZmZ ddlmZmZmZ d d
lmZ d d lmZm Z d d l m Z ej> d<i e j@ �d
di�� G d� d� � Z! ej> d<i e j@ �d
di�� G d� d� � Z"er3dZ#de$d< dZ%de$d< dZ&de$d< dZ'de$d< e d e%� � Z( e d e&� � Z)e d d d d � d=d!�� Z*e d d d d d"� d>d#�� Z*d$ed%dd"� d?d&�Z*erge
e ege f Z+de$d'< e
e ge f Z,de$d(< d)Z-de$d*< e
e eege f Z.de$d+< e
e ege f Z/de$d,< d-Z0de$d.< d/Z1de$d0< e d1e-� � Z2 e d2e0� � Z3e d@d3�� Z4e d%d d4� dAd5�� Z4e d d%d d6� dBd7�� Z4 dCd$d%ed6� dDd8�Z4 e d9� Z5eree5d f Z6y ej> d<i e j@ �� G d:� d;� � Z6y)EzEThis module contains related classes and functions for serialization.� )� annotationsN)�partial�
partialmethod)�
TYPE_CHECKING�Any�Callable�TypeVar�overload)�PydanticUndefined� core_schema)�SerializationInfo� SerializerFunctionWrapHandler�WhenUsed)� Annotated�Literal� TypeAlias� )�PydanticUndefinedAnnotation)� _decorators�_internal_dataclass)�GetCoreSchemaHandler�frozenTc �@ � e Zd ZU dZded< eZded< dZded< d d �Zy
) �PlainSerializeraC Plain serializers use a function to modify the output of serialization.
This is particularly helpful when you want to customize the serialization for annotated types.
Consider an input of `list`, which will be serialized into a space-delimited string.
```python
from typing import List
from typing_extensions import Annotated
from pydantic import BaseModel, PlainSerializer
CustomStr = Annotated[
List, PlainSerializer(lambda x: ' '.join(x), return_type=str)
]
class StudentModel(BaseModel):
courses: CustomStr
student = StudentModel(courses=['Math', 'Chemistry', 'English'])
print(student.model_dump())
#> {'courses': 'Math Chemistry English'}
```
Attributes:
func: The serializer function.
return_type: The return type for the function. If omitted it will be inferred from the type annotation.
when_used: Determines when this serializer should be used. Accepts a string with values `'always'`,
`'unless-none'`, `'json'`, and `'json-unless-none'`. Defaults to 'always'.
z core_schema.SerializerFunction�funcr � return_type�alwaysr � when_usedc � � ||� }|j � \ }} t j | j | j ||�� }|t u rdn|j |� }t j | j t j | j d� || j �� |d< |S # t
$ r}t
j |� |�d}~ww xY w)z�Gets the Pydantic core schema.
Args:
source_type: The source type.
handler: The `GetCoreSchemaHandler` instance.
Returns:
The Pydantic core schema.
��globalns�localnsN�plain��function�info_arg�
return_schemar �
serialization)�_get_types_namespacer �get_function_return_typer r � NameErrorr �from_name_errorr �generate_schemar �$plain_serializer_function_ser_schema� inspect_annotated_serializerr � �self� source_type�handler�schemar! r" r �er' s �kC:\Users\noahv\Documents\GitHub\clickup-operator\.venv\Lib\site-packages\pydantic/functional_serializers.py� __get_pydantic_core_schema__z,PlainSerializer.__get_pydantic_core_schema__7 s� � � ��%�� #� 8� 8� :���'� H�%�>�>�� � �� � �!� � �K� !,�/@� @��g�F]�F]�^i�Fj�
�"-�"R�"R��Y�Y� �=�=�d�i�i��Q�'��n�n� #
��� � �
�� � H�-�=�=�a�@�a� G�� H�� �-B5 �5 C�>C�CN�r2 r r3 r �returnzcore_schema.CoreSchema� �__name__�
__module__� __qualname__�__doc__�__annotations__r r r r7 � � r6 r r s( � � �> )�(�(�K��(�"�I�x�"� rB r c �@ � e Zd ZU dZded< eZded< dZded< d d �Zy
) �WrapSerializera Wrap serializers receive the raw inputs along with a handler function that applies the standard serialization
logic, and can modify the resulting value before returning it as the final output of serialization.
For example, here's a scenario in which a wrap serializer transforms timezones to UTC **and** utilizes the existing `datetime` serialization logic.
```python
from datetime import datetime, timezone
from typing import Any, Dict
from typing_extensions import Annotated
from pydantic import BaseModel, WrapSerializer
class EventDatetime(BaseModel):
start: datetime
end: datetime
def convert_to_utc(value: Any, handler, info) -> Dict[str, datetime]:
# Note that `handler` can actually help serialize the `value` for
# further custom serialization in case it's a subclass.
partial_result = handler(value, info)
if info.mode == 'json':
return {
k: datetime.fromisoformat(v).astimezone(timezone.utc)
for k, v in partial_result.items()
}
return {k: v.astimezone(timezone.utc) for k, v in partial_result.items()}
UTCEventDatetime = Annotated[EventDatetime, WrapSerializer(convert_to_utc)]
class EventModel(BaseModel):
event_datetime: UTCEventDatetime
dt = EventDatetime(
start='2024-01-01T07:00:00-08:00', end='2024-01-03T20:00:00+06:00'
)
event = EventModel(event_datetime=dt)
print(event.model_dump())
'''
{
'event_datetime': {
'start': datetime.datetime(
2024, 1, 1, 15, 0, tzinfo=datetime.timezone.utc
),
'end': datetime.datetime(
2024, 1, 3, 14, 0, tzinfo=datetime.timezone.utc
),
}
}
'''
print(event.model_dump_json())
'''
{"event_datetime":{"start":"2024-01-01T15:00:00Z","end":"2024-01-03T14:00:00Z"}}
'''
```
Attributes:
func: The serializer function to be wrapped.
return_type: The return type for the function. If omitted it will be inferred from the type annotation.
when_used: Determines when this serializer should be used. Accepts a string with values `'always'`,
`'unless-none'`, `'json'`, and `'json-unless-none'`. Defaults to 'always'.
z"core_schema.WrapSerializerFunctionr r r r r r c � � ||� }|j � \ }} t j | j | j ||�� }|t u rdn|j |� }t j | j t j | j d� || j �� |d< |S # t
$ r}t
j |� |�d}~ww xY w)z�This method is used to get the Pydantic core schema of the class.
Args:
source_type: Source type.
handler: Core schema handler.
Returns:
The generated core schema of the class.
r N�wrapr$ r( )r) r r* r r r+ r r, r r- r �#wrap_serializer_function_ser_schemar/ r r0 s r6 r7 z+WrapSerializer.__get_pydantic_core_schema__� s� � � ��%�� #� 8� 8� :���'� H�%�>�>�� � �� � �!� � �K� !,�/@� @��g�F]�F]�^i�Fj�
�"-�"Q�"Q��Y�Y� �=�=�d�i�i��P�'��n�n� #
��� � �
�� � H�-�=�=�a�@�a� G�� H�r8 Nr9 r; rA rB r6 rD rD V s) � �>�@ -�,�(�K��(�"�I�x�"� rB rD z!partial[Any] | partialmethod[Any]r �_Partialz)core_schema.SerializerFunction | _Partial�FieldPlainSerializerz-core_schema.WrapSerializerFunction | _Partial�FieldWrapSerializerz*FieldPlainSerializer | FieldWrapSerializer�FieldSerializer�_FieldPlainSerializerT)�bound�_FieldWrapSerializerT.)r r � check_fieldsc � � y �NrA ��field�moder r rO �fieldss r6 �field_serializerrV � s � � @CrB )rT r r rO c � � y rQ rA rR s r6 rV rV � s � � BErB r# r c �$ � ����� d��� ��fd� }|S )a Decorator that enables custom field serialization.
In the below example, a field of type `set` is used to mitigate duplication. A `field_serializer` is used to serialize the data as a sorted list.
```python
from typing import Set
from pydantic import BaseModel, field_serializer
class StudentModel(BaseModel):
name: str = 'Jane'
courses: Set[str]
@field_serializer('courses', when_used='json')
def serialize_courses_in_order(self, courses: Set[str]):
return sorted(courses)
student = StudentModel(courses={'Math', 'Chemistry', 'English'})
print(student.model_dump_json())
#> {"name":"Jane","courses":["Chemistry","English","Math"]}
```
See [Custom serializers](../concepts/serialization.md#custom-serializers) for more information.
Four signatures are supported:
- `(self, value: Any, info: FieldSerializationInfo)`
- `(self, value: Any, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo)`
- `(value: Any, info: SerializationInfo)`
- `(value: Any, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)`
Args:
fields: Which field(s) the method should be called on.
mode: The serialization mode.
- `plain` means the function will be called instead of the default serialization logic,
- `wrap` means the function will be called with an argument to optionally call the
default serialization logic.
return_type: Optional return type for the function, if omitted it will be inferred from the type annotation.
when_used: Determines the serializer will be used for serialization.
check_fields: Whether to check that the fields actually exist on the model.
Returns:
The decorator function.
c �d �� t j ������� }t j | |� S )N)rU rT r r rO )r � FieldSerializerDecoratorInfo�PydanticDescriptorProxy)�f�dec_inforO rU rT r r s �����r6 �decz field_serializer.<locals>.dec s7 �� � �;�;���#� �%�
�� �2�2�1�h�?�?rB )r\ rK r: �(_decorators.PydanticDescriptorProxy[Any]rA )rT r r rO rU r^ s ````` r6 rV rV � s �� �p@� @� �JrB � ModelPlainSerializerWithInfo� ModelPlainSerializerWithoutInfoz>ModelPlainSerializerWithInfo | ModelPlainSerializerWithoutInfo�ModelPlainSerializer�ModelWrapSerializerWithInfo� ModelWrapSerializerWithoutInfoz<ModelWrapSerializerWithInfo | ModelWrapSerializerWithoutInfo�ModelWrapSerializerz*ModelPlainSerializer | ModelWrapSerializer�ModelSerializer�_ModelPlainSerializerT�_ModelWrapSerializerTc � � y rQ rA )r\ s r6 �model_serializerrj C s � �NQrB )r r c � � y rQ rA �rT r r s r6 rj rj G s � � @CrB rl c � � y rQ rA rl s r6 rj rj M s � � BErB c �0 ���� d���fd� }| �|S || � S )a# Decorator that enables custom model serialization.
This is useful when a model need to be serialized in a customized manner, allowing for flexibility beyond just specific fields.
An example would be to serialize temperature to the same temperature scale, such as degrees Celsius.
```python
from typing import Literal
from pydantic import BaseModel, model_serializer
class TemperatureModel(BaseModel):
unit: Literal['C', 'F']
value: int
@model_serializer()
def serialize_model(self):
if self.unit == 'F':
return {'unit': 'C', 'value': int((self.value - 32) / 1.8)}
return {'unit': self.unit, 'value': self.value}
temperature = TemperatureModel(unit='F', value=212)
print(temperature.model_dump())
#> {'unit': 'C', 'value': 100}
```
Two signatures are supported for `mode='plain'`, which is the default:
- `(self)`
- `(self, info: SerializationInfo)`
And two other signatures for `mode='wrap'`:
- `(self, nxt: SerializerFunctionWrapHandler)`
- `(self, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)`
See [Custom serializers](../concepts/serialization.md#custom-serializers) for more information.
Args:
f: The function to be decorated.
mode: The serialization mode.
- `'plain'` means the function will be called instead of the default serialization logic
- `'wrap'` means the function will be called with an argument to optionally call the default
serialization logic.
when_used: Determines when this serializer should be used.
return_type: The return type for the function. If omitted it will be inferred from the type annotation.
Returns:
The decorator function.
c �` �� t j ����� }t j | |� S )N)rT r r )r � ModelSerializerDecoratorInfor[ )r\ r] rT r r s ���r6 r^ z model_serializer.<locals>.dec� s, �� � �;�;��S^�js�t���2�2�1�h�?�?rB )r\ rf r: r_ rA )r\ rT r r r^ s ``` r6 rj rj V s �� �@@� �y��
��1�v�
rB �AnyTypec �@ � e Zd Zdd�Z dd�Zej Zy)�SerializeAsAnyc �( � t |t � f S rQ )r rs )�cls�items r6 �__class_getitem__z SerializeAsAny.__class_getitem__� s � � �T�>�#3� 3�4� 4rB c �� � ||� }|}|d dk( r |j � }|d }|d dk( r� t j d� t j � �� |d< |S )N�type� definitionsr4 c � � || � S rQ rA )�x�hs r6 �<lambda>z=SerializeAsAny.__get_pydantic_core_schema__.<locals>.<lambda>� s � �Q�q�TrB )r4 r( )�copyr rG �
any_schema)r1 r2 r3 r4 �schema_to_updates r6 r7 z+SerializeAsAny.__get_pydantic_core_schema__� sw � � �[�)�F� %� �"�6�*�m�;�#3�#8�#8�#:� �#3�H�#=� � #�6�*�m�;� 1<�0_�0_�!�+�*@�*@�*B�1� �_� -� �MrB N)rv r r: r r9 )r< r= r> rw r7 �object�__hash__rA rB r6 rs rs � s/ � � 5� � "� �-A� �
#� � �?�?�rB rs rA )rS �strrU r� rT �Literal['wrap']r r r r rO � bool | Noner: z8Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT])rS r� rU r� rT �Literal['plain']r r r r rO r� r: z:Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]) rU r� rT �Literal['plain', 'wrap']r r r r rO r� r: zuCallable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT])r\ rg r: rg )rT r� r r r r r: z8Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT])rT r� r r r r r: z:Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]rQ )
r\ z5_ModelPlainSerializerT | _ModelWrapSerializerT | NonerT r� r r r r r: z�_ModelPlainSerializerT | Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT] | Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT])7r? �
__future__r � dataclasses� functoolsr r �typingr r r r r
�
pydantic_corer r �pydantic_core.core_schemar
r r �typing_extensionsr r r � r � _internalr r �annotated_handlersr � dataclass�
slots_truer rD rH r@ rI rJ rK rL rN rV r` ra rb rc rd re rf rg rh rj rq rs rA rB r6 �<module>r� s2 �� K� "� � ,� B� B� 8� `� `� ;� ;� )� 7� 4� ����E�,�7�7�E��E�@� @� F�@�F ����E�,�7�7�E��E�a� a� F�a�H �=�H�i�=�&Q��)�Q�@�%T���T�?�!M�O�Y�M�0� $�%=�EY� Z�� #�$;�CV� W��
� � � #�C� �C� �C� � C�
� C� �
C� �C� >�C�
�C�
�
!�� � #�E� �E� �E� � E�
� E� �
E� �E� @�E�
�E� &-�(�"� $� B�
�B�
"�B� �B� � B�
� B�A�B�J � /7��=N�7O�QT�7T�.U� �)�U�N�19�3�%��*�1E�#�Y�E�Q�&f��)�f�4�-5�s�<Y�[l�6m�or�6r�-s� ��s�M�08�#�?\�9]�_b�9b�0c�"�I�c�P�%c���c�3�!M�O�Y�M� $�%=�EY� Z�� #�$;�CV� W��
� Q�
� Q�
�4<�QT�C�
�C�)1�C�KN�C�=�C�
�C�
� !�"�� E�
�E� �E� � E�
@� E�
�E� @D�G� &-�"�(�
G�<�G� #� G�
� G� �
G�A�G�T �)�
�� � �w��|�,�N�� �[���<� 0� ;� ;�<�#� #� =�#rB