docs: fix 'into' grammar

README.md

@@ -199,7 +199,7 @@ In addition to serving your apps locally, you can serve apps with [Textual Web](
 
 Textual Web's firewall-busting technology can serve an unlimited number of applications.
 
-Since Textual apps have low system requirements, you can install them anywhere Python also runs. Turning any device in to a connected device.
+Since Textual apps have low system requirements, you can install them anywhere Python also runs. Turning any device into a connected device.
 No desktop required!
 
 

docs/examples/guide/widgets/checker04.py

@@ -52,7 +52,7 @@ def get_square_region(square_offset: Offset) -> Region:
             """Get region relative to widget from square coordinate."""
             x, y = square_offset
             region = Region(x * 8, y * 4, 8, 4)
-            # Move the region in to the widgets frame of reference
+            # Move the region into the widgets frame of reference
             region = region.translate(-self.scroll_offset)
             return region
 

docs/guide/app.md

@@ -1,6 +1,6 @@
 # App Basics
 
-In this chapter we will cover how to use Textual's App class to create an application. Just enough to get you up to speed. We will go in to more detail in the following chapters.
+In this chapter we will cover how to use Textual's App class to create an application. Just enough to get you up to speed. We will go into more detail in the following chapters.
 
 ## The App class
 
@@ -30,7 +30,7 @@ If we run this app with `python simple02.py` you will see a blank terminal, some
 ```{.textual path="docs/examples/app/simple02.py"}
 ```
 
-When you call [App.run()][textual.app.App.run] Textual puts the terminal in to a special state called *application mode*. When in application mode the terminal will no longer echo what you type. Textual will take over responding to user input (keyboard and mouse) and will update the visible portion of the terminal (i.e. the *screen*).
+When you call [App.run()][textual.app.App.run] Textual puts the terminal into a special state called *application mode*. When in application mode the terminal will no longer echo what you type. Textual will take over responding to user input (keyboard and mouse) and will update the visible portion of the terminal (i.e. the *screen*).
 
 If you hit ++ctrl+q++ Textual will exit application mode and return you to the command prompt. Any content you had in the terminal prior to application mode will be restored.
 
@@ -42,7 +42,7 @@ If you hit ++ctrl+q++ Textual will exit application mode and return you to the c
 
 !!! tip "Added in version 0.55.0"
 
-You can also run apps in _inline_ mode, which will cause the app to appear beneath the prompt (and won't go in to application mode).
+You can also run apps in _inline_ mode, which will cause the app to appear beneath the prompt (and won't go into application mode).
 Inline apps are useful for tools that integrate closely with the typical workflow of a terminal.
 
 To run an app in inline mode set the `inline` parameter to `True` when you call [App.run()][textual.app.App.run]. See [Style Inline Apps](../how-to/style-inline-apps.md) for how to apply additional styles to inline apps.

docs/guide/devtools.md

@@ -62,7 +62,7 @@ textual run -c textual colors
 ## Serve
 
 The devtools can also serve your application in a browser.
-Effectively turning your terminal app in to a web application!
+Effectively turning your terminal app into a web application!
 
 The `serve` sub-command is similar to `run`. Here's how you can serve an app launched from a Python file:
 
@@ -144,7 +144,7 @@ textual console -v
 
 ### Decreasing verbosity
 
-Log messages are classififed in to groups, and the `-x` flag can be used to **exclude** all message from a group. The groups are: `EVENT`, `DEBUG`, `INFO`, `WARNING`, `ERROR`, `PRINT`, `SYSTEM`, `LOGGING` and `WORKER`. The group a message belongs to is printed after its timestamp.
+Log messages are classififed into groups, and the `-x` flag can be used to **exclude** all message from a group. The groups are: `EVENT`, `DEBUG`, `INFO`, `WARNING`, `ERROR`, `PRINT`, `SYSTEM`, `LOGGING` and `WORKER`. The group a message belongs to is printed after its timestamp.
 
 Multiple groups may be excluded, for example to exclude everything except warning, errors, and `print` statements:
 

docs/guide/events.md

@@ -20,7 +20,7 @@ This processing of messages is done within an asyncio Task which is started when
 
     The FastAPI docs have an [excellent introduction](https://fastapi.tiangolo.com/async/) to Python async programming.
 
-By way of an example, let's consider what happens if you were to type "Text" in to a `Input` widget. When you hit the ++t++ key, Textual creates a [key][textual.events.Key] event and sends it to the widget's message queue. Ditto for ++e++, ++x++, and ++t++.
+By way of an example, let's consider what happens if you were to type "Text" into a `Input` widget. When you hit the ++t++ key, Textual creates a [key][textual.events.Key] event and sends it to the widget's message queue. Ditto for ++e++, ++x++, and ++t++.
 
 The widget's task will pick the first message from the queue (a key event for the ++t++ key) and call the `on_key` method with the event as the first argument. In other words it will call `Input.on_key(event)`, which updates the display to show the new letter.
 
@@ -334,4 +334,4 @@ Let's look at an example which looks up word definitions from an [api](https://d
     ```{.textual path="docs/examples/events/dictionary.py"}
     ```
 
-Note the highlighted line in the above code which calls `asyncio.create_task` to run a coroutine in the background. Without this you would find typing in to the text box to be unresponsive.
+Note the highlighted line in the above code which calls `asyncio.create_task` to run a coroutine in the background. Without this you would find typing into the text box to be unresponsive.

docs/guide/input.md

@@ -105,7 +105,7 @@ The following example shows how focus works in practice.
     ```{.textual path="docs/examples/guide/input/key03.py", press="H,e,l,l,o,tab,W,o,r,l,d,!"}
     ```
 
-The app splits the screen in to quarters, with a `RichLog` widget in each quarter. If you click any of the text logs, you should see that it is highlighted to show that the widget has focus. Key events will be sent to the focused widget only.
+The app splits the screen into quarters, with a `RichLog` widget in each quarter. If you click any of the text logs, you should see that it is highlighted to show that the widget has focus. Key events will be sent to the focused widget only.
 
 !!! tip
 
@@ -255,4 +255,4 @@ Most mice have a scroll wheel which you can use to scroll the window underneath
 
 !!! information
 
-    Terminal emulators will typically convert trackpad gestures in to scroll events.
+    Terminal emulators will typically convert trackpad gestures into scroll events.

docs/guide/reactivity.md

@@ -134,7 +134,7 @@ The following example modifies "refresh01.py" so that the greeting has an automa
     ```{.textual path="docs/examples/guide/reactivity/refresh02.py" press="n,a,m,e"}
     ```
 
-If you type in to the input now, the greeting will expand to fit the content. If you were to set `layout=False` on the reactive attribute, you should see that the box remains the same size when you type.
+If you type into the input now, the greeting will expand to fit the content. If you were to set `layout=False` on the reactive attribute, you should see that the box remains the same size when you type.
 
 ## Validation
 
@@ -171,7 +171,7 @@ Watch method names begin with `watch_` followed by the name of the attribute, an
 If the method accepts a single argument, it will be called with the new assigned value.
 If the method accepts *two* positional arguments, it will be called with both the *old* value and the *new* value.
 
-The following app will display any color you type in to the input. Try it with a valid color in Textual CSS. For example `"darkorchid"` or `"#52de44"`.
+The following app will display any color you type into the input. Try it with a valid color in Textual CSS. For example `"darkorchid"` or `"#52de44"`.
 
 === "watch01.py"
 
@@ -311,15 +311,15 @@ Compute methods are the final superpower offered by the `reactive` descriptor. T
 
 You could be forgiven in thinking this sounds a lot like Python's property decorator. The difference is that Textual will cache the value of compute methods, and update them when any other reactive attribute changes.
 
-The following example uses a computed attribute. It displays three inputs for each color component (red, green, and blue). If you enter numbers in to these inputs, the background color of another widget changes.
+The following example uses a computed attribute. It displays three inputs for each color component (red, green, and blue). If you enter numbers into these inputs, the background color of another widget changes.
 
 === "computed01.py"
 
     ```python hl_lines="25-26 28-29"
     --8<-- "docs/examples/guide/reactivity/computed01.py"
     ```
 
-    1. Combines color components in to a Color object.
+    1. Combines color components into a Color object.
     2. The watch method is called when the _result_ of `compute_color` changes.
 
 === "computed01.tcss"

docs/guide/testing.md

@@ -91,7 +91,7 @@ Knowing which test has failed will help you quickly track down where your code w
 ## Simulating key presses
 
 We've seen how the [`press`][textual.pilot.Pilot] method simulates keys.
-You can also supply multiple keys to simulate the user typing in to the app.
+You can also supply multiple keys to simulate the user typing into the app.
 Here's an example of simulating the user typing the word "hello".
 
 ```python

docs/guide/widgets.md

@@ -407,7 +407,7 @@ Textual will call this method as required to get content for every row of charac
 --8<-- "docs/images/render_line.excalidraw.svg"
 </div>
 
-Let's look at an example before we go in to the details. The following Textual app implements a widget with the line API that renders a checkerboard pattern. This might form the basis of a chess / checkers game. Here's the code:
+Let's look at an example before we go into the details. The following Textual app implements a widget with the line API that renders a checkerboard pattern. This might form the basis of a chess / checkers game. Here's the code:
 
 === "checker01.py"
 

docs/tutorial.md

@@ -157,14 +157,14 @@ Here's what the above app defines:
 --8<-- "docs/examples/tutorial/stopwatch01.py"
 ```
 
-The final three lines create an instance of the app and calls the [run()][textual.app.App.run] method which puts your terminal in to *application mode* and runs the app until you exit with ++ctrl+q++. This happens within a `__name__ == "__main__"` block so we could run the app with `python stopwatch01.py` or import it as part of a larger project.
+The final three lines create an instance of the app and calls the [run()][textual.app.App.run] method which puts your terminal into *application mode* and runs the app until you exit with ++ctrl+q++. This happens within a `__name__ == "__main__"` block so we could run the app with `python stopwatch01.py` or import it as part of a larger project.
 
 ## Designing a UI with widgets
 
 Textual has a large number of [builtin widgets](./widget_gallery.md).
 For our app we will need new widgets, which we can create by extending and combining the builtin widgets.
 
-Before we dive in to building widgets, let's first sketch a design for the app &mdash; so we know what we're aiming for.
+Before we dive into building widgets, let's first sketch a design for the app &mdash; so we know what we're aiming for.
 
 
 <div class="excalidraw">

docs/widgets/select.md

@@ -9,7 +9,7 @@ A Select widget is a compact control to allow the user to select between a numbe
 - [ ] Container
 
 
-The options in a select control may be passed in to the constructor or set later with [set_options][textual.widgets.Select.set_options].
+The options in a select control may be passed into the constructor or set later with [set_options][textual.widgets.Select.set_options].
 Options should be given as a sequence of tuples consisting of two values: the first is the string (or [Rich Renderable](https://rich.readthedocs.io/en/latest/protocol.html)) to display in the control and list of options, the second is the value of option.
 
 The value of the currently selected option is stored in the `value` attribute of the widget, and the `value` attribute of the [Changed][textual.widgets.Select.Changed] message.

examples/dictionary.py

@@ -48,7 +48,7 @@ async def lookup_word(self, word: str) -> None:
             self.query_one("#results", Markdown).update(markdown)
 
     def make_word_markdown(self, results: object) -> str:
-        """Convert the results in to markdown."""
+        """Convert the results into markdown."""
         lines = []
         if isinstance(results, dict):
             lines.append(f"# {results['title']}")

examples/example.md

@@ -12,7 +12,7 @@ This is H3 Content
 
 #### This is H4
 
-Header level 4 content. Drilling down in to finer headings.
+Header level 4 content. Drilling down into finer headings.
 
 ##### This is H5
 
@@ -85,7 +85,7 @@ In the future I think we could add controls to export the code, copy to the clip
 ```python
 @lru_cache(maxsize=1024)
 def split(self, cut_x: int, cut_y: int) -> tuple[Region, Region, Region, Region]:
-    """Split a region in to 4 from given x and y offsets (cuts).
+    """Split a region into 4 from given x and y offsets (cuts).
 
     ```
                 cut_x ↓

src/textual/_arrange.py

@@ -61,7 +61,7 @@ def arrange(
     layers = _build_layers(display_widgets)
 
     for widgets in layers.values():
-        # Partition widgets in to split widgets and non-split widgets
+        # Partition widgets into split widgets and non-split widgets
         non_split_widgets, split_widgets = partition(get_split, widgets)
         if split_widgets:
             _split_placements, dock_region = _arrange_split_widgets(

src/textual/_binary_encode.py

@@ -26,7 +26,7 @@ class DecodeError(Exception):
 
 
 def dump(data: object) -> bytes:
-    """Encodes a data structure in to bytes.
+    """Encodes a data structure into bytes.
 
     Args:
         data: Data structure

src/textual/_compositor.py

@@ -1,6 +1,6 @@
 """
 
-The compositor handles combining widgets in to a single screen (i.e. compositing).
+The compositor handles combining widgets into a single screen (i.e. compositing).
 
 It also stores the results of that process, so that Textual knows the widgets on
 the screen and their locations. The compositor uses this information to answer

src/textual/_partition.py

@@ -8,7 +8,7 @@
 def partition(
     predicate: Callable[[T], object], iterable: Iterable[T]
 ) -> tuple[list[T], list[T]]:
-    """Partition a sequence in to two list from a given predicate. The first list will contain
+    """Partition a sequence into two list from a given predicate. The first list will contain
     the values where the predicate is False, the second list will contain the remaining values.
 
     Args:

src/textual/app.py

@@ -2845,7 +2845,7 @@ def set_focus(self, widget: Widget | None, scroll_visible: bool = True) -> None:
 
         Args:
             widget: Widget to focus.
-            scroll_visible: Scroll widget in to view.
+            scroll_visible: Scroll widget into view.
         """
         self.screen.set_focus(widget, scroll_visible)
 

src/textual/binding.py

@@ -85,7 +85,7 @@ class Binding:
     """Make this binding a system binding, which removes it from the key panel."""
 
     def parse_key(self) -> tuple[list[str], str]:
-        """Parse a key in to a list of modifiers, and the actual key.
+        """Parse a key into a list of modifiers, and the actual key.
 
         Returns:
             A tuple of (MODIFIER LIST, KEY).

src/textual/color.py

@@ -110,11 +110,11 @@ class Lab(NamedTuple):
     re.VERBOSE,
 )
 
-# Fast way to split a string of 6 characters in to 3 pairs of 2 characters
+# Fast way to split a string of 6 characters into 3 pairs of 2 characters
 _split_pairs3: Callable[[str], tuple[str, str, str]] = itemgetter(
     slice(0, 2), slice(2, 4), slice(4, 6)
 )
-# Fast way to split a string of 8 characters in to 4 pairs of 2 characters
+# Fast way to split a string of 8 characters into 4 pairs of 2 characters
 _split_pairs4: Callable[[str], tuple[str, str, str, str]] = itemgetter(
     slice(0, 2), slice(2, 4), slice(4, 6), slice(6, 8)
 )

src/textual/content.py

@@ -475,7 +475,7 @@ def get_style_at_offset(self, offset: int) -> Style:
         """Get the style of a character at give offset.
 
         Args:
-            offset (int): Offset in to text (negative indexing supported)
+            offset (int): Offset into text (negative indexing supported)
 
         Returns:
             Style: A Style instance.
@@ -828,7 +828,7 @@ def split(
         include_separator: bool = False,
         allow_blank: bool = False,
     ) -> list[Content]:
-        """Split rich text in to lines, preserving styles.
+        """Split rich text into lines, preserving styles.
 
         Args:
             separator (str, optional): String to split on. Defaults to "\\\\n".

src/textual/css/_style_properties.py

@@ -1172,7 +1172,7 @@ def __set__(self, obj: StylesBase, value: float | str | None) -> None:
 
 
 class AlignProperty:
-    """Combines the horizontal and vertical alignment properties in to a single property."""
+    """Combines the horizontal and vertical alignment properties into a single property."""
 
     def __set_name__(self, owner: StylesBase, name: str) -> None:
         self.horizontal = f"{name}_horizontal"

src/textual/css/scalar.py

@@ -242,7 +242,7 @@ def from_number(cls, value: float) -> Scalar:
     @classmethod
     @lru_cache(maxsize=1024)
     def parse(cls, token: str, percent_unit: Unit = Unit.WIDTH) -> Scalar:
-        """Parse a string in to a Scalar
+        """Parse a string into a Scalar
 
         Args:
             token: A string containing a scalar, e.g. "3.14fr"
@@ -267,7 +267,7 @@ def parse(cls, token: str, percent_unit: Unit = Unit.WIDTH) -> Scalar:
     def resolve(
         self, size: Size, viewport: Size, fraction_unit: Fraction | None = None
     ) -> Fraction:
-        """Resolve scalar with units in to a dimensions.
+        """Resolve scalar with units into a dimensions.
 
         Args:
             size: Size of the container.
@@ -348,7 +348,7 @@ def __rich_repr__(self) -> rich.repr.Result:
         yield None, str(self.y)
 
     def resolve(self, size: Size, viewport: Size) -> Offset:
-        """Resolve the offset in to cells.
+        """Resolve the offset into cells.
 
         Args:
             size: Size of container.

src/textual/css/styles.py

@@ -660,7 +660,7 @@ def merge(self, other: StylesBase) -> None:
         """
 
     def merge_rules(self, rules: RulesMap) -> None:
-        """Merge rules in to Styles.
+        """Merge rules into Styles.
 
         Args:
             rules: A mapping of rules.

src/textual/demo/widgets.py

@@ -255,7 +255,7 @@ class ListViews(containers.VerticalGroup):
     LISTS_MD = """\
 ## List Views and Option Lists
 
-A List View turns any widget in to a user-navigable and selectable list.
+A List View turns any widget into a user-navigable and selectable list.
 An Option List for a field to present a list of strings to select from.
 
     """

src/textual/drivers/linux_driver.py

@@ -291,7 +291,7 @@ def on_terminal_resize(signum, stack) -> None:
     def _request_terminal_sync_mode_support(self) -> None:
         """Writes an escape sequence to query the terminal support for the sync protocol."""
         # Terminals should ignore this sequence if not supported.
-        # Apple terminal doesn't, and writes a single 'p' in to the terminal,
+        # Apple terminal doesn't, and writes a single 'p' into the terminal,
         # so we will make a special case for Apple terminal (which doesn't support sync anyway).
         if not self.input_tty:
             return

src/textual/drivers/linux_inline_driver.py

@@ -246,7 +246,7 @@ def on_terminal_resize(signum, stack) -> None:
     def _request_terminal_sync_mode_support(self) -> None:
         """Writes an escape sequence to query the terminal support for the sync protocol."""
         # Terminals should ignore this sequence if not supported.
-        # Apple terminal doesn't, and writes a single 'p' in to the terminal,
+        # Apple terminal doesn't, and writes a single 'p' into the terminal,
         # so we will make a special case for Apple terminal (which doesn't support sync anyway).
         if os.environ.get("TERM_PROGRAM", "") != "Apple_Terminal":
             self.write("\033[?2026$p")