orjson

Орджсон

orjson — это быстрая и правильная библиотека JSON для Python. Она считается самой быстрой библиотекой Python для JSON и более корректна, чем стандартная библиотека json или другие сторонние библиотеки. Он сериализует экземпляры классов данных, даты и времени, numpy и UUID.

orjson.dumps() примерно в 10 раз быстрее, чем json , сериализует общие типы и подтипы, имеет параметр default , позволяющий вызывающей стороне указать, как сериализовать произвольные типы, и имеет ряд флагов, управляющих выводом.

orjson.loads() примерно в 2 раза быстрее, чем json , и строго соответствует UTF-8 и RFC 8259 («Формат обмена данными JavaScript Object Notation (JSON)»).

Чтение и запись в файлы, файлы JSON, разделенные строками, и т. д. не предоставляются библиотекой.

orjson поддерживает CPython 3.8, 3.9, 3.10, 3.11, 3.12, 3.13 и 3.14.

Он распространяет колеса amd64/x86_64, i686/x86, aarch64/armv8, Arm7, POWER/ppc64le и s390x для Linux, колеса amd64 и aarch64 для macOS, а также колеса amd64 и i686/x86 для Windows.

orjson не поддерживает и не будет поддерживать PyPy, встроенные сборки Python для Android/iOS или подинтерпретаторы PEP 554.

В выпусках используется семантическое управление версиями, и сериализация нового типа объекта без флага согласия считается критическим изменением.

orjson лицензируется как Apache 2.0, так и MIT. Репозиторий и система отслеживания проблем — github.com/ijl/orjson, туда можно отправлять исправления. В репозитории доступен CHANGELOG.

1. Использование
   1. Установить
   2. Быстрый старт
   3. Миграция
   4. Сериализация
      1. по умолчанию
      2. вариант
      3. Фрагмент
   5. Десериализовать
2. Типы
   1. класс данных
   2. дата и время
   3. перечисление
   4. плавать
   5. интервал
   6. бестолковый
   7. ул.
   8. uuid
3. Тестирование
4. Производительность
   1. Задержка
   2. Воспроизведение
5. Вопросы
6. Упаковка
7. Лицензия

Использование

Установить

Чтобы установить колесо из PyPI, установите пакет orjson .

В формате requirements.in или requirements.txt укажите:

orjson >= 3.10,<4

В формате pyproject.toml укажите:

 orjson = " ^3.10 "

Чтобы собрать колесо, смотрите упаковку.

Быстрый старт

Это пример сериализации с указанными параметрами и десериализации:

 > >> import orjson , datetime , numpy
> >> data = {
    "type" : "job" ,
    "created_at" : datetime . datetime ( 1970 , 1 , 1 ),
    "status" : "?" ,
    "payload" : numpy . array ([[ 1 , 2 ], [ 3 , 4 ]]),
}
> >> orjson . dumps ( data , option = orjson . OPT_NAIVE_UTC | orjson . OPT_SERIALIZE_NUMPY )
b'{"type":"job","created_at":"1970-01-01T00:00:00+00:00","status":" xf0 x9f x86 x97 ","payload":[[1,2],[3,4]]}'
> >> orjson . loads ( _ )
{ 'type' : 'job' , 'created_at' : '1970-01-01T00:00:00+00:00' , 'status' : '?' , 'payload' : [[ 1 , 2 ], [ 3 , 4 ]]}

Миграция

orjson версии 3 сериализует больше типов, чем версия 2. Подклассы str , int , dict и list теперь сериализуются. Это быстрее и больше похоже на стандартную библиотеку. Его можно отключить с помощью orjson.OPT_PASSTHROUGH_SUBCLASS . Экземпляры dataclasses.dataclass теперь сериализуются по умолчанию и не могут быть настроены в функции default , если не указан option=orjson.OPT_PASSTHROUGH_DATACLASS . Экземпляры uuid.UUID сериализуются по умолчанию. Для любого типа, который теперь сериализован, реализации функции default и параметры, позволяющие их реализовать, можно удалить, но это не обязательно. Никаких изменений в десериализации не произошло.

При переходе из стандартной библиотеки самое большое отличие состоит в том, что orjson.dumps возвращает bytes , а json.dumps возвращает str .

Пользователи с объектами dict , использующими ключи, отличные от str должны указать option=orjson.OPT_NON_STR_KEYS .

sort_keys заменяется на option=orjson.OPT_SORT_KEYS .

