docs: use rumdl to make more sentences single-line (#5584)

* docs: use `rumdl` to make more sentences single-line

* Update guide/src/class/call.md

Co-authored-by: Lily <code@lilyf.org>

---------

Co-authored-by: Lily <code@lilyf.org>

Author: davidhewitt

guide/pyclass-parameters.md

@@ -28,8 +28,7 @@
 | `unsendable` | Required if your struct is not [`Send`][params-3]. Rather than using `unsendable`, consider implementing your struct in a thread-safe way by e.g. substituting [`Rc`][params-4] with [`Arc`][params-5]. By using `unsendable`, your class will panic when accessed by another thread. Also note the Python's GC is multi-threaded and while unsendable classes will not be traversed on foreign threads to avoid UB, this can lead to memory leaks. |
 | `weakref` | Allows this class to be [weakly referenceable][params-6]. |
 
-All of these parameters can either be passed directly on the `#[pyclass(...)]` annotation, or as one or
-more accompanying `#[pyo3(...)]` annotations, e.g.:
+All of these parameters can either be passed directly on the `#[pyclass(...)]` annotation, or as one or more accompanying `#[pyo3(...)]` annotations, e.g.:
 
 ```rust,ignore
 // Argument supplied directly to the `#[pyclass]` annotation.

guide/src/SUMMARY.md

@@ -43,8 +43,11 @@
 ---
 
 [Appendix A: Migration guide](migration.md)
+
 [Appendix B: Trait bounds](trait-bounds.md)
+
 [Appendix C: Python typing hints](python-typing-hints.md)
+
 [CHANGELOG](changelog.md)
 
 ---

guide/src/building-and-distribution.md

@@ -255,11 +255,9 @@ As an advanced feature, you can build PyO3 wheel without calling Python interpre
 Also, if the build host Python interpreter is not found or is too old or otherwise unusable, PyO3 will still attempt to compile `abi3` extension modules after displaying a warning message.
 On Unix-like systems this works unconditionally; on Windows you must also set the `RUSTFLAGS` environment variable to contain `-L native=/path/to/python/libs` so that the linker can find `python3.lib`.
 
-If the `python3.dll` import library is not available, an experimental `generate-import-lib` crate
-feature may be enabled, and the required library will be created and used by PyO3 automatically.
+If the `python3.dll` import library is not available, an experimental `generate-import-lib` crate feature may be enabled, and the required library will be created and used by PyO3 automatically.
 
-*Note*: MSVC targets require LLVM binutils (`llvm-dlltool`) to be available in `PATH` for
-the automatic import library generation feature to work.
+*Note*: MSVC targets require LLVM binutils (`llvm-dlltool`) to be available in `PATH` for the automatic import library generation feature to work.
 
 #### Missing features
 
@@ -395,9 +393,7 @@ cargo build --target x86_64-pc-windows-gnu
 
 Any of the `abi3-py3*` features can be enabled instead of setting `PYO3_CROSS_PYTHON_VERSION` in the above examples.
 
-`PYO3_CROSS_LIB_DIR` can often be omitted when cross compiling extension modules for Unix and macOS targets,
-or when cross compiling extension modules for Windows and the experimental `generate-import-lib`
-crate feature is enabled.
+`PYO3_CROSS_LIB_DIR` can often be omitted when cross compiling extension modules for Unix and macOS targets, or when cross compiling extension modules for Windows and the experimental `generate-import-lib` crate feature is enabled.
 
 The following resources may also be useful for cross-compiling:
 

guide/src/class.md

@@ -184,14 +184,11 @@ impl Nonzero {
 }
 ```
 
-If you want to return an existing object (for example, because your `new`
-method caches the values it returns), `new` can return `pyo3::Py<Self>`.
+If you want to return an existing object (for example, because your `new` method caches the values it returns), `new` can return `pyo3::Py<Self>`.
 
-As you can see, the Rust method name is not important here; this way you can
-still, use `new()` for a Rust-level constructor.
+As you can see, the Rust method name is not important here; this way you can still, use `new()` for a Rust-level constructor.
 
-If no method marked with `#[new]` is declared, object instances can only be
-created from Rust, but not from Python.
+If no method marked with `#[new]` is declared, object instances can only be created from Rust, but not from Python.
 
 For arguments, see the [`Method arguments`](#method-arguments) section below.
 
@@ -327,8 +324,7 @@ These parameters are covered in various sections of this guide.
 
 ### Return type
 
-Generally, `#[new]` methods have to return `T: Into<PyClassInitializer<Self>>` or
-`PyResult<T> where T: Into<PyClassInitializer<Self>>`.
+Generally, `#[new]` methods have to return `T: Into<PyClassInitializer<Self>>` or `PyResult<T> where T: Into<PyClassInitializer<Self>>`.
 
 For constructors that may fail, you should wrap the return type in a PyResult as well.
 Consult the table below to determine which type your constructor should return:
@@ -547,8 +543,7 @@ impl MyDict {
 # }
 ```
 
-Here, the `args` and `kwargs` allow creating instances of the subclass passing
-initial items, such as `MyDict(item_sequence)` or `MyDict(a=1, b=2)`.
+Here, the `args` and `kwargs` allow creating instances of the subclass passing initial items, such as `MyDict(item_sequence)` or `MyDict(a=1, b=2)`.
 
 ## Object properties
 
@@ -695,11 +690,9 @@ impl MyClass {
 
 Both `&self` and `&mut self` can be used, due to the use of [runtime borrow checking](#bound-and-interior-mutability).
 
-The return type must be `PyResult<T>` or `T` for some `T` that implements `IntoPyObject`;
-the latter is allowed if the method cannot raise Python exceptions.
+The return type must be `PyResult<T>` or `T` for some `T` that implements `IntoPyObject`; the latter is allowed if the method cannot raise Python exceptions.
 
-A `Python` parameter can be specified as part of method signature, in this case the `py` argument
-gets injected by the method wrapper, e.g.
+A `Python` parameter can be specified as part of method signature, in this case the `py` argument gets injected by the method wrapper, e.g.
 
 ```rust
 # use pyo3::prelude::*;
@@ -794,8 +787,7 @@ impl MyClass {
 
 ## Class attributes
 
-To create a class attribute (also called [class variable][classattr]), a method without
-any arguments can be annotated with the `#[classattr]` attribute.
+To create a class attribute (also called [class variable][classattr]), a method without any arguments can be annotated with the `#[classattr]` attribute.
 
 ```rust,no_run
 # use pyo3::prelude::*;
@@ -820,8 +812,7 @@ class creation.
 
 > Note: `#[classattr]` does not work with [`#[pyo3(warn(...))]`](./function.md#warn) attribute.
 
-If the class attribute is defined with `const` code only, one can also annotate associated
-constants:
+If the class attribute is defined with `const` code only, one can also annotate associated constants:
 
 ```rust,no_run
 # use pyo3::prelude::*;
@@ -1054,8 +1045,7 @@ impl MyClass {
 # }
 ```
 
-Note that `text_signature` on `#[new]` is not compatible with compilation in
-`abi3` mode until Python 3.10 or greater.
+Note that `text_signature` on `#[new]` is not compatible with compilation in `abi3` mode until Python 3.10 or greater.
 
 ### Method receivers and lifetime elision
 

guide/src/class/call.md

@@ -3,8 +3,7 @@
 Classes can be callable if they have a `#[pymethod]` named `__call__`.
 This allows instances of a class to behave similar to functions.
 
-This method's signature must look like `__call__(<self>, ...) -> object` - here,
- any argument list can be defined as for normal pymethods
+This method's signature must look like `__call__(<self>, ...) -> object` - here, any argument list can be defined as for normal pymethods
 
 ## Example: Implementing a call counter
 

guide/src/class/object.md

@@ -25,8 +25,7 @@ mod my_module {
 }
 ```
 
-At this point Python code can import the module, access the class and create class instances - but
-nothing else.
+At this point Python code can import the module, access the class and create class instances - but nothing else.
 
 ```python
 from my_module import Number
@@ -99,8 +98,7 @@ It expands and is passed into the `format!` macro in the following ways:
 - `"{0}"` -> `"{}", self.0`
 - `"{x:?}"` -> `"{:?}", self.x`
 
-*Note: Depending upon the format string you use, this may require implementation of the `Display` or `Debug` traits for the given Rust types.*
-*Note: the pyclass args `name` and `rename_all` are incompatible with the shorthand format string and will raise a compile time error.*
+*Note: Depending upon the format string you use, this may require implementation of the `Display` or `Debug` traits for the given Rust types.* *Note: the pyclass args `name` and `rename_all` are incompatible with the shorthand format string and will raise a compile time error.*
 
 ```rust,no_run
 # use pyo3::prelude::*;
@@ -239,8 +237,7 @@ impl Number {
 }
 ```
 
-If you obtain the result by comparing two Rust values, as in this example, you
-can take a shortcut using `CompareOp::matches`:
+If you obtain the result by comparing two Rust values, as in this example, you can take a shortcut using `CompareOp::matches`:
 
 ```rust,no_run
 use pyo3::class::basic::CompareOp;
@@ -259,8 +256,7 @@ impl Number {
 }
 ```
 
-It checks that the `std::cmp::Ordering` obtained from Rust's `Ord` matches
-the given `CompareOp`.
+It checks that the `std::cmp::Ordering` obtained from Rust's `Ord` matches the given `CompareOp`.
 
 Alternatively, you can implement just equality using `__eq__`:
 

guide/src/class/protocols.md

@@ -233,8 +233,7 @@ impl Container {
 # });
 ```
 
-For more details on Python's iteration protocols, check out [the "Iterator Types" section of the library
-documentation](https://docs.python.org/library/stdtypes.html#iterator-types).
+For more details on Python's iteration protocols, check out [the "Iterator Types" section of the library documentation](https://docs.python.org/library/stdtypes.html#iterator-types).
 
 #### Returning a value from iteration
 
@@ -363,11 +362,9 @@ This will help libraries such as `numpy` recognise the class as a sequence, howe
 
 ### Numeric types
 
-Binary arithmetic operations (`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`,
-`pow()` and `**`, `<<`, `>>`, `&`, `^`, and `|`) and their reflected versions:
+Binary arithmetic operations (`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`, `pow()` and `**`, `<<`, `>>`, `&`, `^`, and `|`) and their reflected versions:
 
-(If the `object` is not of the type specified in the signature, the generated code
-will automatically `return NotImplemented`.)
+(If the `object` is not of the type specified in the signature, the generated code will automatically `return NotImplemented`.)
 
 - `__add__(<self>, object) -> object`
 - `__radd__(<self>, object) -> object`
@@ -398,8 +395,7 @@ will automatically `return NotImplemented`.)
 - `__pow__(<self>, object, object) -> object`
 - `__rpow__(<self>, object, object) -> object`
 
-In-place assignment operations (`+=`, `-=`, `*=`, `@=`, `/=`, `//=`, `%=`,
-`**=`, `<<=`, `>>=`, `&=`, `^=`, `|=`):
+In-place assignment operations (`+=`, `-=`, `*=`, `@=`, `/=`, `//=`, `%=`, `**=`, `<<=`, `>>=`, `&=`, `^=`, `|=`):
 
 - `__iadd__(<self>, object) -> ()`
 - `__isub__(<self>, object) -> ()`

guide/src/conversions/traits.md

@@ -20,9 +20,7 @@ let v: Vec<i32> = list.extract()?;
 # }
 ```
 
-This method is available for many Python object types, and can produce a wide
-variety of Rust types, which you can check out in the implementor list of
-[`FromPyObject`].
+This method is available for many Python object types, and can produce a wide variety of Rust types, which you can check out in the implementor list of [`FromPyObject`].
 
 [`FromPyObject`] is also implemented for your own Rust types wrapped as Python objects (see [the chapter about classes](../class.md)).
 There, in order to both be able to operate on mutable references *and* satisfy Rust's rules of non-aliasing mutable references, you have to extract the PyO3 reference wrappers [`PyRef`] and [`PyRefMut`].
@@ -36,8 +34,7 @@ Derivation for empty enums, enum variants and structs is not supported.
 
 ### Deriving [`FromPyObject`] for structs
 
-The derivation generates code that will attempt to access the attribute  `my_string` on
-the Python object, i.e. `obj.getattr("my_string")`, and call `extract()` on the attribute.
+The derivation generates code that will attempt to access the attribute  `my_string` on the Python object, i.e. `obj.getattr("my_string")`, and call `extract()` on the attribute.
 
 ```rust
 use pyo3::prelude::*;
@@ -447,8 +444,7 @@ enum RustyEnum {
 # }
 ```
 
-If the input is neither a string nor an integer, the error message will be:
-`"'<INPUT_TYPE>' cannot be cast as 'str | int'"`.
+If the input is neither a string nor an integer, the error message will be: `"'<INPUT_TYPE>' cannot be cast as 'str | int'"`.
 
 ### `#[derive(FromPyObject)]` Container Attributes
 
@@ -560,16 +556,14 @@ All types in PyO3 implement this trait, as does a `#[pyclass]` which doesn't use
 This trait defines a single method, `into_pyobject()`, which returns a [`Result`] with `Ok` and `Err` types depending on the input value.
 For convenience, there is a companion [`IntoPyObjectExt`] trait which adds methods such as `into_py_any()` which converts the `Ok` and `Err` types to commonly used types (in the case of `into_py_any()`, `Py<PyAny>` and `PyErr` respectively).
 
-Occasionally you may choose to implement this for custom types which are mapped to Python types
-*without* having a unique python type.
+Occasionally you may choose to implement this for custom types which are mapped to Python types *without* having a unique python type.
 
 ### derive macro
 
 `IntoPyObject` can be implemented using our derive macro.
 Both `struct`s and `enum`s are supported.
 
-`struct`s will turn into a `PyDict` using the field names as keys, tuple `struct`s will turn convert
-into `PyTuple` with the fields in declaration order.
+`struct`s will turn into a `PyDict` using the field names as keys, tuple `struct`s will turn convert into `PyTuple` with the fields in declaration order.
 
 ```rust,no_run
 # #![allow(dead_code)]
@@ -591,8 +585,7 @@ struct Struct {
 struct Tuple<'a, K: Hash + Eq, V>(&'a str, HashMap<K, V>);
 ```
 
-For structs with a single field (newtype pattern) the `#[pyo3(transparent)]` option can be used to
-forward the implementation to the inner type.
+For structs with a single field (newtype pattern) the `#[pyo3(transparent)]` option can be used to forward the implementation to the inner type.
 
 ```rust,no_run
 # #![allow(dead_code)]
@@ -660,8 +653,7 @@ All the same rules from above apply as well.
 
 ### manual implementation
 
-If the derive macro is not suitable for your use case, `IntoPyObject` can be implemented manually as
-demonstrated below.
+If the derive macro is not suitable for your use case, `IntoPyObject` can be implemented manually as demonstrated below.
 
 ```rust,no_run
 # use pyo3::prelude::*;

guide/src/debugging.md

@@ -358,9 +358,7 @@ Automated ways to discover thread safety issues can often be more fruitful than
 [ThreadSanitizer](https://clang.llvm.org/docs/ThreadSanitizer.html) is a thread safety checking runtime that can be used to detect data races triggered by thread safety bugs or incorrect use of thread-unsafe data structures.
 While it can only detect data races triggered by code at runtime, if it does detect something the reports often point to exactly where the problem is happening.
 
-To use `ThreadSanitizer` with a library that depends on PyO3, you will need to
-install a nightly Rust toolchain, along with the `rust-src` component, since you
-will need to compile the Rust standard library:
+To use `ThreadSanitizer` with a library that depends on PyO3, you will need to install a nightly Rust toolchain, along with the `rust-src` component, since you will need to compile the Rust standard library:
 
 ```bash
 rustup install nightly
@@ -371,13 +369,9 @@ rustup component add rust-src
 You will also need a version of CPython compiled using LLVM/Clang with the same major version of LLVM as is currently used to compile nightly Rust.
 As of March 2025, Rust nightly uses LLVM 20.
 
-The [cpython_sanity docker images](https://github.com/nascheme/cpython_sanity)
-contain a development environment with a pre-compiled version of CPython 3.13 or
-3.14 as well as optionally NumPy and SciPy, all compiled using LLVM 20 and
-ThreadSanitizer.
+The [cpython_sanity docker images](https://github.com/nascheme/cpython_sanity) contain a development environment with a pre-compiled version of CPython 3.13 or 3.14 as well as optionally NumPy and SciPy, all compiled using LLVM 20 and ThreadSanitizer.
 
-After activating a nightly Rust toolchain, you can build your project using
-`ThreadSanitizer` with the following command:
+After activating a nightly Rust toolchain, you can build your project using `ThreadSanitizer` with the following command:
 
 ```bash
 RUSTFLAGS="-Zsanitizer=thread" maturin develop -Zbuild-std --target x86_64-unknown-linux-gnu

guide/src/ecosystem/logging.md

@@ -1,7 +1,6 @@
 # Logging
 
-It is desirable if both the Python and Rust parts of the application end up
-logging using the same configuration into the same place.
+It is desirable if both the Python and Rust parts of the application end up logging using the same configuration into the same place.
 
 This section of the guide briefly discusses how to connect the two languages' logging ecosystems together.
 The recommended way for Python extension modules is to configure Rust's logger to send log messages to Python using the `pyo3-log` crate.