python-json-logger 2.0.6__tar.gz → 3.0.0__tar.gz

{python-json-logger-2.0.6 → python-json-logger-3.0.0}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011, Zakaria Zajac 
+Copyright (c) 2011, Zakaria Zajac and the python-json-logger Contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

{python-json-logger-2.0.6/src/python_json_logger.egg-info → python-json-logger-3.0.0}/PKG-INFO

@@ -1,58 +1,78 @@
 Metadata-Version: 2.1
 Name: python-json-logger
-Version: 2.0.6
-Summary: A python library adding a json log formatter
-Home-page: http://github.com/madzak/python-json-logger
-Author: Zakaria Zajac
-Author-email: zak@madzak.com
-License: BSD
+Version: 3.0.0
+Summary: JSON Log Formatter for the Python Logging Package
+Author-email: Zakaria Zajac <zak@madzak.com>
+Maintainer-email: Nicholas Hairs <info+python-json-logger@nicholashairs.com>
+License: BSD-2-Clause License
+Project-URL: GitHub, https://github.com/nhairs/python-json-logger
 Classifier: Development Status :: 6 - Mature
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Logging
-Requires-Python: >=3.6
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-
-![Build Status](https://github.com/madzak/python-json-logger/actions/workflows/build.yml/badge.svg)
+Provides-Extra: lint
+Requires-Dist: validate-pyproject[all]; extra == "lint"
+Requires-Dist: black; extra == "lint"
+Requires-Dist: pylint; extra == "lint"
+Requires-Dist: mypy; extra == "lint"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+![Build Status](https://github.com/nhairs/python-json-logger/actions/workflows/test-suite.yml/badge.svg)
 [![License](https://img.shields.io/pypi/l/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 [![Version](https://img.shields.io/pypi/v/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 
-Overview
-=======
+# Python JSON Logger
+
 This library is provided to allow standard python logging to output log data as json objects. With JSON we can make our logs more readable by machines and we can stop writing custom parsers for syslog type records.
 
-News
-=======
-Hi, I see this package is quiet alive and I am sorry for ignoring it so long. I will be stepping up my maintenance of this package so please allow me a week to get things back in order (and most likely a new minor version) and I'll post and update here once I am caught up.
 
-Installing
-==========
-Pip:
+### 🚨 Important 🚨
+
+This repository is a maintained fork of [madzak/python-json-logger](https://github.com/madzak/python-json-logger) pending [a PEP 541 request](https://github.com/pypi/support/issues/3607) for the PyPI package.  The future direction of the project is being discussed [here](https://github.com/nhairs/python-json-logger/issues/1).
+
+## Installation
+
+### Install via pip / PyPI
+
+Until the PEP 541 request is complete you will need to use one of the alternative methods below.
+
+### Install from GitHub
 
-    pip install python-json-logger
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git'
+```
+
+To install a specific version:
 
-Pypi:
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git@v2.0.7'
+```
 
-   https://pypi.python.org/pypi/python-json-logger
 
-Manual:
+### Install from Source
 
-    python setup.py install
+```shell
+git clone https://github.com/nhairs/python-json-logger.git
+cd python-json-logger
+pip install -e .
+```
 
-Usage
-=====
+## Usage
 
-## Integrating with Python's logging framework
+### Integrating with Python's logging framework
 
 Json outputs are provided by the JsonFormatter logging formatter. You can add the custom formatter like below:
 
@@ -70,7 +90,7 @@ Json outputs are provided by the JsonFormatter logging formatter. You can add th
     logger.addHandler(logHandler)
 ```
 
-## Customizing fields
+### Customizing fields
 
 The fmt parser can also be overidden if you want to have required fields that differ from the default of just `message`.
 
@@ -112,7 +132,7 @@ formatter = CustomJsonFormatter('%(timestamp)s %(level)s %(name)s %(message)s')
 
 Items added to the log record will be included in *every* log message, no matter what the format requires.
 
-## Adding custom object serialization
+### Adding custom object serialization
 
 For custom handling of object serialization you can specify default json object translator or provide a custom encoder
 
@@ -129,7 +149,7 @@ logger.info({"special": "value", "run": 12})
 logger.info("classic message", extra={"special": "value", "run": 12})
 ```
 
-## Using a Config File
+### Using a Config File
 
 To use the module with a config file using the [`fileConfig` function](https://docs.python.org/3/library/logging.config.html#logging.config.fileConfig), use the class `pythonjsonlogger.jsonlogger.JsonFormatter`. Here is a sample config file.
 
@@ -162,8 +182,7 @@ format = %(message)s
 class = pythonjsonlogger.jsonlogger.JsonFormatter
 ```
 
-Example Output
-==============
+## Example Output
 
 Sample JSON with a full formatter (basically the log message from the unit test). Every log message will appear on 1 line like a typical logger.
 
@@ -191,9 +210,14 @@ Sample JSON with a full formatter (basically the log message from the unit test)
 }
 ```
 
-External Examples
-=================
+## License
+
+This project is licensed under the BSD 2 Clause License - see [`LICENSE`](https://github.com/nhairs/python-json-logger/blob/main/LICENSE)
+
+## Authors and Maintainers
+
+This project was originally authored by [Zakaria Zajac](https://github.com/madzak) and our wonderful [contributors](https://github.com/nhairs/python-json-logger/graphs/contributors)
 
-- [Wesley Tanaka - Structured log files in Python using python-json-logger](https://wtanaka.com/node/8201)
+It is currently maintained by:
 
-- [Archive](https://web.archive.org/web/20201130054012/https://wtanaka.com/node/8201)
+- [Nicholas Hairs](https://github.com/nhairs) - [nicholashairs.com](https://www.nicholashairs.com)

{python-json-logger-2.0.6 → python-json-logger-3.0.0}/README.md

@@ -1,33 +1,46 @@
-![Build Status](https://github.com/madzak/python-json-logger/actions/workflows/build.yml/badge.svg)
+![Build Status](https://github.com/nhairs/python-json-logger/actions/workflows/test-suite.yml/badge.svg)
 [![License](https://img.shields.io/pypi/l/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 [![Version](https://img.shields.io/pypi/v/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 
-Overview
-=======
+# Python JSON Logger
+
 This library is provided to allow standard python logging to output log data as json objects. With JSON we can make our logs more readable by machines and we can stop writing custom parsers for syslog type records.
 
-News
-=======
-Hi, I see this package is quiet alive and I am sorry for ignoring it so long. I will be stepping up my maintenance of this package so please allow me a week to get things back in order (and most likely a new minor version) and I'll post and update here once I am caught up.
 
-Installing
-==========
-Pip:
+### 🚨 Important 🚨
+
+This repository is a maintained fork of [madzak/python-json-logger](https://github.com/madzak/python-json-logger) pending [a PEP 541 request](https://github.com/pypi/support/issues/3607) for the PyPI package.  The future direction of the project is being discussed [here](https://github.com/nhairs/python-json-logger/issues/1).
 
-    pip install python-json-logger
+## Installation
 
-Pypi:
+### Install via pip / PyPI
 
-   https://pypi.python.org/pypi/python-json-logger
+Until the PEP 541 request is complete you will need to use one of the alternative methods below.
 
-Manual:
+### Install from GitHub
 
-    python setup.py install
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git'
+```
 
-Usage
-=====
+To install a specific version:
 
-## Integrating with Python's logging framework
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git@v2.0.7'
+```
+
+
+### Install from Source
+
+```shell
+git clone https://github.com/nhairs/python-json-logger.git
+cd python-json-logger
+pip install -e .
+```
+
+## Usage
+
+### Integrating with Python's logging framework
 
 Json outputs are provided by the JsonFormatter logging formatter. You can add the custom formatter like below:
 
@@ -45,7 +58,7 @@ Json outputs are provided by the JsonFormatter logging formatter. You can add th
     logger.addHandler(logHandler)
 ```
 
-## Customizing fields
+### Customizing fields
 
 The fmt parser can also be overidden if you want to have required fields that differ from the default of just `message`.
 
@@ -87,7 +100,7 @@ formatter = CustomJsonFormatter('%(timestamp)s %(level)s %(name)s %(message)s')
 
 Items added to the log record will be included in *every* log message, no matter what the format requires.
 
-## Adding custom object serialization
+### Adding custom object serialization
 
 For custom handling of object serialization you can specify default json object translator or provide a custom encoder
 
@@ -104,7 +117,7 @@ logger.info({"special": "value", "run": 12})
 logger.info("classic message", extra={"special": "value", "run": 12})
 ```
 
-## Using a Config File
+### Using a Config File
 
 To use the module with a config file using the [`fileConfig` function](https://docs.python.org/3/library/logging.config.html#logging.config.fileConfig), use the class `pythonjsonlogger.jsonlogger.JsonFormatter`. Here is a sample config file.
 
@@ -137,8 +150,7 @@ format = %(message)s
 class = pythonjsonlogger.jsonlogger.JsonFormatter
 ```
 
-Example Output
-==============
+## Example Output
 
 Sample JSON with a full formatter (basically the log message from the unit test). Every log message will appear on 1 line like a typical logger.
 
@@ -166,9 +178,14 @@ Sample JSON with a full formatter (basically the log message from the unit test)
 }
 ```
 
-External Examples
-=================
+## License
+
+This project is licensed under the BSD 2 Clause License - see [`LICENSE`](https://github.com/nhairs/python-json-logger/blob/main/LICENSE)
+
+## Authors and Maintainers
+
+This project was originally authored by [Zakaria Zajac](https://github.com/madzak) and our wonderful [contributors](https://github.com/nhairs/python-json-logger/graphs/contributors)
 
-- [Wesley Tanaka - Structured log files in Python using python-json-logger](https://wtanaka.com/node/8201)
+It is currently maintained by:
 
-- [Archive](https://web.archive.org/web/20201130054012/https://wtanaka.com/node/8201)
+- [Nicholas Hairs](https://github.com/nhairs) - [nicholashairs.com](https://www.nicholashairs.com)

python-json-logger-3.0.0/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-json-logger"
+version = "3.0.0"
+description = "JSON Log Formatter for the Python Logging Package"
+authors = [
+    {name = "Zakaria Zajac", email = "zak@madzak.com"},
+]
+maintainers  = [
+    {name = "Nicholas Hairs", email = "info+python-json-logger@nicholashairs.com"},
+]
+
+# Dependency Information
+requires-python = ">=3.7"
+# dependencies = []
+
+# Extra information
+readme = "README.md"
+license = {text = "BSD-2-Clause License"}
+classifiers = [
+    "Development Status :: 6 - Mature",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Logging",
+    "Typing :: Typed",
+]
+
+[project.urls]
+# homepage = "https://nhairs.github.io/python-json-logger/latest/"
+GitHub = "https://github.com/nhairs/python-json-logger"
+
+[project.optional-dependencies]
+lint = [
+    "validate-pyproject[all]",
+    "black",
+    "pylint",
+    "mypy",
+]
+
+test = [
+    "pytest",
+]
+
+#docs = [
+#    "black",
+#    "mkdocs",
+#    "mkdocs-material>=8.5",
+#    "mkdocs-awesome-pages-plugin",
+#    "mdx_truly_sane_lists",
+#    "mkdocstrings[python]",
+#    "mkdocs-gen-files",
+#    "mkdocs-literate-nav",
+#    "mike",
+#]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["pythonjsonlogger*"]
+
+[tool.setuptools.package-data]
+pythonjsonlogger = ["py.typed"]
+
+[tool.black]
+line-length = 100

{python-json-logger-2.0.6 → python-json-logger-3.0.0/src/python_json_logger.egg-info}/PKG-INFO

@@ -1,58 +1,78 @@
 Metadata-Version: 2.1
 Name: python-json-logger
-Version: 2.0.6
-Summary: A python library adding a json log formatter
-Home-page: http://github.com/madzak/python-json-logger
-Author: Zakaria Zajac
-Author-email: zak@madzak.com
-License: BSD
+Version: 3.0.0
+Summary: JSON Log Formatter for the Python Logging Package
+Author-email: Zakaria Zajac <zak@madzak.com>
+Maintainer-email: Nicholas Hairs <info+python-json-logger@nicholashairs.com>
+License: BSD-2-Clause License
+Project-URL: GitHub, https://github.com/nhairs/python-json-logger
 Classifier: Development Status :: 6 - Mature
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Logging
-Requires-Python: >=3.6
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-
-![Build Status](https://github.com/madzak/python-json-logger/actions/workflows/build.yml/badge.svg)
+Provides-Extra: lint
+Requires-Dist: validate-pyproject[all]; extra == "lint"
+Requires-Dist: black; extra == "lint"
+Requires-Dist: pylint; extra == "lint"
+Requires-Dist: mypy; extra == "lint"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+![Build Status](https://github.com/nhairs/python-json-logger/actions/workflows/test-suite.yml/badge.svg)
 [![License](https://img.shields.io/pypi/l/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 [![Version](https://img.shields.io/pypi/v/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 
-Overview
-=======
+# Python JSON Logger
+
 This library is provided to allow standard python logging to output log data as json objects. With JSON we can make our logs more readable by machines and we can stop writing custom parsers for syslog type records.
 
-News
-=======
-Hi, I see this package is quiet alive and I am sorry for ignoring it so long. I will be stepping up my maintenance of this package so please allow me a week to get things back in order (and most likely a new minor version) and I'll post and update here once I am caught up.
 
-Installing
-==========
-Pip:
+### 🚨 Important 🚨
+
+This repository is a maintained fork of [madzak/python-json-logger](https://github.com/madzak/python-json-logger) pending [a PEP 541 request](https://github.com/pypi/support/issues/3607) for the PyPI package.  The future direction of the project is being discussed [here](https://github.com/nhairs/python-json-logger/issues/1).
+
+## Installation
+
+### Install via pip / PyPI
+
+Until the PEP 541 request is complete you will need to use one of the alternative methods below.
+
+### Install from GitHub
 
-    pip install python-json-logger
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git'
+```
+
+To install a specific version:
 
-Pypi:
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git@v2.0.7'
+```
 
-   https://pypi.python.org/pypi/python-json-logger
 
-Manual:
+### Install from Source
 
-    python setup.py install
+```shell
+git clone https://github.com/nhairs/python-json-logger.git
+cd python-json-logger
+pip install -e .
+```
 
-Usage
-=====
+## Usage
 
-## Integrating with Python's logging framework
+### Integrating with Python's logging framework
 
 Json outputs are provided by the JsonFormatter logging formatter. You can add the custom formatter like below:
 
@@ -70,7 +90,7 @@ Json outputs are provided by the JsonFormatter logging formatter. You can add th
     logger.addHandler(logHandler)
 ```
 
-## Customizing fields
+### Customizing fields
 
 The fmt parser can also be overidden if you want to have required fields that differ from the default of just `message`.
 
@@ -112,7 +132,7 @@ formatter = CustomJsonFormatter('%(timestamp)s %(level)s %(name)s %(message)s')
 
 Items added to the log record will be included in *every* log message, no matter what the format requires.
 
-## Adding custom object serialization
+### Adding custom object serialization
 
 For custom handling of object serialization you can specify default json object translator or provide a custom encoder
 
@@ -129,7 +149,7 @@ logger.info({"special": "value", "run": 12})
 logger.info("classic message", extra={"special": "value", "run": 12})
 ```
 
-## Using a Config File
+### Using a Config File
 
 To use the module with a config file using the [`fileConfig` function](https://docs.python.org/3/library/logging.config.html#logging.config.fileConfig), use the class `pythonjsonlogger.jsonlogger.JsonFormatter`. Here is a sample config file.
 
@@ -162,8 +182,7 @@ format = %(message)s
 class = pythonjsonlogger.jsonlogger.JsonFormatter
 ```
 
-Example Output
-==============
+## Example Output
 
 Sample JSON with a full formatter (basically the log message from the unit test). Every log message will appear on 1 line like a typical logger.
 
@@ -191,9 +210,14 @@ Sample JSON with a full formatter (basically the log message from the unit test)
 }
 ```
 
-External Examples
-=================
+## License
+
+This project is licensed under the BSD 2 Clause License - see [`LICENSE`](https://github.com/nhairs/python-json-logger/blob/main/LICENSE)
+
+## Authors and Maintainers
+
+This project was originally authored by [Zakaria Zajac](https://github.com/madzak) and our wonderful [contributors](https://github.com/nhairs/python-json-logger/graphs/contributors)
 
-- [Wesley Tanaka - Structured log files in Python using python-json-logger](https://wtanaka.com/node/8201)
+It is currently maintained by:
 
-- [Archive](https://web.archive.org/web/20201130054012/https://wtanaka.com/node/8201)
+- [Nicholas Hairs](https://github.com/nhairs) - [nicholashairs.com](https://www.nicholashairs.com)

{python-json-logger-2.0.6 → python-json-logger-3.0.0}/src/python_json_logger.egg-info/SOURCES.txt

@@ -1,13 +1,15 @@
 LICENSE
 MANIFEST.in
 README.md
+pyproject.toml
 setup.cfg
-setup.py
 src/python_json_logger.egg-info/PKG-INFO
 src/python_json_logger.egg-info/SOURCES.txt
 src/python_json_logger.egg-info/dependency_links.txt
+src/python_json_logger.egg-info/requires.txt
 src/python_json_logger.egg-info/top_level.txt
 src/pythonjsonlogger/__init__.py
 src/pythonjsonlogger/jsonlogger.py
+src/pythonjsonlogger/py.typed
 tests/__init__.py
-tests/tests.py
+tests/test_jsonlogger.py

python-json-logger-3.0.0/src/python_json_logger.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[lint]
+validate-pyproject[all]
+black
+pylint
+mypy
+
+[test]
+pytest

{python-json-logger-2.0.6 → python-json-logger-3.0.0}/src/pythonjsonlogger/jsonlogger.py

@@ -1,15 +1,16 @@
-'''
+"""
 This library is provided to allow standard python logging
 to output log data as JSON formatted strings
-'''
+"""
+
 import logging
 import json
 import re
-from datetime import date, datetime, time, timezone
 import traceback
 import importlib
-
-from typing import Any, Dict, Optional, Union, List, Tuple
+from datetime import date, datetime, time, timezone
+import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from inspect import istraceback
 
@@ -17,19 +18,45 @@ from collections import OrderedDict
 
 # skip natural LogRecord attributes
 # http://docs.python.org/library/logging.html#logrecord-attributes
-RESERVED_ATTRS: Tuple[str, ...] = (
-    'args', 'asctime', 'created', 'exc_info', 'exc_text', 'filename',
-    'funcName', 'levelname', 'levelno', 'lineno', 'module',
-    'msecs', 'message', 'msg', 'name', 'pathname', 'process',
-    'processName', 'relativeCreated', 'stack_info', 'thread', 'threadName')
-
+# Changed in 3.0.0, is now list[str] instead of tuple[str, ...]
+RESERVED_ATTRS: List[str] = [
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "module",
+    "msecs",
+    "message",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "stack_info",
+    "thread",
+    "threadName",
+]
+
+if sys.version_info >= (3, 12):
+    # taskName added in python 3.12
+    RESERVED_ATTRS.append("taskName")
+    RESERVED_ATTRS.sort()
+
+OptionalCallableOrStr = Optional[Union[Callable, str]]
 
 
 def merge_record_extra(
     record: logging.LogRecord,
     target: Dict,
     reserved: Union[Dict, List],
-    rename_fields: Optional[Dict[str,str]] = None,
+    rename_fields: Optional[Dict[str, str]] = None,
 ) -> Dict:
     """
     Merges extra attributes from LogRecord object into target dictionary
@@ -44,10 +71,8 @@ def merge_record_extra(
         rename_fields = {}
     for key, value in record.__dict__.items():
         # this allows to have numeric keys
-        if (key not in reserved
-            and not (hasattr(key, "startswith")
-                     and key.startswith('_'))):
-            target[rename_fields.get(key,key)] = value
+        if key not in reserved and not (hasattr(key, "startswith") and key.startswith("_")):
+            target[rename_fields.get(key, key)] = value
     return target
 
 
@@ -56,30 +81,34 @@ class JsonEncoder(json.JSONEncoder):
     A custom encoder extending the default JSONEncoder
     """
 
-    def default(self, obj):
-        if isinstance(obj, (date, datetime, time)):
-            return self.format_datetime_obj(obj)
+    def default(self, o: Any) -> Any:
+        if isinstance(o, (date, datetime, time)):
+            return self.format_datetime_obj(o)
 
-        elif istraceback(obj):
-            return ''.join(traceback.format_tb(obj)).strip()
+        if istraceback(o):
+            return "".join(traceback.format_tb(o)).strip()
 
-        elif type(obj) == Exception \
-                or isinstance(obj, Exception) \
-                or type(obj) == type:
-            return str(obj)
+        # pylint: disable=unidiomatic-typecheck
+        if type(o) == Exception or isinstance(o, Exception) or type(o) == type:
+            return str(o)
 
         try:
-            return super(JsonEncoder, self).default(obj)
+            return super().default(o)
 
         except TypeError:
             try:
-                return str(obj)
+                return str(o)
 
-            except Exception:
+            except Exception:  # pylint: disable=broad-exception-caught
                 return None
 
-    def format_datetime_obj(self, obj):
-        return obj.isoformat()
+    def format_datetime_obj(self, o):
+        """Format datetime objects found in self.default
+
+        This allows subclasses to change the datetime format without understanding the
+        internals of the default method.
+        """
+        return o.isoformat()
 
 
 class JsonFormatter(logging.Formatter):
@@ -89,22 +118,35 @@ class JsonFormatter(logging.Formatter):
     json default encoder
     """
 
-    def __init__(self, *args, **kwargs):
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        *args: Any,
+        json_default: OptionalCallableOrStr = None,
+        json_encoder: OptionalCallableOrStr = None,
+        json_serialiser: Union[Callable, str] = json.dumps,
+        json_indent: Optional[Union[int, str]] = None,
+        json_ensure_ascii: bool = True,
+        prefix: str = "",
+        rename_fields: Optional[dict] = None,
+        static_fields: Optional[dict] = None,
+        reserved_attrs: Union[Tuple[str, ...], List[str], None] = None,
+        timestamp: Union[bool, str] = False,
+        **kwargs: Any,
+    ) -> None:
         """
         :param json_default: a function for encoding non-standard objects
             as outlined in https://docs.python.org/3/library/json.html
         :param json_encoder: optional custom encoder
         :param json_serializer: a :meth:`json.dumps`-compatible callable
             that will be used to serialize the log record.
-        :param json_indent: an optional :meth:`json.dumps`-compatible numeric value
-            that will be used to customize the indent of the output json.
+        :param json_indent: indent parameter for json.dumps
+        :param json_ensure_ascii: ensure_ascii parameter for json.dumps
         :param prefix: an optional string prefix added at the beginning of
             the formatted string
         :param rename_fields: an optional dict, used to rename field names in the output.
             Rename message to @message: {'message': '@message'}
         :param static_fields: an optional dict, used to add fields with static values to all logs
-        :param json_indent: indent parameter for json.dumps
-        :param json_ensure_ascii: ensure_ascii parameter for json.dumps
         :param reserved_attrs: an optional list of fields that will be skipped when
             outputting json log record. Defaults to all log record attributes:
             http://docs.python.org/library/logging.html#logrecord-attributes
@@ -113,17 +155,18 @@ class JsonFormatter(logging.Formatter):
             to log record using string as key. If True boolean is passed, timestamp key
             will be "timestamp". Defaults to False/off.
         """
-        self.json_default = self._str_to_fn(kwargs.pop("json_default", None))
-        self.json_encoder = self._str_to_fn(kwargs.pop("json_encoder", None))
-        self.json_serializer = self._str_to_fn(kwargs.pop("json_serializer", json.dumps))
-        self.json_indent = kwargs.pop("json_indent", None)
-        self.json_ensure_ascii = kwargs.pop("json_ensure_ascii", True)
-        self.prefix = kwargs.pop("prefix", "")
-        self.rename_fields = kwargs.pop("rename_fields", {})
-        self.static_fields = kwargs.pop("static_fields", {})
-        reserved_attrs = kwargs.pop("reserved_attrs", RESERVED_ATTRS)
+        self.json_default = self._str_to_fn(json_default)
+        self.json_encoder = self._str_to_fn(json_encoder)
+        self.json_serializer = self._str_to_fn(json_serialiser)
+        self.json_indent = json_indent
+        self.json_ensure_ascii = json_ensure_ascii
+        self.prefix = prefix
+        self.rename_fields = rename_fields or {}
+        self.static_fields = static_fields or {}
+        if reserved_attrs is None:
+            reserved_attrs = RESERVED_ATTRS
         self.reserved_attrs = dict(zip(reserved_attrs, reserved_attrs))
-        self.timestamp = kwargs.pop("timestamp", False)
+        self.timestamp = timestamp
 
         # super(JsonFormatter, self).__init__(*args, **kwargs)
         logging.Formatter.__init__(self, *args, **kwargs)
@@ -131,9 +174,9 @@ class JsonFormatter(logging.Formatter):
             self.json_encoder = JsonEncoder
 
         self._required_fields = self.parse()
-        self._skip_fields = dict(zip(self._required_fields,
-                                     self._required_fields))
+        self._skip_fields = dict(zip(self._required_fields, self._required_fields))
         self._skip_fields.update(self.reserved_attrs)
+        return
 
     def _str_to_fn(self, fn_as_str):
         """
@@ -146,7 +189,7 @@ class JsonFormatter(logging.Formatter):
         if not isinstance(fn_as_str, str):
             return fn_as_str
 
-        path, _, function = fn_as_str.rpartition('.')
+        path, _, function = fn_as_str.rpartition(".")
         module = importlib.import_module(path)
         return getattr(module, function)
 
@@ -158,22 +201,26 @@ class JsonFormatter(logging.Formatter):
         to include in all log messages.
         """
         if isinstance(self._style, logging.StringTemplateStyle):
-            formatter_style_pattern = re.compile(r'\$\{(.+?)\}', re.IGNORECASE)
+            formatter_style_pattern = re.compile(r"\$\{(.+?)\}", re.IGNORECASE)
         elif isinstance(self._style, logging.StrFormatStyle):
-            formatter_style_pattern = re.compile(r'\{(.+?)\}', re.IGNORECASE)
+            formatter_style_pattern = re.compile(r"\{(.+?)\}", re.IGNORECASE)
         # PercentStyle is parent class of StringTemplateStyle and StrFormatStyle so
         # it needs to be checked last.
         elif isinstance(self._style, logging.PercentStyle):
-            formatter_style_pattern = re.compile(r'%\((.+?)\)', re.IGNORECASE)
+            formatter_style_pattern = re.compile(r"%\((.+?)\)", re.IGNORECASE)
         else:
-            raise ValueError('Invalid format: %s' % self._fmt)
+            raise ValueError(f"Invalid format: {self._fmt!r}")
 
         if self._fmt:
             return formatter_style_pattern.findall(self._fmt)
-        else:
-            return []
-
-    def add_fields(self, log_record: Dict[str, Any], record: logging.LogRecord, message_dict: Dict[str, Any]) -> None:
+        return []
+
+    def add_fields(
+        self,
+        log_record: Dict[str, Any],
+        record: logging.LogRecord,
+        message_dict: Dict[str, Any],
+    ) -> None:
         """
         Override this method to implement custom logic for adding fields.
         """
@@ -182,42 +229,53 @@ class JsonFormatter(logging.Formatter):
 
         log_record.update(self.static_fields)
         log_record.update(message_dict)
-        merge_record_extra(record, log_record, reserved=self._skip_fields, rename_fields=self.rename_fields)
+        merge_record_extra(
+            record,
+            log_record,
+            reserved=self._skip_fields,
+            rename_fields=self.rename_fields,
+        )
 
         if self.timestamp:
-            key = self.timestamp if type(self.timestamp) == str else 'timestamp'
+            # TODO: Can this use isinstance instead?
+            # pylint: disable=unidiomatic-typecheck
+            key = self.timestamp if type(self.timestamp) == str else "timestamp"
             log_record[key] = datetime.fromtimestamp(record.created, tz=timezone.utc)
 
         self._perform_rename_log_fields(log_record)
+        return
 
-    def _perform_rename_log_fields(self, log_record):
+    def _perform_rename_log_fields(self, log_record: Dict[str, Any]) -> None:
         for old_field_name, new_field_name in self.rename_fields.items():
             log_record[new_field_name] = log_record[old_field_name]
             del log_record[old_field_name]
+        return
 
-    def process_log_record(self, log_record):
+    def process_log_record(self, log_record: Dict[str, Any]) -> Dict[str, Any]:
         """
         Override this method to implement custom logic
         on the possibly ordered dictionary.
         """
         return log_record
 
-    def jsonify_log_record(self, log_record):
+    def jsonify_log_record(self, log_record: Dict[str, Any]) -> str:
         """Returns a json string of the log record."""
-        return self.json_serializer(log_record,
-                                    default=self.json_default,
-                                    cls=self.json_encoder,
-                                    indent=self.json_indent,
-                                    ensure_ascii=self.json_ensure_ascii)
+        return self.json_serializer(
+            log_record,
+            default=self.json_default,
+            cls=self.json_encoder,
+            indent=self.json_indent,
+            ensure_ascii=self.json_ensure_ascii,
+        )
 
     def serialize_log_record(self, log_record: Dict[str, Any]) -> str:
         """Returns the final representation of the log record."""
-        return "%s%s" % (self.prefix, self.jsonify_log_record(log_record))
+        return self.prefix + self.jsonify_log_record(log_record)
 
     def format(self, record: logging.LogRecord) -> str:
         """Formats a log record and serializes to json"""
         message_dict: Dict[str, Any] = {}
-        # FIXME: logging.LogRecord.msg and logging.LogRecord.message in typeshed
+        # TODO: logging.LogRecord.msg and logging.LogRecord.message in typeshed
         #        are always type of str. We shouldn't need to override that.
         if isinstance(record.msg, dict):
             message_dict = record.msg
@@ -230,14 +288,14 @@ class JsonFormatter(logging.Formatter):
 
         # Display formatted exception, but allow overriding it in the
         # user-supplied dict.
-        if record.exc_info and not message_dict.get('exc_info'):
-            message_dict['exc_info'] = self.formatException(record.exc_info)
-        if not message_dict.get('exc_info') and record.exc_text:
-            message_dict['exc_info'] = record.exc_text
+        if record.exc_info and not message_dict.get("exc_info"):
+            message_dict["exc_info"] = self.formatException(record.exc_info)
+        if not message_dict.get("exc_info") and record.exc_text:
+            message_dict["exc_info"] = record.exc_text
         # Display formatted record of stack frames
         # default format is a string returned from :func:`traceback.print_stack`
-        if record.stack_info and not message_dict.get('stack_info'):
-            message_dict['stack_info'] = self.formatStack(record.stack_info)
+        if record.stack_info and not message_dict.get("stack_info"):
+            message_dict["stack_info"] = self.formatStack(record.stack_info)
 
         log_record: Dict[str, Any] = OrderedDict()
         self.add_fields(log_record, record, message_dict)

python-json-logger-3.0.0/src/pythonjsonlogger/py.typed

@@ -0,0 +1 @@
+# PEP-561 marker. https://mypy.readthedocs.io/en/latest/installed_packages.html

python-json-logger-2.0.6/tests/tests.py → python-json-logger-3.0.0/tests/test_jsonlogger.py

@@ -1,27 +1,20 @@
-# -*- coding: utf-8 -*-
-import unittest
-import unittest.mock
+import datetime
 import logging
+from io import StringIO
 import json
+import random
 import sys
 import traceback
-import random
-
-try:
-    import xmlrunner  # noqa
-except ImportError:
-    pass
-
-from io import StringIO
+import unittest
+import unittest.mock
 
-sys.path.append('src/python-json-logger')
+sys.path.append("src/python-json-logger")
 from pythonjsonlogger import jsonlogger
-import datetime
 
 
 class TestJsonLogger(unittest.TestCase):
     def setUp(self):
-        self.log = logging.getLogger("logging-test-{}".format(random.randint(1, 101)))
+        self.log = logging.getLogger(f"logging-test-{random.randint(1, 101)}")
         self.log.setLevel(logging.DEBUG)
         self.buffer = StringIO()
 
@@ -41,7 +34,7 @@ class TestJsonLogger(unittest.TestCase):
     def test_percentage_format(self):
         fr = jsonlogger.JsonFormatter(
             # All kind of different styles to check the regex
-            '[%(levelname)8s] %(message)s %(filename)s:%(lineno)d %(asctime)'
+            "[%(levelname)8s] %(message)s %(filename)s:%(lineno)d %(asctime)"
         )
         self.log_handler.setFormatter(fr)
 
@@ -50,10 +43,10 @@ class TestJsonLogger(unittest.TestCase):
         log_json = json.loads(self.buffer.getvalue())
 
         self.assertEqual(log_json["message"], msg)
-        self.assertEqual(log_json.keys(), {'levelname', 'message', 'filename', 'lineno', 'asctime'})
+        self.assertEqual(log_json.keys(), {"levelname", "message", "filename", "lineno", "asctime"})
 
     def test_rename_base_field(self):
-        fr = jsonlogger.JsonFormatter(rename_fields={'message': '@message'})
+        fr = jsonlogger.JsonFormatter(rename_fields={"message": "@message"})
         self.log_handler.setFormatter(fr)
 
         msg = "testing logging format"
@@ -63,7 +56,7 @@ class TestJsonLogger(unittest.TestCase):
         self.assertEqual(log_json["@message"], msg)
 
     def test_rename_nonexistent_field(self):
-        fr = jsonlogger.JsonFormatter(rename_fields={'nonexistent_key': 'new_name'})
+        fr = jsonlogger.JsonFormatter(rename_fields={"nonexistent_key": "new_name"})
         self.log_handler.setFormatter(fr)
 
         stderr_watcher = StringIO()
@@ -73,7 +66,7 @@ class TestJsonLogger(unittest.TestCase):
         self.assertTrue("KeyError: 'nonexistent_key'" in stderr_watcher.getvalue())
 
     def test_add_static_fields(self):
-        fr = jsonlogger.JsonFormatter(static_fields={'log_stream': 'kafka'})
+        fr = jsonlogger.JsonFormatter(static_fields={"log_stream": "kafka"})
 
         self.log_handler.setFormatter(fr)
 
@@ -86,27 +79,27 @@ class TestJsonLogger(unittest.TestCase):
 
     def test_format_keys(self):
         supported_keys = [
-            'asctime',
-            'created',
-            'filename',
-            'funcName',
-            'levelname',
-            'levelno',
-            'lineno',
-            'module',
-            'msecs',
-            'message',
-            'name',
-            'pathname',
-            'process',
-            'processName',
-            'relativeCreated',
-            'thread',
-            'threadName'
+            "asctime",
+            "created",
+            "filename",
+            "funcName",
+            "levelname",
+            "levelno",
+            "lineno",
+            "module",
+            "msecs",
+            "message",
+            "name",
+            "pathname",
+            "process",
+            "processName",
+            "relativeCreated",
+            "thread",
+            "threadName",
         ]
 
-        log_format = lambda x: ['%({0:s})s'.format(i) for i in x]
-        custom_format = ' '.join(log_format(supported_keys))
+        log_format = lambda x: [f"%({i:s})s" for i in x]
+        custom_format = " ".join(log_format(supported_keys))
 
         fr = jsonlogger.JsonFormatter(custom_format)
         self.log_handler.setFormatter(fr)
@@ -121,7 +114,7 @@ class TestJsonLogger(unittest.TestCase):
                 self.assertTrue(True)
 
     def test_unknown_format_key(self):
-        fr = jsonlogger.JsonFormatter('%(unknown_key)s %(message)s')
+        fr = jsonlogger.JsonFormatter("%(unknown_key)s %(message)s")
 
         self.log_handler.setFormatter(fr)
         msg = "testing unknown logging format"
@@ -134,8 +127,7 @@ class TestJsonLogger(unittest.TestCase):
         fr = jsonlogger.JsonFormatter()
         self.log_handler.setFormatter(fr)
 
-        msg = {"text": "testing logging", "num": 1, 5: "9",
-               "nested": {"more": "data"}}
+        msg = {"text": "testing logging", "num": 1, 5: "9", "nested": {"more": "data"}}
 
         self.log.info(msg)
         log_json = json.loads(self.buffer.getvalue())
@@ -149,8 +141,7 @@ class TestJsonLogger(unittest.TestCase):
         fr = jsonlogger.JsonFormatter()
         self.log_handler.setFormatter(fr)
 
-        extra = {"text": "testing logging", "num": 1, 5: "9",
-                 "nested": {"more": "data"}}
+        extra = {"text": "testing logging", "num": 1, 5: "9", "nested": {"more": "data"}}
         self.log.info("hello", extra=extra)
         log_json = json.loads(self.buffer.getvalue())
         self.assertEqual(log_json.get("text"), extra["text"])
@@ -163,19 +154,20 @@ class TestJsonLogger(unittest.TestCase):
         fr = jsonlogger.JsonFormatter()
         self.log_handler.setFormatter(fr)
 
-        msg = {"adate": datetime.datetime(1999, 12, 31, 23, 59),
-               "otherdate": datetime.date(1789, 7, 14),
-               "otherdatetime": datetime.datetime(1789, 7, 14, 23, 59),
-               "otherdatetimeagain": datetime.datetime(1900, 1, 1)}
+        msg = {
+            "adate": datetime.datetime(1999, 12, 31, 23, 59),
+            "otherdate": datetime.date(1789, 7, 14),
+            "otherdatetime": datetime.datetime(1789, 7, 14, 23, 59),
+            "otherdatetimeagain": datetime.datetime(1900, 1, 1),
+        }
         self.log.info(msg)
         log_json = json.loads(self.buffer.getvalue())
         self.assertEqual(log_json.get("adate"), "1999-12-31T23:59:00")
         self.assertEqual(log_json.get("otherdate"), "1789-07-14")
         self.assertEqual(log_json.get("otherdatetime"), "1789-07-14T23:59:00")
-        self.assertEqual(log_json.get("otherdatetimeagain"),
-                         "1900-01-01T00:00:00")
+        self.assertEqual(log_json.get("otherdatetimeagain"), "1900-01-01T00:00:00")
 
-    @unittest.mock.patch('time.time', return_value=1500000000.0)
+    @unittest.mock.patch("time.time", return_value=1500000000.0)
     def test_json_default_encoder_with_timestamp(self, time_mock):
         fr = jsonlogger.JsonFormatter(timestamp=True)
         self.log_handler.setFormatter(fr)
@@ -189,11 +181,11 @@ class TestJsonLogger(unittest.TestCase):
     def test_json_custom_default(self):
         def custom(o):
             return "very custom"
+
         fr = jsonlogger.JsonFormatter(json_default=custom)
         self.log_handler.setFormatter(fr)
 
-        msg = {"adate": datetime.datetime(1999, 12, 31, 23, 59),
-               "normal": "value"}
+        msg = {"adate": datetime.datetime(1999, 12, 31, 23, 59), "normal": "value"}
         self.log.info(msg)
         log_json = json.loads(self.buffer.getvalue())
         self.assertEqual(log_json.get("adate"), "very custom")
@@ -215,12 +207,12 @@ class TestJsonLogger(unittest.TestCase):
 
     def get_traceback_from_exception_followed_by_log_call(self) -> str:
         try:
-            raise Exception('test')
+            raise Exception("test")
         except Exception:
             self.log.exception("hello")
             str_traceback = traceback.format_exc()
             # Formatter removes trailing new line
-            if str_traceback.endswith('\n'):
+            if str_traceback.endswith("\n"):
                 str_traceback = str_traceback[:-1]
 
         return str_traceback
@@ -245,14 +237,14 @@ class TestJsonLogger(unittest.TestCase):
     def test_ensure_ascii_true(self):
         fr = jsonlogger.JsonFormatter()
         self.log_handler.setFormatter(fr)
-        self.log.info('Привет')
+        self.log.info("Привет")
         msg = self.buffer.getvalue().split('"message": "', 1)[1].split('"', 1)[0]
         self.assertEqual(msg, r"\u041f\u0440\u0438\u0432\u0435\u0442")
 
     def test_ensure_ascii_false(self):
         fr = jsonlogger.JsonFormatter(json_ensure_ascii=False)
         self.log_handler.setFormatter(fr)
-        self.log.info('Привет')
+        self.log.info("Привет")
         msg = self.buffer.getvalue().split('"message": "', 1)[1].split('"', 1)[0]
         self.assertEqual(msg, "Привет")
 
@@ -262,10 +254,11 @@ class TestJsonLogger(unittest.TestCase):
                 return (z.real, z.imag)
             else:
                 type_name = z.__class__.__name__
-                raise TypeError("Object of type '{}' is no JSON serializable".format(type_name))
+                raise TypeError(f"Object of type '{type_name}' is no JSON serializable")
 
-        formatter = jsonlogger.JsonFormatter(json_default=encode_complex,
-                                             json_encoder=json.JSONEncoder)
+        formatter = jsonlogger.JsonFormatter(
+            json_default=encode_complex, json_encoder=json.JSONEncoder
+        )
         self.log_handler.setFormatter(formatter)
 
         value = {
@@ -274,44 +267,43 @@ class TestJsonLogger(unittest.TestCase):
 
         self.log.info(" message", extra=value)
         msg = self.buffer.getvalue()
-        self.assertEqual(msg, "{\"message\": \" message\", \"special\": [3.0, 8.0]}\n")
+        self.assertEqual(msg, '{"message": " message", "special": [3.0, 8.0]}\n')
 
     def test_rename_reserved_attrs(self):
-        log_format = lambda x: ['%({0:s})s'.format(i) for i in x]
+        log_format = lambda x: [f"%({i:s})s" for i in x]
         reserved_attrs_map = {
-            'exc_info': 'error.type',
-            'exc_text': 'error.message',
-            'funcName': 'log.origin.function',
-            'levelname': 'log.level',
-            'module': 'log.origin.file.name',
-            'processName': 'process.name',
-            'threadName': 'process.thread.name',
-            'msg': 'log.message'
+            "exc_info": "error.type",
+            "exc_text": "error.message",
+            "funcName": "log.origin.function",
+            "levelname": "log.level",
+            "module": "log.origin.file.name",
+            "processName": "process.name",
+            "threadName": "process.thread.name",
+            "msg": "log.message",
         }
 
-        custom_format = ' '.join(log_format(reserved_attrs_map.keys()))
-        reserved_attrs = [_ for _ in jsonlogger.RESERVED_ATTRS if _ not in list(reserved_attrs_map.keys())]
-        formatter = jsonlogger.JsonFormatter(custom_format, reserved_attrs=reserved_attrs, rename_fields=reserved_attrs_map)
+        custom_format = " ".join(log_format(reserved_attrs_map.keys()))
+        reserved_attrs = [
+            _ for _ in jsonlogger.RESERVED_ATTRS if _ not in list(reserved_attrs_map.keys())
+        ]
+        formatter = jsonlogger.JsonFormatter(
+            custom_format, reserved_attrs=reserved_attrs, rename_fields=reserved_attrs_map
+        )
         self.log_handler.setFormatter(formatter)
         self.log.info("message")
 
         msg = self.buffer.getvalue()
-        self.assertEqual(msg, '{"error.type": null, "error.message": null, "log.origin.function": "test_rename_reserved_attrs", "log.level": "INFO", "log.origin.file.name": "tests", "process.name": "MainProcess", "process.thread.name": "MainThread", "log.message": "message"}\n')
+        self.assertEqual(
+            msg,
+            '{"error.type": null, "error.message": null, "log.origin.function": "test_rename_reserved_attrs", "log.level": "INFO", "log.origin.file.name": "test_jsonlogger", "process.name": "MainProcess", "process.thread.name": "MainThread", "log.message": "message"}\n',
+        )
 
     def test_merge_record_extra(self):
-        record = logging.LogRecord("name", level=1, pathname="", lineno=1, msg="Some message", args=None, exc_info=None)
+        record = logging.LogRecord(
+            "name", level=1, pathname="", lineno=1, msg="Some message", args=None, exc_info=None
+        )
         output = jsonlogger.merge_record_extra(record, target=dict(foo="bar"), reserved=[])
         self.assertIn("foo", output)
         self.assertIn("msg", output)
-        self.assertEquals(output["foo"], "bar")
-        self.assertEquals(output["msg"], "Some message")
-
-
-if __name__ == '__main__':
-    if len(sys.argv[1:]) > 0:
-        if sys.argv[1] == 'xml':
-            testSuite = unittest.TestLoader().loadTestsFromTestCase(
-                TestJsonLogger)
-            xmlrunner.XMLTestRunner(output='reports').run(testSuite)
-    else:
-        unittest.main()
+        self.assertEqual(output["foo"], "bar")
+        self.assertEqual(output["msg"], "Some message")

python-json-logger-2.0.6/setup.py

@@ -1,41 +0,0 @@
-from os import path
-from setuptools import setup, find_packages
-
-# read the contents of your README file
-this_directory = path.abspath(path.dirname(__file__))
-with open(path.join(this_directory, 'README.md'), encoding='utf-8') as f:
-    long_description = f.read()
-
-setup(
-    name="python-json-logger",
-    version="2.0.6",
-    url="http://github.com/madzak/python-json-logger",
-    license="BSD",
-    include_package_data=True,
-    description="A python library adding a json log formatter",
-    long_description=long_description,
-    long_description_content_type='text/markdown',
-    author="Zakaria Zajac",
-    author_email="zak@madzak.com",
-    package_dir={'': 'src'},
-    package_data={"src/pythonjsonlogger": ["py.typed"]},
-    packages=find_packages("src", exclude="tests"),
-    # https://packaging.python.org/guides/distributing-packages-using-setuptools/#python-requires
-    python_requires=">=3.6",
-    test_suite="tests.tests",
-    classifiers=[
-        'Development Status :: 6 - Mature',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: BSD License',
-        'Operating System :: OS Independent',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-        'Programming Language :: Python :: 3.9',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3.11',
-        'Topic :: System :: Logging',
-    ]
-)