indent заменяется на option=orjson.OPT_INDENT_2 , а другие уровни отступов не поддерживаются.

ensure_ascii , вероятно, сегодня неактуален, и символы UTF-8 нельзя преобразовать в ASCII.

Сериализация

 def dumps (
    __obj : Any ,
    default : Optional [ Callable [[ Any ], Any ]] = ...,
    option : Optional [ int ] = ...,
) -> bytes : ...

dumps() сериализует объекты Python в JSON.

Он изначально сериализует str , dict , list , tuple , int , float , bool , None , dataclasses.dataclass , typing.TypedDict , datetime.datetime , datetime.date , datetime.time , uuid.UUID , numpy.ndarray и orjson.Fragment Экземпляры orjson.Fragment . Он поддерживает произвольные типы по default . Он сериализует подклассы str , int , dict , list , dataclasses.dataclass и enum.Enum . Он не сериализует подклассы tuple , чтобы избежать сериализации объектов namedtuple как массивов. Чтобы избежать сериализации подклассов, укажите опцию orjson.OPT_PASSTHROUGH_SUBCLASS .

Выходные данные представляют собой bytes объект, содержащий UTF-8.

Глобальная блокировка переводчика (GIL) удерживается на время разговора.

Он вызывает JSONEncodeError для неподдерживаемого типа. Это сообщение об исключении описывает недопустимый объект с сообщением об ошибке Type is not JSON serializable: ... . Чтобы это исправить, укажите default.

Он вызывает JSONEncodeError для str , содержащей недопустимый код UTF-8.

Он вызывает JSONEncodeError для целого числа, длина которого превышает 64 бита по умолчанию или, с OPT_STRICT_INTEGER , 53 бита.

Он вызывает JSONEncodeError , если dict имеет ключ типа, отличного от str , если не указан OPT_NON_STR_KEYS .

Он вызывает JSONEncodeError , если выходные данные по default рекурсивно обрабатываются по default глубиной более 254 уровней.

Он вызывает JSONEncodeError при циклических ссылках.

Он вызывает JSONEncodeError , если tzinfo для объекта datetime не поддерживается.

JSONEncodeError — это подкласс TypeError . Это сделано для совместимости со стандартной библиотекой.

Если сбой был вызван исключением по default , JSONEncodeError связывает исходное исключение как __cause__ .

по умолчанию

Чтобы сериализовать подкласс или произвольные типы, укажите default как вызываемый объект, который возвращает поддерживаемый тип. default может быть функцией, лямбда-выражением или экземпляром вызываемого класса. Чтобы указать, что тип не обрабатывался по default , создайте исключение, например TypeError .

 > >> import orjson , decimal
> >>
def default ( obj ):
    if isinstance ( obj , decimal . Decimal ):
        return str ( obj )
    raise TypeError

> >> orjson . dumps ( decimal . Decimal ( "0.0842389659712649442845" ))
JSONEncodeError : Type is not JSON serializable : decimal . Decimal
> >> orjson . dumps ( decimal . Decimal ( "0.0842389659712649442845" ), default = default )
b'"0.0842389659712649442845"'
> >> orjson . dumps ({ 1 , 2 }, default = default )
orjson . JSONEncodeError : Type is not JSON serializable : set

Вызываемый объект default может возвращать объект, который сам должен быть обработан по default до 254 раз, прежде чем будет вызвано исключение.

Важно, чтобы default возникало исключение, если тип не может быть обработан. В противном случае Python неявно возвращает None , который выглядит для вызывающей стороны как допустимое значение и сериализуется:

 > >> import orjson , json
> >>
def default ( obj ):
    if isinstance ( obj , decimal . Decimal ):
        return str ( obj )

> >> orjson . dumps ({ "set" :{ 1 , 2 }}, default = default )
b'{"set":null}'
> >> json . dumps ({ "set" :{ 1 , 2 }}, default = default )
'{"set":null}' 

вариант

Чтобы изменить способ сериализации данных, укажите option . Каждая option представляет собой целочисленную константу в orjson . Чтобы указать несколько параметров, замаскируйте их вместе, например, option=orjson.OPT_STRICT_INTEGER | orjson.OPT_NAIVE_UTC .

OPT_APPEND_NEWLINE

Добавьте n к выводу. Это удобство и оптимизация шаблона dumps(...) + "n" . Объекты bytes неизменяемы, и этот шаблон копирует исходное содержимое.

 > >> import orjson
