Spellcheck & grammar (astral-sh#10375)

## Summary

I used `codespell` and `gramma` to identify mispellings and grammar
errors throughout the codebase and fixed them. I tried not to make any
controversial changes, but feel free to revert as you see fit.

crates/ruff/tests/format.rs

@@ -23,7 +23,7 @@ fn default_options() {
         .arg("-")
         .pass_stdin(r#"
 def foo(arg1, arg2,):
-    print('Should\'t change quotes')
+    print('Shouldn\'t change quotes')
 
 
 if condition:
@@ -38,7 +38,7 @@ if condition:
         arg1,
         arg2,
     ):
-        print("Should't change quotes")
+        print("Shouldn't change quotes")
 
 
     if condition:

crates/ruff_formatter/src/buffer.rs

@@ -37,7 +37,7 @@ pub trait Buffer {
     #[doc(hidden)]
     fn elements(&self) -> &[FormatElement];
 
-    /// Glue for usage of the [`write!`] macro with implementors of this trait.
+    /// Glue for usage of the [`write!`] macro with implementers of this trait.
     ///
     /// This method should generally not be invoked manually, but rather through the [`write!`] macro itself.
     ///

crates/ruff_linter/resources/test/fixtures/pycodestyle/W505.py

@@ -10,7 +10,7 @@ def f1():
     # Here's a standalone comment that's over the limit.
 
     x = 2
-    # Another standalone that is preceded by a newline and indent toke and is over the limit.
+    # Another standalone that is preceded by a newline and indent token and is over the limit.
 
     print("Here's a string that's over the limit, but it's not a docstring.")
 

crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py

@@ -10,7 +10,7 @@ def f1():
     # Here's a standalone comment that's over theß9💣2ℝ.
 
     x = 2
-    # Another standalone that is preceded by a newline and indent toke and is over theß9💣2ℝ.
+    # Another standalone that is preceded by a newline and indent token and is over theß9💣2ℝ.
 
     print("Here's a string that's over theß9💣2ℝ, but it's not a ß9💣2ℝing.")
 

crates/ruff_linter/resources/test/fixtures/ruff/RUF021.py

@@ -47,7 +47,7 @@
     and some_third_reasonably_long_condition
     or some_fourth_reasonably_long_condition
     and some_fifth_reasonably_long_condition
-    # a commment
+    # a comment
     and some_sixth_reasonably_long_condition
     and some_seventh_reasonably_long_condition
     # another comment

crates/ruff_linter/resources/test/fixtures/ruff/RUF022.py

@@ -48,7 +48,7 @@
 # we implement an "isort-style sort":
 # SCEAMING_CASE constants first,
 # then CamelCase classes,
-# then anything thats lowercase_snake_case.
+# then anything that's lowercase_snake_case.
 # This (which is currently alphabetically sorted)
 # should get reordered accordingly:
 __all__ = [

crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs

@@ -294,7 +294,7 @@ impl Violation for MissingReturnTypePrivateFunction {
 ///
 /// Note that type checkers often allow you to omit the return type annotation for
 /// `__init__` methods, as long as at least one argument has a type annotation. To
-/// opt-in to this behavior, use the `mypy-init-return` setting in your `pyproject.toml`
+/// opt in to this behavior, use the `mypy-init-return` setting in your `pyproject.toml`
 /// or `ruff.toml` file:
 ///
 /// ```toml

crates/ruff_linter/src/rules/flake8_bandit/rules/logging_config_insecure_listen.rs

@@ -11,7 +11,7 @@ use crate::checkers::ast::Checker;
 ///
 /// ## Why is this bad?
 /// `logging.config.listen` starts a server that listens for logging
-/// configuration requests. This is insecure as parts of the configuration are
+/// configuration requests. This is insecure, as parts of the configuration are
 /// passed to the built-in `eval` function, which can be used to execute
 /// arbitrary code.
 ///

crates/ruff_linter/src/rules/flake8_bandit/rules/shell_injection.rs

@@ -222,7 +222,7 @@ impl Violation for StartProcessWithNoShell {
 ///
 /// ## Why is this bad?
 /// Starting a process with a partial executable path can allow attackers to
-/// execute arbitrary executable by adjusting the `PATH` environment variable.
+/// execute an arbitrary executable by adjusting the `PATH` environment variable.
 /// Consider using a full path to the executable instead.
 ///
 /// ## Example

crates/ruff_linter/src/rules/flake8_bandit/rules/ssh_no_host_key_verification.rs

@@ -11,7 +11,7 @@ use crate::checkers::ast::Checker;
 /// Checks for uses of policies disabling SSH verification in Paramiko.
 ///
 /// ## Why is this bad?
-/// By default, Paramiko checks the identity of remote host when establishing
+/// By default, Paramiko checks the identity of the remote host when establishing
 /// an SSH connection. Disabling the verification might lead to the client
 /// connecting to a malicious host, without the client knowing.
 ///

crates/ruff_linter/src/rules/flake8_bandit/rules/suspicious_function_call.rs

@@ -59,7 +59,7 @@ impl Violation for SuspiciousPickleUsage {
 /// Checks for calls to `marshal` functions.
 ///
 /// ## Why is this bad?
-/// Deserializing untrusted data with `marshal` is insecure as it can allow for
+/// Deserializing untrusted data with `marshal` is insecure, as it can allow for
 /// the creation of arbitrary objects, which can then be used to achieve
 /// arbitrary code execution and otherwise unexpected behavior.
 ///
@@ -68,7 +68,7 @@ impl Violation for SuspiciousPickleUsage {
 ///
 /// If you must deserialize untrusted data with `marshal`, consider signing the
 /// data with a secret key and verifying the signature before deserializing the
-/// payload, This will prevent an attacker from injecting arbitrary objects
+/// payload. This will prevent an attacker from injecting arbitrary objects
 /// into the serialized data.
 ///
 /// ## Example
@@ -353,7 +353,7 @@ impl Violation for SuspiciousMarkSafeUsage {
 /// behavior.
 ///
 /// To mitigate this risk, audit all uses of URL open functions and ensure that
-/// only permitted schemes are used (e.g., allowing `http:` and `https:` and
+/// only permitted schemes are used (e.g., allowing `http:` and `https:`, and
 /// disallowing `file:` and `ftp:`).
 ///
 /// ## Example
@@ -395,7 +395,7 @@ impl Violation for SuspiciousURLOpenUsage {
 /// Checks for uses of cryptographically weak pseudo-random number generators.
 ///
 /// ## Why is this bad?
-/// Cryptographically weak pseudo-random number generators are insecure as they
+/// Cryptographically weak pseudo-random number generators are insecure, as they
 /// are easily predictable. This can allow an attacker to guess the generated
 /// numbers and compromise the security of the system.
 ///

crates/ruff_linter/src/rules/flake8_bandit/rules/suspicious_imports.rs

@@ -245,7 +245,7 @@ impl Violation for SuspiciousLxmlImport {
 /// Checks for imports of the `xmlrpc` module.
 ///
 /// ## Why is this bad?
-/// XMLRPC is a particularly dangerous XML module as it is also concerned with
+/// XMLRPC is a particularly dangerous XML module, as it is also concerned with
 /// communicating data over a network. Use the `defused.xmlrpc.monkey_patch()`
 /// function to monkey-patch the `xmlrpclib` module and mitigate remote XML
 /// attacks.

crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_collection_call.rs

@@ -13,7 +13,7 @@ use crate::rules::flake8_comprehensions::settings::Settings;
 /// rewritten as empty literals.
 ///
 /// ## Why is this bad?
-/// It's unnecessary to call e.g., `dict()` as opposed to using an empty
+/// It's unnecessary to call, e.g., `dict()` as opposed to using an empty
 /// literal (`{}`). The former is slower because the name `dict` must be
 /// looked up in the global scope in case it has been rebound.
 ///

crates/ruff_linter/src/rules/flake8_django/rules/model_without_dunder_str.rs

@@ -10,14 +10,14 @@ use crate::checkers::ast::Checker;
 use super::helpers;
 
 /// ## What it does
-/// Checks that `__str__` method is defined in Django models.
+/// Checks that a `__str__` method is defined in Django models.
 ///
 /// ## Why is this bad?
-/// Django models should define `__str__` method to return a string representation
+/// Django models should define a `__str__` method to return a string representation
 /// of the model instance, as Django calls this method to display the object in
 /// the Django Admin and elsewhere.
 ///
-/// Models without `__str__` method will display a non-meaningful representation
+/// Models without a `__str__` method will display a non-meaningful representation
 /// of the object in the Django Admin.
 ///
 /// ## Example

crates/ruff_linter/src/rules/flake8_pie/rules/multiple_starts_ends_with.rs

@@ -21,7 +21,7 @@ use crate::checkers::ast::Checker;
 /// ## Why is this bad?
 /// The `startswith` and `endswith` methods accept tuples of prefixes or
 /// suffixes respectively. Passing a tuple of prefixes or suffixes is more
-/// more efficient and readable than calling the method multiple times.
+/// efficient and readable than calling the method multiple times.
 ///
 /// ## Example
 /// ```python

crates/ruff_linter/src/rules/flake8_pyi/rules/unnecessary_literal_union.rs

@@ -11,7 +11,7 @@ use crate::checkers::ast::Checker;
 /// Checks for the presence of multiple literal types in a union.
 ///
 /// ## Why is this bad?
-/// Literal types accept multiple arguments and it is clearer to specify them
+/// Literal types accept multiple arguments, and it is clearer to specify them
 /// as a single literal.
 ///
 /// ## Example

crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs

@@ -103,9 +103,9 @@ impl Violation for PytestParametrizeNamesWrongType {
 /// of values.
 ///
 /// The style for the list of values rows can be configured via the
-/// the [`lint.flake8-pytest-style.parametrize-values-type`] setting, while the
+/// [`lint.flake8-pytest-style.parametrize-values-type`] setting, while the
 /// style for each row of values can be configured via the
-/// the [`lint.flake8-pytest-style.parametrize-values-row-type`] setting.
+/// [`lint.flake8-pytest-style.parametrize-values-row-type`] setting.
 ///
 /// For example, [`lint.flake8-pytest-style.parametrize-values-type`] will lead to
 /// the following expectations:

crates/ruff_linter/src/rules/flake8_return/rules/function.rs

@@ -151,7 +151,7 @@ impl AlwaysFixableViolation for ImplicitReturn {
 /// assigned variable.
 ///
 /// ## Why is this bad?
-/// The variable assignment is not necessary as the value can be returned
+/// The variable assignment is not necessary, as the value can be returned
 /// directly.
 ///
 /// ## Example

crates/ruff_linter/src/rules/flake8_simplify/rules/ast_ifexp.rs

@@ -61,7 +61,7 @@ impl Violation for IfExprWithTrueFalse {
 /// condition.
 ///
 /// ## Why is this bad?
-/// `if` expressions that evaluate to `False` for a truthy condition an `True`
+/// `if` expressions that evaluate to `False` for a truthy condition and `True`
 /// for a falsey condition can be replaced with `not` operators, which are more
 /// concise and readable.
 ///

crates/ruff_linter/src/rules/flake8_tidy_imports/rules/banned_api.rs

@@ -13,15 +13,14 @@ use crate::rules::flake8_tidy_imports::matchers::NameMatchPolicy;
 ///
 /// ## Why is this bad?
 /// Projects may want to ensure that specific modules or module members are
-/// not be imported or accessed.
+/// not imported or accessed.
 ///
 /// Security or other company policies may be a reason to impose
 /// restrictions on importing external Python libraries. In some cases,
 /// projects may adopt conventions around the use of certain modules or
 /// module members that are not enforceable by the language itself.
 ///
-/// This rule enforces certain import conventions project-wide in an
-/// automatic way.
+/// This rule enforces certain import conventions project-wide automatically.
 ///
 /// ## Options
 /// - `lint.flake8-tidy-imports.banned-api`

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/glob_rule.rs

@@ -16,7 +16,7 @@ use ruff_macros::{derive_message_formats, violation};
 ///
 /// |                   | `glob`                                                                                                                                                             | `Path.glob`                                                                                                                                |
 /// |-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
-/// | Hidden files      | Excludes hidden files by default. From Python 3.11 onwards, the `include_hidden` keyword can used to include hidden directories.                                   | Includes hidden files by default.                                                                                                          |
+/// | Hidden files      | Excludes hidden files by default. From Python 3.11 onwards, the `include_hidden` keyword can be used to include hidden directories.                                   | Includes hidden files by default.                                                                                                          |
 /// | Iterator          | `iglob` returns an iterator. Under the hood, `glob` simply converts the iterator to a list.                                                                        | `Path.glob` returns an iterator.                                                                                                           |
 /// | Working directory | `glob` takes a `root_dir` keyword to set the current working directory.                                                                                            | `Path.rglob` can be used to return the relative path.                                                                                      |
 /// | Globstar (`**`)   | `glob` requires the `recursive` flag to be set to `True` for the `**` pattern to match any files and zero or more directories, subdirectories, and symbolic links. | The `**` pattern in `Path.glob` means "this directory and all subdirectories, recursively". In other words, it enables recursive globbing. |

crates/ruff_linter/src/rules/numpy/rules/deprecated_type_alias.rs

@@ -15,7 +15,7 @@ use crate::checkers::ast::Checker;
 /// primarily for historic reasons, and have been a cause of
 /// frequent confusion for newcomers.
 ///
-/// These aliases were been deprecated in 1.20, and removed in 1.24.
+/// These aliases were deprecated in 1.20, and removed in 1.24.
 ///
 /// ## Examples
 /// ```python

crates/ruff_linter/src/rules/pandas_vet/rules/attr.rs

@@ -10,7 +10,7 @@ use crate::rules::pandas_vet::helpers::{test_expression, Resolution};
 /// Checks for uses of `.values` on Pandas Series and Index objects.
 ///
 /// ## Why is this bad?
-/// The `.values` attribute is ambiguous as it's return type is unclear. As
+/// The `.values` attribute is ambiguous as its return type is unclear. As
 /// such, it is no longer recommended by the Pandas documentation.
 ///
 /// Instead, use `.to_numpy()` to return a NumPy array, or `.array` to return a

crates/ruff_linter/src/rules/pep8_naming/rules/invalid_module_name.rs

@@ -21,7 +21,7 @@ use crate::rules::pep8_naming::settings::IgnoreNames;
 /// > all-lowercase names, although the use of underscores is discouraged.
 /// >
 /// > When an extension module written in C or C++ has an accompanying Python module that
-/// > provides a higher level (e.g. more object oriented) interface, the C/C++ module has
+/// > provides a higher level (e.g. more object-oriented) interface, the C/C++ module has
 /// > a leading underscore (e.g. `_socket`).
 ///
 /// Further, in order for Python modules to be importable, they must be valid

crates/ruff_linter/src/rules/pycodestyle/rules/blank_lines.rs

@@ -241,7 +241,7 @@ impl AlwaysFixableViolation for BlankLineAfterDecorator {
 /// Checks for missing blank lines after the end of function or class.
 ///
 /// ## Why is this bad?
-/// PEP 8 recommends using blank lines as following:
+/// PEP 8 recommends using blank lines as follows:
 /// - Two blank lines are expected between functions and classes
 /// - One blank line is expected between methods of a class.
 ///
@@ -292,7 +292,7 @@ impl AlwaysFixableViolation for BlankLinesAfterFunctionOrClass {
 /// Checks for 1 blank line between nested function or class definitions.
 ///
 /// ## Why is this bad?
-/// PEP 8 recommends using blank lines as following:
+/// PEP 8 recommends using blank lines as follows:
 /// - Two blank lines are expected between functions and classes
 /// - One blank line is expected between methods of a class.
 ///

crates/ruff_linter/src/rules/pycodestyle/rules/missing_newline_at_end_of_file.rs

@@ -9,8 +9,9 @@ use ruff_source_file::Locator;
 /// Checks for files missing a new line at the end of the file.
 ///
 /// ## Why is this bad?
-/// Trailing blank lines are superfluous.
-/// However the last line should end with a new line.
+/// Trailing blank lines in a file are superfluous.
+///
+/// However, the last line of the file should end with a newline.
 ///
 /// ## Example
 /// ```python

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__max_doc_length.snap

@@ -27,11 +27,11 @@ W505.py:10:51: W505 Doc line too long (56 > 50)
 12 |     x = 2
    |
 
-W505.py:13:51: W505 Doc line too long (93 > 50)
+W505.py:13:51: W505 Doc line too long (94 > 50)
    |
 12 |     x = 2
-13 |     # Another standalone that is preceded by a newline and indent toke and is over the limit.
-   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ W505
+13 |     # Another standalone that is preceded by a newline and indent token and is over the limit.
+   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ W505
 14 | 
 15 |     print("Here's a string that's over the limit, but it's not a docstring.")
    |
@@ -58,5 +58,3 @@ W505.py:31:51: W505 Doc line too long (85 > 50)
 31 |     It's over the limit on this line, which isn't the first line in the docstring."""
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ W505
    |
-
-

crates/ruff_linter/src/rules/pycodestyle/snapshots/ruff_linter__rules__pycodestyle__tests__max_doc_length_with_utf_8.snap

@@ -27,11 +27,11 @@ W505_utf_8.py:10:51: W505 Doc line too long (56 > 50)
 12 |     x = 2
    |
 
-W505_utf_8.py:13:51: W505 Doc line too long (93 > 50)
+W505_utf_8.py:13:51: W505 Doc line too long (94 > 50)
    |
 12 |     x = 2
-13 |     # Another standalone that is preceded by a newline and indent toke and is over theß9💣2ℝ.
-   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ W505
+13 |     # Another standalone that is preceded by a newline and indent token and is over theß9💣2ℝ.
+   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ W505
 14 | 
 15 |     print("Here's a string that's over theß9💣2ℝ, but it's not a ß9💣2ℝing.")
    |
@@ -58,5 +58,3 @@ W505_utf_8.py:31:50: W505 Doc line too long (85 > 50)
 31 |     It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing."""
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ W505
    |
-
-

crates/ruff_linter/src/rules/pydocstyle/rules/blank_before_after_class.rs

@@ -60,7 +60,7 @@ impl AlwaysFixableViolation for OneBlankLineBeforeClass {
 ///
 /// ## Why is this bad?
 /// [PEP 257] recommends the use of a blank line to separate a class's
-/// docstring its methods.
+/// docstring from its methods.
 ///
 /// This rule may not apply to all projects; its applicability is a matter of
 /// convention. By default, this rule is enabled when using the `google`

crates/ruff_linter/src/rules/pydocstyle/rules/not_missing.rs

@@ -368,7 +368,7 @@ impl Violation for UndocumentedPublicPackage {
 /// ## Why is this bad?
 /// Magic methods (methods with names that start and end with double
 /// underscores) are used to implement operator overloading and other special
-/// behavior. Such methods should should be documented via docstrings to
+/// behavior. Such methods should be documented via docstrings to
 /// outline their behavior.
 ///
 /// Generally, magic method docstrings should describe the method's behavior,

crates/ruff_linter/src/rules/pylint/rules/compare_to_empty_string.rs

@@ -13,8 +13,8 @@ use crate::checkers::ast::Checker;
 ///
 /// ## Why is this bad?
 /// An empty string is falsy, so it is unnecessary to compare it to `""`. If
-/// the value can be something else Python considers falsy, such as `None` or
-/// `0` or another empty container, then the code is not equivalent.
+/// the value can be something else Python considers falsy, such as `None`,
+/// `0`, or another empty container, then the code is not equivalent.
 ///
 /// ## Known problems
 /// High false positive rate, as the check is context-insensitive and does not

crates/ruff_linter/src/rules/pylint/rules/redefined_argument_from_local.rs

@@ -6,8 +6,8 @@ use ruff_macros::{derive_message_formats, violation};
 /// that redefine function parameters.
 ///
 /// ## Why is this bad?
-/// Redefined variable can cause unexpected behavior because of overridden function parameter.
-/// If nested functions are declared, inner function's body can override outer function's parameter.
+/// Redefined variables can cause unexpected behavior because of overridden function parameters.
+/// If nested functions are declared, an inner function's body can override an outer function's parameters.
 ///
 /// ## Example
 /// ```python

crates/ruff_linter/src/rules/pylint/rules/redefined_loop_name.rs

@@ -29,7 +29,7 @@ use crate::checkers::ast::Checker;
 /// into the remainder of the enclosing loop.
 ///
 /// While this mistake is easy to spot in small examples, it can be hidden
-/// in larger blocks of code where the definition and redefinition of the
+/// in larger blocks of code, where the definition and redefinition of the
 /// variable may not be visible at the same time.
 ///
 /// ## Example