supplier-meesho.webflow 1.0.0

package/GitRepos/isort/docs/major_releases/introducing_isort_5.md

@@ -0,0 +1,142 @@
+# Introducing isort 5
+
+[![isort 5 - the best version of isort yet](https://raw.githubusercontent.com/pycqa/isort/main/art/logo_5.png)](https://pycqa.github.io/isort/)
+
+isort 5.0.0 is the first major release of isort in over five years and the first significant refactoring of isort since it was conceived more than ten years ago.
+It's also the first version to require Python 3 (Python 3.6+ at that!) to run - though it can still be run on source files from any version of Python.
+This does mean that there may be some pain with the upgrade process, but we believe the improvements will be well worth it.
+
+[Click here for an attempt at full changelog with a list of breaking changes.](https://pycqa.github.io/isort/CHANGELOG/)
+
+[Using isort 4.x.x? Click here for the isort 5.0.0 upgrade guide.](https://pycqa.github.io/isort/docs/upgrade_guides/5.0.0/)
+
+[Try isort 5 right now from your browser!](https://pycqa.github.io/isort/docs/quick_start/0.-try/)
+
+So why the massive change?
+
+# Profile support
+```
+isort --profile black .
+isort --profile django .
+isort --profile pycharm .
+isort --profile google .
+isort --profile open_stack .
+isort --profile plone .
+isort --profile attrs .
+isort --profile hug .
+```
+
+isort is very configurable. That's great, but it can be overwhelming, both for users and for the isort project. isort now comes with profiles for the most common isort configurations,
+so you likely will not need to configure anything at all. This also means that as a project, isort can run extensive tests against these specific profiles to ensure nothing breaks over time.
+
+# Sort imports **anywhere**
+
+```python3
+import a  # <- These are sorted
+import b
+
+b.install(a)
+
+import os  # <- And these are sorted
+import sys
+
+
+def my_function():
+    import x  # <- Even these are sorted!
+    import z
+```
+
+isort 5 will find and sort contiguous section of imports no matter where they are.
+It also allows you to place code in-between imports without any hacks required.
+
+# Streaming architecture
+
+```python3
+import a
+import b
+...
+∞
+```
+isort has been refactored to use a streaming architecture. This means it can sort files of *any* size (even larger than the Python interpreter supports!) without breaking a sweat.
+It also means that even when sorting imports in smaller files, it is faster and more resource-efficient.
+
+# Consistent behavior across **all** environments
+
+Sorting the same file with the same configuration should give you the same output no matter what computer or OS you are running. Extensive effort has been placed around refactoring
+how modules are placed and how configuration files are loaded to ensure this is the case.
+
+
+# Cython support
+
+```python3
+cimport ctime
+from cpython cimport PyLong_FromVoidPtr
+from cpython cimport bool as py_bool
+from cython.operator cimport dereference as deref
+from cython.operator cimport preincrement as preinc
+from libc.stdint cimport uint64_t, uintptr_t
+from libc.stdlib cimport atoi, calloc, free, malloc
+from libc.string cimport memcpy, strlen
+from libcpp cimport bool as cpp_bool
+from libcpp.map cimport map as cpp_map
+from libcpp.pair cimport pair as cpp_pair
+from libcpp.string cimport string as cpp_string
+from libcpp.vector cimport vector as cpp_vector
+from multimap cimport multimap as cpp_multimap
+from wstring cimport wstring as cpp_wstring
+```
+
+isort 5 adds seamless support for Cython (`.pyx`) files.
+
+# Action Comments
+
+```python3
+import e
+import f
+
+# isort: off  <- Turns isort parsing off
+
+import b
+import a
+
+# isort: on  <- Turns isort parsing back on
+
+import c
+import d
+```
+
+isort 5 adds support for [Action Comments](https://pycqa.github.io/isort/docs/configuration/action_comments/) which provide a quick and convient way to control the flow of parsing within single source files.
+
+
+# First class Python API
+
+```python3
+import isort
+
+isort.code("""
+import b
+import a
+""") == """
+import a
+import b
+"""
+```
+
+isort now exposes its programmatic API as a first-class citizen. This API makes it easy to extend or use isort in your own Python project. You can see the full documentation for this new API [here](https://pycqa.github.io/isort/reference/isort/api/).
+
+# Solid base for the future
+
+A major focus for the release was to give isort a solid foundation for the next 5-10 years of the project's life.
+isort has been refactored into functional components that are easily testable. The project now has 100% code coverage.
+It utilizes tools like [Hypothesis](https://hypothesis.readthedocs.io/en/latest/) to reduce the number of unexpected errors.
+It went from fully dynamic to fully static typing using mypy. Finally, it utilizes the latest linters both on (like [DeepSource](https://deepsource.io/gh/pycqa/isort/)) and offline (like [Flake8](https://flake8.pycqa.org/en/latest/)) to help ensure a higher bar for all code contributions into the future.
+
+# Give 5.0.0 a try!
+
+[Try isort 5 right now from your browser!](https://pycqa.github.io/isort/docs/quick_start/0.-try/)
+
+OR
+
+Install isort locally using `pip3 install isort`.
+
+[Click here for full installation instructions.](https://pycqa.github.io/isort/docs/quick_start/1.-install/)

package/GitRepos/isort/docs/major_releases/release_policy.md

@@ -0,0 +1,46 @@
+# isort Project Official Release Policy
+
+isort has moved from being a simple hobby project for individuals to sort imports in their Python files
+to an essential part of the CI/CD pipeline for large companies and significant Open Source projects.
+Due to this evolution, it is now of increased importance that isort maintains a level of quality, predictability, and consistency
+that gives projects big and small confidence to depend on it.
+
+## Formatting guarantees
+
+With isort 5.1.0, the isort Project guarantees that formatting will stay the same for the options given in accordance to its test suite for the duration of all major releases. This means projects can safely use isort > 5.1.0 < 6.0.0
+without worrying about major formatting changes disrupting their Project.
+
+## Packaging guarantees
+
+Starting with the 5.0.0 release isort includes the following project guarantees to help guide development:
+
+- isort will never have dependencies, optional, required, or otherwise.
+- isort will always act the same independent to the Python environment it is installed in.
+
+## Versioning
+
+isort follows the [Semantic Versioning 2.0.0 specification](https://semver.org/spec/v2.0.0.html) meaning it has three numerical version parts with distinct rules
+`MAJOR.MINOR.PATCH`.
+
+### Patch Releases x.x.1
+
+Within the isort Project, patch releases are really meant solely to fix bugs and minor oversights.
+Patch releases should *never* drastically change formatting, even if it's for the better.
+
+### Minor Releases x.1.x
+
+Minor changes can contain new backward-incompatible features, and of particular note can include bug fixes
+that result in intentional formatting changes - but they should still never be too large in scope.
+API backward compatibility should strictly be maintained.
+
+### Major Releases 1.x.x
+
+Major releases are the only place where backward-incompatible changes or substantial formatting changes can occur.
+Because these kind of changes are likely to break projects that utilize isort, either as a formatter or library,
+isort must do the following:
+
+- Release a release candidate with at least 2 weeks for bugs to be reported and fixed.
+- Keep releasing follow up release candidates until there are no or few bugs reported.
+- Provide an upgrade guide that helps users work around any backward-incompatible changes.
+- Provide a detailed changelog of all changes.
+- Where possible, warn and point to the upgrade guide instead of breaking when options are removed.

package/GitRepos/isort/docs/quick_start/0.-try.md

@@ -0,0 +1,50 @@
+Try isort from your browser!
+========
+
+Use our live isort editor to see how isort can help improve the formatting of your Python imports.
+
+!!! important - "Safe to use. No code is transmitted."
+    The below live isort tester doesn't transmit any of the code you paste to our server or anyone else's. Instead, this page runs a complete Python3 installation with isort installed entirely within your browser. To accomplish this, it utilizes the [pyodide](https://github.com/iodide-project/pyodide) project.
+
+<head>
+<script type="text/javascript">
+    // set the pyodide files URL (packages.json, pyodide.asm.data etc)
+    window.languagePluginUrl = 'https://pyodide-cdn2.iodide.io/v0.15.0/full/';
+</script>
+<script src="https://pyodide-cdn2.iodide.io/v0.15.0/full/pyodide.js"></script>
+<script src="https://pagecdn.io/lib/ace/1.4.5/ace.js" integrity="sha256-5Xkhn3k/1rbXB+Q/DX/2RuAtaB4dRRyQvMs83prFjpM=" crossorigin="anonymous"></script>
+<link rel="stylesheet" type="text/css" href="https://pycqa.github.io/isort/docs/quick_start/interactive.css">
+</head>
+
+
+<div id="liveTester">
+<div id="sideBySide">
+<div id="inputEditor" class="editor">from future import braces
+import b
+import b
+import os
+import a
+from future import braces
+import b
+import a
+import b, a
+</div>
+<div id="outputEditor" class="editor">Loading...</div>
+<div>
+
+&nbsp;Configuration (Note: the below must follow JSON format). Full configuration guide is <a href="https://pycqa.github.io/isort/docs/configuration/options/">here</a>:
+
+<div id="configEditor" class="configurator">{"line_length": 80,
+ "profile": "black",
+ "atomic": true
+}
+</div>
+</div>
+</div>
+</div>
+
+<script src="https://pycqa.github.io/isort/docs/quick_start/interactive.js"></script>
+<div style="clear:both;"></div>
+Like what you saw? Installing isort to use locally is as simple as `pip3 install isort`.
+
+[Click here for full installation instructions.](https://pycqa.github.io/isort/docs/quick_start/1.-install/)

package/GitRepos/isort/docs/quick_start/1.-install.md

@@ -0,0 +1,22 @@
+Install `isort` using your preferred Python package manager:
+
+`pip3 install isort`
+
+OR
+
+`poetry add isort`
+
+OR
+
+`pipenv install isort`
+
+OR
+
+For a fully isolated user installation you can use [pipx](https://github.com/pipxproject/pipx)
+
+`pipx install isort`
+
+<script id="asciicast-qZglwdh3YdoRHjtpxuNmQJehj" src="https://asciinema.org/a/qZglwdh3YdoRHjtpxuNmQJehj.js" async></script>
+
+!!!tip
+    If you want isort to act as a linter for projects, it probably makes since to add isort as an explicit development dependency for each project that uses it. If, on the other hand, you are an individual developer simply using isort as a personal tool to clean up your own commits, a global or user level installation makes sense. Both are seamlessly supported on a single machine.

package/GitRepos/isort/docs/quick_start/2.-cli.md

@@ -0,0 +1,43 @@
+# Command Line Usage
+
+Once installed, `isort` exposes a command line utility for sorting, organizing, and formatting imports within Python and Cython source files.
+
+To verify the tool is installed correctly, run `isort` from the command line and you should be given the available commands and the version of isort installed.
+For a list of all CLI options type `isort --help` or view [the online configuration reference](https://pycqa.github.io/isort/docs/configuration/options/):
+
+<script id="asciicast-346599" src="https://asciinema.org/a/346599.js" async></script>
+
+## Formatting a Project
+
+In general, isort is most commonly utilized across an entire projects source at once. The simplest way to do this is `isort .` or if using a `src` directory `isort src`. isort will automatically find all Python source files recursively and pick-up a configuration file placed at the root of your project if present. This can be combined with any command line configuration customizations such as specifying a profile to use (`isort . --profile black`).
+
+<script id="asciicast-346600" src="https://asciinema.org/a/346600.js" async></script>
+
+## Verifying a Project
+
+The second most common usage of isort is verifying that imports within a project are formatted correctly (often within the context of a CI/CD system). The simplest way to accomplish this is using the check command line option: `isort --check .`. To improve the usefulness of errors when they do occur, this can be combined with the diff option: `isort --check --diff .`.
+
+<script id="asciicast-346601" src="https://asciinema.org/a/346601.js" async></script>
+
+## Single Source Files
+
+Finally, isort can just as easily be ran against individual source files. Simply pass in a single or multiple source files to sort or validate (Example: `isort setup.py`).
+
+<script id="asciicast-346602" src="https://asciinema.org/a/346602.js" async></script>
+
+## Multiple Projects
+
+Running a single isort command across multiple projects, or source files spanning multiple projects, is highly discouraged. Instead it is recommended that an isort process (or command) is ran for each project independently. This is because isort creates an immutable config for each CLI instance.
+
+```
+# YES
+isort project1
+isort project2
+
+# Also YES
+isort project1/src project1/test
+isort project2/src project2/test
+
+# NO
+isort project1 project2
+```

package/GitRepos/isort/docs/quick_start/3.-api.md

@@ -0,0 +1,22 @@
+# Programmatic Python API Usage
+
+In addition to the powerful command line interface, isort exposes a complete Python API.
+
+To use the Python API, `import isort` and then call the desired function call:
+
+<script id="asciicast-346604" src="https://asciinema.org/a/346604.js" async></script>
+
+Every function is fully type hinted and requires and returns only builtin Python objects.
+
+Highlights include:
+
+- `isort.code` - Takes a string containing code, and returns it with imports sorted.
+- `isort.check_code` - Takes a string containing code, and returns `True` if all imports are sorted correctly, otherwise, `False`.
+- `isort.stream` - Takes an input stream containing Python code and an output stream. Outputs code to output stream with all imports sorted.
+- `isort.check_stream` - Takes an input stream containing Python code and returns `True` if all imports in the stream are sorted correctly, otherwise, `False`.
+- `isort.file` - Takes the path of a Python source file and sorts the imports in-place.
+- `isort.check_file` - Takes the path of a Python source file and returns `True` if all imports contained within are sorted correctly, otherwise, `False`.
+- `isort.place_module` - Takes the name of a module as a string and returns the categorization determined for it.
+- `isort.place_module_with_reason` - Takes the name of a module as a string and returns the categorization determined for it and why that categorization was given.
+
+For a full definition of the API see the [API reference documentation](https://pycqa.github.io/isort/reference/isort/api/) or try `help(isort)` from an interactive interpreter.

package/GitRepos/isort/docs/quick_start/interactive.css

@@ -0,0 +1,26 @@
+.editor {
+    height: 400px;
+    width: 49.7%;
+    display: inline-block;
+}
+.configurator {
+    height: 200px;
+    width: 100%;
+    clear: both;
+    float: left;
+}
+#liveTester {
+    background: black;
+    color: white;
+}
+#sideBySide {
+    white-space: nowrap;
+}
+#liveTester.fullscreen {
+    position: absolute;
+    top: 0px;
+    left: 0px;
+    right: 0px;
+    z-index: 99;
+    bottom: 0px;
+}

package/GitRepos/isort/docs/quick_start/interactive.js

@@ -0,0 +1,55 @@
+window.addEventListener('load', () => {
+    var input = ace.edit("inputEditor");
+    var output = ace.edit("outputEditor");
+    var configurator = ace.edit("configEditor");
+
+    [input, output, configurator].forEach((editor) => {
+        editor.setTheme("ace/theme/monokai");
+        editor.session.setMode("ace/mode/python");
+        editor.resize();
+    });
+
+    configurator.session.setMode("ace/mode/json");
+
+    function updateOutput() {
+        output.setValue(document.sort_code(input.getValue(), configurator.getValue()));
+    }
+
+    output.setReadOnly(true);
+    input.session.on('change', updateOutput);
+    configurator.session.on('change', updateOutput);
+
+    document.updateOutput = updateOutput;
+});
+
+
+languagePluginLoader.then(() => {
+    return pyodide.loadPackage(['micropip'])
+}).then(() => {
+    pyodide.runPython(`
+import micropip
+
+from js import document
+
+def use_isort(*args):
+    import isort
+    import json
+    import textwrap
+
+    print(f"Using {isort.__version__} of isort.")
+
+    def sort_code(code, configuration):
+        try:
+            configuration = json.loads(configuration or "{}")
+        except Exception as configuration_error:
+            return "\\n".join(textwrap.wrap(f"Exception thrown trying to read given configuration {configuration_error}", 40))
+        try:
+            return isort.code(code, **configuration)
+        except Exception as isort_error:
+            return "\\n".join(textwrap.wrap(f"Exception thrown trying to sort given imports {isort_error}", 40))
+
+    document.sort_code = sort_code
+    document.updateOutput()
+
+micropip.install('isort').then(use_isort)`);
+});

package/GitRepos/isort/docs/upgrade_guides/5.0.0.md

@@ -0,0 +1,97 @@
+# Upgrading to 5.0.0
+
+isort 5.0.0 is the first major release of isort in 5 years, and as such it does introduce some breaking changes.
+This guide is meant to help migrate projects from using isort 4.x.x unto the 5.0.0 release.
+
+Related documentation:
+
+* [isort 5.0.0 changelog](https://pycqa.github.io/isort/CHANGELOG/#500-penny-july-4-2020)
+* [isort 5 release document](https://pycqa.github.io/isort/docs/major_releases/introducing_isort_5/)
+
+!!! important - "If you use pre-commit remove seed-isort-config."
+    If you currently use pre-commit, make sure to see the pre-commit section of this document. In particular, make sure to remove any `seed-isort-config` pre-step.
+
+## Imports no Longer Moved to Top
+
+One of the most immediately evident changes when upgrading to isort 5, is it now avoids moving imports around code by default.
+The great thing about this is that it means that isort can safely run against complex code bases that need to place side effects between import sections without needing any comments, flags, or configs. It's also part of the rearchitecting that allows it to sort within type checking conditionals and functions. However, it can be a jarring change
+for those of us who have gotten used to placing imports right above their usage in code to avoid context switching. No need to worry! isort still supports this work mode.
+
+If you want to move all imports to the top, you can use the new`--float-to-top` flag in the CLI or `float_to_top=true` option in your config file.
+
+See: [https://pycqa.github.io/isort/docs/configuration/options/#float-to-top](https://pycqa.github.io/isort/docs/configuration/options/#float-to-top)
+
+## Migrating CLI options
+
+### `--dont-skip` or `-ns`
+In an earlier version isort had a default skip of `__init__.py`. To get around that many projects wanted a way to not skip `__init__.py` or any other files that were automatically skipped in the future by isort. isort no longer has any default skips, so if the value here is `__init__.py` you can simply remove the command line option. If it is something else, just make sure you aren't specifying to skip that file somewhere else in your config.
+
+### `--recursive` or `-rc`
+Prior to version 5.0.0, isort wouldn't automatically traverse directories. The --recursive option was necessary to tell it to do so. In 5.0.0 directories are automatically traversed for all Python files, and as such this option is no longer necessary and should simply be removed.
+
+### `--apply` or `-y`
+Prior to version 5.0.0, depending on how isort was executed, it would ask you before making every file change. In isort 5.0.0 file changes happen by default inline with other formatters. `--interactive` is available to restore the previous behavior. If encountered this option can simply be removed.
+
+### `--keep-direct-and-as` or `-k`
+Many versions ago, by default isort would remove imports such as `from datetime import datetime` if an alias for the same import also existed such as `from datetime import datetime as dt` - never allowing both to exist.
+The option was originally added to allow working around this, and was then turned on as the default. Now the option for the old behaviour has been removed. Simply remove the option from your config file.
+
+### `-ac`, `-wl`, `-ws`, `-tc`, `-sp`, `-sp`, `-sl`, `-sg`, `-sd`, `-rr`, `-ot`, `-nlb`, `-nis`, `-ls`, `-le`, `-lbt`, `-lai`, `-fss`, `-fgw`, `-ff`, `-fass`, `-fas`, `-dt`, `-ds`, `-df`, `-cs`, `-ca`, `-af`, `-ac`
+Two-letter shortened setting names (like `ac` for `atomic`) now require two dashes to avoid ambiguity. Simply add another dash before the option, or switch to the long form option to fix (example: `--ac` or `--atomic`).
+
+### `-v` and `-V`
+The `-v` (previously for version now for verbose) and `-V` (previously for verbose and now for version) options have been swapped to be more consistent with tools across the CLI and in particular Python ecosystem.
+
+## Migrating Config options
+
+The first thing to keep in mind is how isort loads config options has changed in isort 5. It will no longer merge multiple config files, instead you must have 1 isort config per a project.
+If you have multiple configs, they will need to be merged into 1 single one. You can see the priority order of configuration files and the manner in which they are loaded on the
+[config files documentation page](https://pycqa.github.io/isort/docs/configuration/config_files/).
+
+!!! tip - "Config options are loaded relative to the file, not the isort instance."
+    isort looks for a config file based on the path of the file you request to sort. If you have your config placed outside of the project, you can use `--settings-path` to manually specify the config location instead. Full information about how config files are loaded is in the linked config files documentation page.
+
+
+### `not_skip`
+This is the same as the `--dont-skip` CLI option above. In an earlier version isort had a default skip of `__init__.py`. To get around that many projects wanted a way to not skip `__init__.py` or any other files that were automatically skipped in the future by isort. isort no longer has any default skips, so if the value here is `__init__.py` you can simply remove the setting. If it is something else, just make sure you aren't specifying to skip that file somewhere else in your config.
+
+### `keep_direct_and_as_imports`
+This is the same as `keep-direct-and-as` from CLI. Many versions ago, by default isort would remove imports such as `from datetime import datetime` if an alias for the same import also existed such as `from datetime import datetime as dt` - never allowing both to exist.
+The option was originally added to allow working around this, and was then turned on as the default. Now the option for the old behaviour has been removed. Simply remove the option from your config file.
+
+### `known_standard_library`
+isort settings no longer merge together, instead they override. The old behavior of merging together caused many hard to
+track down errors, but the one place it was very convenient was for adding a few additional standard library modules.
+In isort 5, you can still get this behavior by moving your extra modules from the `known_standard_library` setting to [`extra_standard_library`](https://pycqa.github.io/isort/docs/configuration/options/#extra-standard-library).
+
+### module placement changes: `known_third_party`, `known_first_party`, `default_section`, etc...
+isort has completely rewritten its logic for placing modules in 5.0.0 to ensure the same behavior across environments. You can see the details of this change [here](https://github.com/pycqa/isort/issues/1147).
+The TL;DR of which is that isort has now changed from `default_section=FIRSTPARTY` to `default_section=THIRDPARTY`. If you all already setting the default section to third party, your config is probably in good shape.
+If not, you can either use the old finding approach with `--magic-placement` in the CLI or `old_finders=True` in your config, or preferably, you are able to remove all placement options and isort will determine it correctly.
+If it doesn't, you should be able to just specify your projects modules with `known_first_party` and be done with it.
+
+## Migrating pre-commit
+
+### seed-isort-config
+
+If you have a step in your precommit called `seed-isort-config` or similar, it is highly recommend that you remove this. It is unnecessary in 5.x.x, is guaranteed to slow things down, and worse can conflict with isort's own module placement logic.
+
+### isort pre-commit step
+
+isort now includes an optimized precommit configuration in the repo itself. To use it you can replace any existing isort precommit step with:
+
+```
+  - repo: https://github.com/pycqa/isort
+    rev: 5.8.0
+    hooks:
+      - id: isort
+        name: isort (python)
+      - id: isort
+        name: isort (cython)
+        types: [cython]
+      - id: isort
+        name: isort (pyi)
+        types: [pyi]
+```
+
+under the `repos` section of your projects `.pre-commit-config.yaml` config.

package/GitRepos/isort/docs/warning_and_error_codes/W0500.md

@@ -0,0 +1,22 @@
+# W0500 Warning Codes
+
+The W0500 error codes are reserved for warnings related to a major release of the isort project.
+Generally, the existence of any of these will trigger one additional warning listing the upgrade guide.
+
+For the most recent upgrade guide, see: [The 5.0.0 Upgrade Guide.](https://pycqa.github.io/isort/docs/upgrade_guides/5.0.0/).
+
+## W0501: Deprecated CLI flags were included that will be ignored.
+
+This warning will be shown if a CLI flag is passed into the isort command that is no longer supported but can safely be ignored.
+Often, this happens because an argument used to be required to turn on a feature that then became the default. An example of this
+is `--recursive` which became the default behavior for all folders passed-in starting with 5.0.0.
+
+## W0502: Deprecated CLI flags were included that will safely be remapped.
+
+This warning will be shown if a CLI flag is passed into the isort command that is no longer supported but can safely be remapped to the new version of the flag. If you encounter this warning, you must update the argument to match the new flag
+before the next major release.
+
+## W0503: Deprecated config options were ignored.
+
+This warning will be shown if a deprecated config option is defined in the Project's isort config file, but can safely be ignored.
+This is similar to `W0500` but dealing with config files rather than CLI flags.

package/GitRepos/isort/example_isort_formatting_plugin/example_isort_formatting_plugin.py

@@ -0,0 +1,23 @@
+import black
+
+import isort
+
+
+def black_format_import_section(
+    contents: str, extension: str, config: isort.settings.Config
+) -> str:
+    """Formats the given import section using black."""
+    if extension.lower() not in ("pyi", "py"):
+        return contents
+
+    try:
+        return black.format_file_contents(
+            contents,
+            fast=True,
+            mode=black.FileMode(
+                is_pyi=extension.lower() == "pyi",
+                line_length=config.line_length,
+            ),
+        )
+    except black.NothingChanged:
+        return contents