> >> orjson . dumps ([])
b"[]"
> >> orjson . dumps ([], option = orjson . OPT_APPEND_NEWLINE )
b"[] n " 

OPT_INDENT_2

Вывод в виде красивой печати с отступом в два пробела. Это эквивалентно indent=2 в стандартной библиотеке. Красивая печать происходит медленнее, а результат больше. orjson — самая быстрая по сравнению с библиотекой для красивой печати, и ее замедление при красивой печати гораздо меньше, чем у стандартной библиотеки. Эта опция совместима со всеми остальными опциями.

 > >> import orjson
> >> orjson . dumps ({ "a" : "b" , "c" : { "d" : True }, "e" : [ 1 , 2 ]})
b'{"a":"b","c":{"d":true},"e":[1,2]}'
> >> orjson . dumps (
    { "a" : "b" , "c" : { "d" : True }, "e" : [ 1 , 2 ]},
    option = orjson . OPT_INDENT_2
)
b'{ n  "a": "b", n  "c": { n    "d": true n  }, n  "e": [ n    1, n    2 n  ] n }'

Если они отображаются, отступы и разрывы строк выглядят следующим образом:

{
  "a" : " b " ,
  "c" : {
    "d" : true
  },
  "e" : [
    1 ,
    2
  ]
}

Это измеряет сериализацию приспособления github.json как компактного (52 КБ) или красивого (64 КБ):

Библиотека	компактный (мс)	красивая (мс)	против Орджсона
Орджсон	0,01	0,02	1
JSON	0,13	0,54	34

Это измеряет сериализацию приспособления citm_catalog.json, что является скорее худшим случаем из-за количества вложений и новых строк, как компактного (489 КБ) или красивого (1,1 МБ):

Библиотека	компактный (мс)	красивая (мс)	против Орджсона
Орджсон	0,25	0,45	1
JSON	3.01	24.42	54,4

Это можно воспроизвести с помощью скрипта pyindent .

OPT_NAIVE_UTC

Сериализуйте объекты datetime.datetime без tzinfo как UTC. Это не влияет на объекты datetime.datetime , для которых установлен tzinfo .

 > >> import orjson , datetime
> >> orjson . dumps (
        datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ),
    )
b'"1970-01-01T00:00:00"'
> >> orjson . dumps (
        datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ),
        option = orjson . OPT_NAIVE_UTC ,
    )
b'"1970-01-01T00:00:00+00:00"' 

OPT_NON_STR_KEYS

Сериализуйте ключи dict типа, отличного от str . Это позволяет ключам dict быть одним из str , int , float , bool , None , datetime.datetime , datetime.date , datetime.time , enum.Enum и uuid.UUID . Для сравнения: стандартная библиотека по умолчанию сериализует str , int , float , bool или None . orjson показал, что сериализация ключей, отличных от str выполняется быстрее, чем другие библиотеки. Этот параметр работает медленнее для ключей str чем вариант по умолчанию.

 > >> import orjson , datetime , uuid
> >> orjson . dumps (
        { uuid . UUID ( "7202d115-7ff3-4c81-a7c1-2a1f067b1ece" ): [ 1 , 2 , 3 ]},
        option = orjson . OPT_NON_STR_KEYS ,
    )
b'{"7202d115-7ff3-4c81-a7c1-2a1f067b1ece":[1,2,3]}'
> >> orjson . dumps (
        { datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 ): [ 1 , 2 , 3 ]},
        option = orjson . OPT_NON_STR_KEYS | orjson . OPT_NAIVE_UTC ,
    )
b'{"1970-01-01T00:00:00+00:00":[1,2,3]}'

Эти типы обычно сериализуются так, как они были бы в виде значений, например, datetime.datetime по-прежнему является строкой RFC 3339 и учитывает влияющие на нее параметры. Исключением является то, что сериализация int не учитывает OPT_STRICT_INTEGER .

Этот вариант имеет риск создания дубликатов ключей. Это связано с тем, что объекты, отличные от str могут сериализоваться в ту же str , что и существующий ключ, например, {"1": true, 1: false} . Последний ключ, который будет вставлен в dict будет сериализован последним, и десериализатор JSON предположительно возьмет последнее вхождение ключа (в приведенном выше примере false ). Первое значение будет потеряно.

Эта опция совместима с orjson.OPT_SORT_KEYS . Если используется сортировка, обратите внимание, что сортировка нестабильна и будет непредсказуема для повторяющихся ключей.

 > >> import orjson , datetime
> >> orjson . dumps (
    { "other" : 1 , datetime . date ( 1970 , 1 , 5 ): 2 , datetime . date ( 1970 , 1 , 3 ): 3 },
    option = orjson . OPT_NON_STR_KEYS | orjson . OPT_SORT_KEYS
)
b'{"1970-01-03":3,"1970-01-05":2,"other":1}'

Это измеряет сериализацию 589 КБ JSON, содержащего list из 100 dict , в котором каждый dict имеет как 365 случайно отсортированных ключей int , представляющих временные метки эпохи, так и один ключ str , а значение для каждого ключа представляет собой одно целое число. В «ключах str» ключи были преобразованы в str перед сериализацией, а orjson по-прежнему указывает option=orjson.OPT_NON_STR_KEYS (что всегда несколько медленнее).

Библиотека	ключи str (мс)	int ключи (мс)	int ключи отсортированы (мс)
Орджсон	0,5	0,93	2.08
JSON	2,72	3,59

json пуст, поскольку при попытке сортировки перед преобразованием всех ключей в str возникает ошибка TypeError . Это можно воспроизвести с помощью сценария pynonstr .

OPT_OMIT_MICROSECONDS

Не сериализуйте поле microsecond в экземплярах datetime.datetime и datetime.time .

 > >> import orjson , datetime
> >> orjson . dumps (
        datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , 1 ),
    )
b'"1970-01-01T00:00:00.000001"'
> >> orjson . dumps (
        datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , 1 ),
        option = orjson . OPT_OMIT_MICROSECONDS ,
    )
b'"1970-01-01T00:00:00"' 

OPT_PASSTHROUGH_DATACLASS

Передача экземпляров dataclasses.dataclass по default . Это позволяет настроить их вывод, но работает намного медленнее.

 > >> import orjson , dataclasses
> >>
@ dataclasses . dataclass
class User :
    id : str
    name : str
    password : str

def default ( obj ):
    if isinstance ( obj , User ):
        return { "id" : obj . id , "name" : obj . name }
    raise TypeError

> >> orjson . dumps ( User ( "3b1" , "asd" , "zxc" ))
b'{"id":"3b1","name":"asd","password":"zxc"}'
> >> orjson . dumps ( User ( "3b1" , "asd" , "zxc" ), option = orjson . OPT_PASSTHROUGH_DATACLASS )
TypeError : Type is not JSON serializable : User
> >> orjson . dumps (
        User ( "3b1" , "asd" , "zxc" ),
        option = orjson . OPT_PASSTHROUGH_DATACLASS ,
        default = default ,
    )
b'{"id":"3b1","name":"asd"}' 

OPT_PASSTHROUGH_DATETIME

Передача экземпляров datetime.datetime , datetime.date и datetime.time по default . Это позволяет сериализовать дату и время в собственный формат, например даты HTTP:

 > >> import orjson , datetime
> >>
def default ( obj ):
    if isinstance ( obj , datetime . datetime ):
        return obj . strftime ( "%a, %d %b %Y %H:%M:%S GMT" )
    raise TypeError

> >> orjson . dumps ({ "created_at" : datetime . datetime ( 1970 , 1 , 1 )})
b'{"created_at":"1970-01-01T00:00:00"}'
> >> orjson . dumps ({ "created_at" : datetime . datetime ( 1970 , 1 , 1 )}, option = orjson . OPT_PASSTHROUGH_DATETIME )
TypeError : Type is not JSON serializable : datetime . datetime
> >> orjson . dumps (
        { "created_at" : datetime . datetime ( 1970 , 1 , 1 )},
        option = orjson . OPT_PASSTHROUGH_DATETIME ,
        default = default ,
    )
b'{"created_at":"Thu, 01 Jan 1970 00:00:00 GMT"}'

Это не влияет на дату и время в ключах dict если используется OPT_NON_STR_KEYS.

OPT_PASSTHROUGH_SUBCLASS

Передача подклассов встроенных типов по default .

 > >> import orjson
> >>
class Secret ( str ):
    pass

def default ( obj ):
    if isinstance ( obj , Secret ):
        return "******"
    raise TypeError

> >> orjson . dumps ( Secret ( "zxc" ))
b'"zxc"'
> >> orjson . dumps ( Secret ( "zxc" ), option = orjson . OPT_PASSTHROUGH_SUBCLASS )
TypeError : Type is not JSON serializable : Secret
> >> orjson . dumps ( Secret ( "zxc" ), option = orjson . OPT_PASSTHROUGH_SUBCLASS , default = default )
b'"******"'

Это не влияет на сериализацию подклассов как ключей dict при использовании OPT_NON_STR_KEYS.

OPT_SERIALIZE_DATACLASS

Это устарело и не действует в версии 3. В версии 2 это требовалось для сериализации экземпляров dataclasses.dataclass . Для получения дополнительной информации см. класс данных.

OPT_SERIALIZE_NUMPY

Сериализуйте экземпляры numpy.ndarray . Подробнее см. numpy.

OPT_SERIALIZE_UUID

Это устарело и не действует в версии 3. В версии 2 это требовалось для сериализации экземпляров uuid.UUID . Дополнительные сведения см. в разделе UUID.

OPT_SORT_KEYS

Сериализуйте ключи dict в отсортированном порядке. По умолчанию сериализация выполняется в неопределенном порядке. Это эквивалентно sort_keys=True в стандартной библиотеке.

Это можно использовать для обеспечения детерминированности порядка при хешировании или тестировании. Это имеет существенное снижение производительности и в целом не рекомендуется.

 > >> import orjson
> >> orjson . dumps ({ "b" : 1 , "c" : 2 , "a" : 3 })
b'{"b":1,"c":2,"a":3}'
> >> orjson . dumps ({ "b" : 1 , "c" : 2 , "a" : 3 }, option = orjson . OPT_SORT_KEYS )
b'{"a":3,"b":1,"c":2}'

Это измеряет сериализацию приспособления twitter.json в несортированном и отсортированном виде:

Библиотека	несортированный (мс)	отсортировано (мс)	против Орджсона
Орджсон	0,11	0,3	1
JSON	1,36	1,93	6.4

Тест можно воспроизвести с помощью сценария pysort .

Сортировка не учитывает параметры сортировки/локали:

 > >> import orjson
> >> orjson . dumps ({ "a" : 1 , "ä" : 2 , "A" : 3 }, option = orjson . OPT_SORT_KEYS )
b'{"A":3,"a":1," xc3 xa4 ":2}'

Это то же поведение сортировки, что и в стандартной библиотеке.

dataclass также сериализуется как карты, но это на них не влияет.

OPT_STRICT_INTEGER

Установите 53-битное ограничение на целые числа. В противном случае ограничение составляет 64 бита, как и в стандартной библиотеке Python. Подробнее см. внутр.

OPT_UTC_Z

Сериализуйте часовой пояс UTC в экземплярах datetime.datetime как Z вместо +00:00 .

 > >> import orjson , datetime , zoneinfo
> >> orjson . dumps (
        datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , tzinfo = zoneinfo . ZoneInfo ( "UTC" )),
    )
b'"1970-01-01T00:00:00+00:00"'
> >> orjson . dumps (
        datetime . datetime ( 1970 , 1 , 1 , 0 , 0 , 0 , tzinfo = zoneinfo . ZoneInfo ( "UTC" )),
        option = orjson . OPT_UTC_Z
    )
b'"1970-01-01T00:00:00Z"' 

Фрагмент

orjson.Fragment включает в документ уже сериализованный JSON. Это эффективный способ включения больших двоичных объектов JSON из кэша, поля JSONB или отдельно сериализованного объекта без предварительной десериализации в объекты Python с помощью loads() .

 > >> import orjson
> >> orjson . dumps ({ "key" : "zxc" , "data" : orjson . Fragment ( b'{"a": "b", "c": 1}' )})
b'{"key":"zxc","data":{"a": "b", "c": 1}}'

Он не выполняет переформатирование: orjson.OPT_INDENT_2 не повлияет на компактный большой двоичный объект, а красиво напечатанный большой двоичный объект JSON не будет перезаписан как компактный.

Входные данные должны быть bytes или str и передаваться в качестве позиционного аргумента.

Это вызывает orjson.JSONEncodeError , если указана str и ввод недействителен в формате UTF-8. В противном случае проверка не выполняется, и можно записать недопустимый JSON. Это не позволяет избежать символов. Реализация тестируется на отсутствие сбоя при наличии недопустимых строк или недопустимого JSON.

Десериализовать

 def loads ( __obj : Union [ bytes , bytearray , memoryview , str ]) -> Any : ...

loads() десериализует JSON в объекты Python. Он десериализуется в объекты dict , list , int , float , str , bool и None .

принимаются bytes , bytearray , memoryview и str . Если входные данные существуют как объект memoryview , bytearray или bytes , рекомендуется передать их напрямую, а не создавать ненужный объект str . То есть orjson.loads(b"{}") вместо orjson.loads(b"{}".decode("utf-8")) . Это требует меньшего использования памяти и меньшей задержки.

Входные данные должны быть действительными в формате UTF-8.

orjson поддерживает кэш ключей карты на протяжении всего процесса. Это приводит к чистому сокращению использования памяти за счет исключения повторяющихся строк. Для кэширования ключи должны иметь длину не более 64 байт и храниться 2048 записей.

Глобальная блокировка переводчика (GIL) удерживается на время разговора.

Он вызывает JSONDecodeError , если указан недопустимый тип или неверный JSON. Это включает в себя, если входные данные содержат NaN , Infinity или -Infinity , что разрешено стандартной библиотекой, но не является допустимым JSON.

Он вызывает JSONDecodeError , если комбинация массива или объекта рекурсирует на глубину 1024 уровня.

JSONDecodeError — это подкласс json.JSONDecodeError и ValueError . Это сделано для совместимости со стандартной библиотекой.

Типы

класс данных

orjson сериализует экземпляры dataclasses.dataclass изначально. Он сериализует экземпляры в 40–50 раз быстрее, чем другие библиотеки, и позволяет избежать серьезного замедления, наблюдаемого в других библиотеках, по сравнению с сериализацией dict .

Поддерживается передача всех вариантов классов данных, включая классы данных, использующие __slots__ , замороженные классы данных, классы с необязательными атрибутами или атрибутами по умолчанию и подклассы. Отсутствие использования __slots__ дает выигрыш в производительности.

Библиотека	дикт (мс)	класс данных (мс)	против Орджсона
Орджсон	0,43	0,95	1
JSON	5,81	38.32	40

Это измеряет сериализацию 555 КБ JSON, orjson и других библиотек с использованием default для сериализации вывода dataclasses.asdict() . Это можно воспроизвести с помощью сценария pydataclass .

Классы данных сериализуются как карты, при этом каждый атрибут сериализуется в порядке, указанном в определении класса:

 > >> import dataclasses , orjson , typing

@ dataclasses . dataclass
class Member :
    id : int
    active : bool = dataclasses . field ( default = False )

@ dataclasses . dataclass
class Object :
    id : int
    name : str
    members : typing . List [ Member ]

> >> orjson . dumps ( Object ( 1 , "a" , [ Member ( 1 , True ), Member ( 2 )]))
b'{"id":1,"name":"a","members":[{"id":1,"active":true},{"id":2,"active":false}]}'

дата и время

orjson сериализует объекты datetime.datetime в формат RFC 3339, например «1970-01-01T00:00:00+00:00». Это подмножество ISO 8601, совместимое с isoformat() в стандартной библиотеке.

 > >> import orjson , datetime , zoneinfo
> >> orjson . dumps (
    datetime . datetime ( 2018 , 12 , 1 , 2 , 3 , 4 , 9 , tzinfo = zoneinfo . ZoneInfo ( "Australia/Adelaide" ))
)
b'"2018-12-01T02:03:04.000009+10:30"'
> >> orjson . dumps (
    datetime . datetime ( 2100 , 9 , 1 , 21 , 55 , 2 ). replace ( tzinfo = zoneinfo . ZoneInfo ( "UTC" ))
)
b'"2100-09-01T21:55:02+00:00"'
> >> orjson . dumps (
    datetime . datetime ( 2100 , 9 , 1 , 21 , 55 , 2 )
)
b'"2100-09-01T21:55:02"'

datetime.datetime поддерживает экземпляры с tzinfo , имеющим значение None , datetime.timezone.utc , экземпляр часового пояса из модуля python3.9+ zoneinfo или экземпляр часового пояса из сторонних библиотек pendulum , pytz или dateutil / arrow .

Быстрее всего использовать zoneinfo.ZoneInfo стандартной библиотеки для часовых поясов.

Объекты datetime.time не должны иметь tzinfo .

 > >> import orjson , datetime
> >> orjson . dumps ( datetime . time ( 12 , 0 , 15 , 290 ))
b'"12:00:15.000290"'

Объекты datetime.date всегда будут сериализоваться.

 > >> import orjson , datetime
> >> orjson . dumps ( datetime . date ( 1900 , 1 , 2 ))
b'"1900-01-02"'

Ошибки с tzinfo приводят к возникновению JSONEncodeError .

Чтобы отключить сериализацию объектов datetime , укажите опцию orjson.