chore: enable pep 563/585

.flake8

@@ -8,7 +8,7 @@ inline-quotes = double
 # Allow omission of a return type hint for __init__ if at least one argument is annotated
 # Allow omission of a return type hint for __init__ if at least one argument is annotated
 # used by flake8-annotations
 # used by flake8-annotations
 mypy-init-return = true
 mypy-init-return = true
-enable-extensions = TC, TC2
+enable-extensions = TC, TC1
 type-checking-exempt-modules = typing, typing-extensions
 type-checking-exempt-modules = typing, typing-extensions
 eradicate-whitelist-extend = ^-.*;
 eradicate-whitelist-extend = ^-.*;
 extend-ignore =
 extend-ignore =

.pre-commit-config.yaml

@@ -50,7 +50,7 @@ repos:
     hooks:
     hooks:
       - id: pyupgrade
       - id: pyupgrade
         args: [--py37-plus]
         args: [--py37-plus]
-        exclude: '^(install|get)-poetry.py$'
+        exclude: ^(install|get)-poetry.py$
 
 
   - repo: https://github.com/pycqa/isort
   - repo: https://github.com/pycqa/isort
     rev: 5.10.1
     rev: 5.10.1
@@ -58,6 +58,8 @@ repos:
       - id: isort
       - id: isort
         name: "isort (python)"
         name: "isort (python)"
         types: [python]
         types: [python]
+        args: [--add-import, from __future__ import annotations]
+        exclude: ^(install|get)-poetry.py$
       - id: isort
       - id: isort
         name: "isort (pyi)"
         name: "isort (pyi)"
         types: [pyi]
         types: [pyi]

src/poetry/__init__.py

+from __future__ import annotations
+
+
 __path__ = __import__("pkgutil").extend_path(__path__, __name__)
 __path__ = __import__("pkgutil").extend_path(__path__, __name__)

src/poetry/__main__.py

+from __future__ import annotations
+
 import sys
 import sys
 
 
 
 

src/poetry/__version__.py

+from __future__ import annotations
+
+
 __version__ = "1.2.0a2"
 __version__ = "1.2.0a2"

src/poetry/config/config.py

+from __future__ import annotations
+
 import os
 import os
 import re
 import re
 
 
@@ -6,8 +8,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
 from typing import Callable
 from typing import Callable
-from typing import Dict
-from typing import Optional
 
 
 from poetry.config.dict_config_source import DictConfigSource
 from poetry.config.dict_config_source import DictConfigSource
 from poetry.locations import CACHE_DIR
 from poetry.locations import CACHE_DIR
@@ -31,7 +31,7 @@ def int_normalizer(val: str) -> int:
 
 
 class Config:
 class Config:
 
 
-    default_config: Dict[str, Any] = {
+    default_config: dict[str, Any] = {
         "cache-dir": str(CACHE_DIR),
         "cache-dir": str(CACHE_DIR),
         "virtualenvs": {
         "virtualenvs": {
             "create": True,
             "create": True,
@@ -45,43 +45,43 @@ class Config:
     }
     }
 
 
     def __init__(
     def __init__(
-        self, use_environment: bool = True, base_dir: Optional[Path] = None
+        self, use_environment: bool = True, base_dir: Path | None = None
     ) -> None:
     ) -> None:
         self._config = deepcopy(self.default_config)
         self._config = deepcopy(self.default_config)
         self._use_environment = use_environment
         self._use_environment = use_environment
         self._base_dir = base_dir
         self._base_dir = base_dir
-        self._config_source: "ConfigSource" = DictConfigSource()
-        self._auth_config_source: "ConfigSource" = DictConfigSource()
+        self._config_source: ConfigSource = DictConfigSource()
+        self._auth_config_source: ConfigSource = DictConfigSource()
 
 
     @property
     @property
-    def config(self) -> Dict:
+    def config(self) -> dict:
         return self._config
         return self._config
 
 
     @property
     @property
-    def config_source(self) -> "ConfigSource":
+    def config_source(self) -> ConfigSource:
         return self._config_source
         return self._config_source
 
 
     @property
     @property
-    def auth_config_source(self) -> "ConfigSource":
+    def auth_config_source(self) -> ConfigSource:
         return self._auth_config_source
         return self._auth_config_source
 
 
-    def set_config_source(self, config_source: "ConfigSource") -> "Config":
+    def set_config_source(self, config_source: ConfigSource) -> Config:
         self._config_source = config_source
         self._config_source = config_source
 
 
         return self
         return self
 
 
-    def set_auth_config_source(self, config_source: "ConfigSource") -> "Config":
+    def set_auth_config_source(self, config_source: ConfigSource) -> Config:
         self._auth_config_source = config_source
         self._auth_config_source = config_source
 
 
         return self
         return self
 
 
-    def merge(self, config: Dict[str, Any]) -> None:
+    def merge(self, config: dict[str, Any]) -> None:
         from poetry.utils.helpers import merge_dicts
         from poetry.utils.helpers import merge_dicts
 
 
         merge_dicts(self._config, config)
         merge_dicts(self._config, config)
 
 
-    def all(self) -> Dict[str, Any]:
-        def _all(config: Dict, parent_key: str = "") -> Dict:
+    def all(self) -> dict[str, Any]:
+        def _all(config: dict, parent_key: str = "") -> dict:
             all_ = {}
             all_ = {}
 
 
             for key in config:
             for key in config:
@@ -100,7 +100,7 @@ class Config:
 
 
         return _all(self.config)
         return _all(self.config)
 
 
-    def raw(self) -> Dict[str, Any]:
+    def raw(self) -> dict[str, Any]:
         return self._config
         return self._config
 
 
     def get(self, setting_name: str, default: Any = None) -> Any:
     def get(self, setting_name: str, default: Any = None) -> Any:

src/poetry/config/config_source.py

+from __future__ import annotations
+
 from typing import Any
 from typing import Any
 
 
 
 

src/poetry/config/dict_config_source.py

+from __future__ import annotations
+
 from typing import Any
 from typing import Any
-from typing import Dict
 
 
 from poetry.config.config_source import ConfigSource
 from poetry.config.config_source import ConfigSource
 
 
 
 
 class DictConfigSource(ConfigSource):
 class DictConfigSource(ConfigSource):
     def __init__(self) -> None:
     def __init__(self) -> None:
-        self._config: Dict[str, Any] = {}
+        self._config: dict[str, Any] = {}
 
 
     @property
     @property
-    def config(self) -> Dict[str, Any]:
+    def config(self) -> dict[str, Any]:
         return self._config
         return self._config
 
 
     def add_property(self, key: str, value: Any) -> None:
     def add_property(self, key: str, value: Any) -> None:

src/poetry/config/file_config_source.py

+from __future__ import annotations
+
 from contextlib import contextmanager
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 
 
 
 
 class FileConfigSource(ConfigSource):
 class FileConfigSource(ConfigSource):
-    def __init__(self, file: "TOMLFile", auth_config: bool = False) -> None:
+    def __init__(self, file: TOMLFile, auth_config: bool = False) -> None:
         self._file = file
         self._file = file
         self._auth_config = auth_config
         self._auth_config = auth_config
 
 
@@ -24,7 +26,7 @@ class FileConfigSource(ConfigSource):
         return str(self._file.path)
         return str(self._file.path)
 
 
     @property
     @property
-    def file(self) -> "TOMLFile":
+    def file(self) -> TOMLFile:
         return self._file
         return self._file
 
 
     def add_property(self, key: str, value: Any) -> None:
     def add_property(self, key: str, value: Any) -> None:
@@ -58,7 +60,7 @@ class FileConfigSource(ConfigSource):
                 current_config = current_config[key]
                 current_config = current_config[key]
 
 
     @contextmanager
     @contextmanager
-    def secure(self) -> Iterator["TOMLDocument"]:
+    def secure(self) -> Iterator[TOMLDocument]:
         if self.file.exists():
         if self.file.exists():
             initial_config = self.file.read()
             initial_config = self.file.read()
             config = self.file.read()
             config = self.file.read()

src/poetry/config/source.py

-import dataclasses
+from __future__ import annotations
 
 
-from typing import Dict
-from typing import Union
+import dataclasses
 
 
 
 
 @dataclasses.dataclass(order=True, eq=True)
 @dataclasses.dataclass(order=True, eq=True)
@@ -11,5 +10,5 @@ class Source:
     default: bool = dataclasses.field(default=False)
     default: bool = dataclasses.field(default=False)
     secondary: bool = dataclasses.field(default=False)
     secondary: bool = dataclasses.field(default=False)
 
 
-    def to_dict(self) -> Dict[str, Union[str, bool]]:
+    def to_dict(self) -> dict[str, str | bool]:
         return dataclasses.asdict(self)
         return dataclasses.asdict(self)

src/poetry/console/application.py

+from __future__ import annotations
+
 import logging
 import logging
 import re
 import re
 
 
@@ -6,8 +8,6 @@ from importlib import import_module
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
 from typing import Callable
 from typing import Callable
-from typing import Optional
-from typing import Type
 from typing import cast
 from typing import cast
 
 
 from cleo.application import Application as BaseApplication
 from cleo.application import Application as BaseApplication
@@ -37,7 +37,7 @@ if TYPE_CHECKING:
 
 
 
 
 def load_command(name: str) -> Callable:
 def load_command(name: str) -> Callable:
-    def _load() -> Type[Command]:
+    def _load() -> type[Command]:
         words = name.split(" ")
         words = name.split(" ")
         module = import_module("poetry.console.commands." + ".".join(words))
         module = import_module("poetry.console.commands." + ".".join(words))
         command_class = getattr(module, "".join(c.title() for c in words) + "Command")
         command_class = getattr(module, "".join(c.title() for c in words) + "Command")
@@ -94,7 +94,7 @@ class Application(BaseApplication):
         super().__init__("poetry", __version__)
         super().__init__("poetry", __version__)
 
 
         self._poetry = None
         self._poetry = None
-        self._io: Optional["IO"] = None
+        self._io: IO | None = None
         self._disable_plugins = False
         self._disable_plugins = False
         self._plugins_loaded = False
         self._plugins_loaded = False
 
 
@@ -108,7 +108,7 @@ class Application(BaseApplication):
         self.set_command_loader(command_loader)
         self.set_command_loader(command_loader)
 
 
     @property
     @property
-    def poetry(self) -> "Poetry":
+    def poetry(self) -> Poetry:
         from pathlib import Path
         from pathlib import Path
 
 
         from poetry.factory import Factory
         from poetry.factory import Factory
@@ -131,10 +131,10 @@ class Application(BaseApplication):
 
 
     def create_io(
     def create_io(
         self,
         self,
-        input: Optional["Input"] = None,
-        output: Optional["Output"] = None,
-        error_output: Optional["Output"] = None,
-    ) -> "IO":
+        input: Input | None = None,
+        output: Output | None = None,
+        error_output: Output | None = None,
+    ) -> IO:
         io = super().create_io(input, output, error_output)
         io = super().create_io(input, output, error_output)
 
 
         # Set our own CLI styles
         # Set our own CLI styles
@@ -159,21 +159,21 @@ class Application(BaseApplication):
 
 
         return io
         return io
 
 
-    def render_error(self, error: Exception, io: "IO") -> None:
+    def render_error(self, error: Exception, io: IO) -> None:
         # We set the solution provider repository here to load providers
         # We set the solution provider repository here to load providers
         # only when an error occurs
         # only when an error occurs
         self.set_solution_provider_repository(self._get_solution_provider_repository())
         self.set_solution_provider_repository(self._get_solution_provider_repository())
 
 
         super().render_error(error, io)
         super().render_error(error, io)
 
 
-    def _run(self, io: "IO") -> int:
+    def _run(self, io: IO) -> int:
         self._disable_plugins = io.input.parameter_option("--no-plugins")
         self._disable_plugins = io.input.parameter_option("--no-plugins")
 
 
         self._load_plugins(io)
         self._load_plugins(io)
 
 
         return super()._run(io)
         return super()._run(io)
 
 
-    def _configure_io(self, io: "IO") -> None:
+    def _configure_io(self, io: IO) -> None:
         # We need to check if the command being run
         # We need to check if the command being run
         # is the "run" command.
         # is the "run" command.
         definition = self.definition
         definition = self.definition
@@ -210,7 +210,7 @@ class Application(BaseApplication):
         return super()._configure_io(io)
         return super()._configure_io(io)
 
 
     def register_command_loggers(
     def register_command_loggers(
-        self, event: "ConsoleCommandEvent", event_name: str, _: Any
+        self, event: ConsoleCommandEvent, event_name: str, _: Any
     ) -> None:
     ) -> None:
         from poetry.console.logging.io_formatter import IOFormatter
         from poetry.console.logging.io_formatter import IOFormatter
         from poetry.console.logging.io_handler import IOHandler
         from poetry.console.logging.io_handler import IOHandler
@@ -251,7 +251,7 @@ class Application(BaseApplication):
             logger.setLevel(level)
             logger.setLevel(level)
 
 
     def configure_env(
     def configure_env(
-        self, event: "ConsoleCommandEvent", event_name: str, _: Any
+        self, event: ConsoleCommandEvent, event_name: str, _: Any
     ) -> None:
     ) -> None:
         from poetry.console.commands.env_command import EnvCommand
         from poetry.console.commands.env_command import EnvCommand
 
 
@@ -276,11 +276,11 @@ class Application(BaseApplication):
         command.set_env(env)
         command.set_env(env)
 
 
     def configure_installer(
     def configure_installer(
-        self, event: "ConsoleCommandEvent", event_name: str, _: Any
+        self, event: ConsoleCommandEvent, event_name: str, _: Any
     ) -> None:
     ) -> None:
         from poetry.console.commands.installer_command import InstallerCommand
         from poetry.console.commands.installer_command import InstallerCommand
 
 
-        command: "InstallerCommand" = cast(InstallerCommand, event.command)
+        command: InstallerCommand = cast(InstallerCommand, event.command)
         if not isinstance(command, InstallerCommand):
         if not isinstance(command, InstallerCommand):
             return
             return
 
 
@@ -291,7 +291,7 @@ class Application(BaseApplication):
 
 
         self._configure_installer(command, event.io)
         self._configure_installer(command, event.io)
 
 
-    def _configure_installer(self, command: "InstallerCommand", io: "IO") -> None:
+    def _configure_installer(self, command: InstallerCommand, io: IO) -> None:
         from poetry.installation.installer import Installer
         from poetry.installation.installer import Installer
 
 
         poetry = command.poetry
         poetry = command.poetry
@@ -306,7 +306,7 @@ class Application(BaseApplication):
         installer.use_executor(poetry.config.get("experimental.new-installer", False))
         installer.use_executor(poetry.config.get("experimental.new-installer", False))
         command.set_installer(installer)
         command.set_installer(installer)
 
 
-    def _load_plugins(self, io: "IO") -> None:
+    def _load_plugins(self, io: IO) -> None:
         if self._plugins_loaded:
         if self._plugins_loaded:
             return
             return
 
 
@@ -322,7 +322,7 @@ class Application(BaseApplication):
         self._plugins_loaded = True
         self._plugins_loaded = True
 
 
     @property
     @property
-    def _default_definition(self) -> "Definition":
+    def _default_definition(self) -> Definition:
         from cleo.io.inputs.option import Option
         from cleo.io.inputs.option import Option
 
 
         definition = super()._default_definition
         definition = super()._default_definition
@@ -333,7 +333,7 @@ class Application(BaseApplication):
 
 
         return definition
         return definition
 
 
-    def _get_solution_provider_repository(self) -> "SolutionProviderRepository":
+    def _get_solution_provider_repository(self) -> SolutionProviderRepository:
         from crashtest.solution_providers.solution_provider_repository import (
         from crashtest.solution_providers.solution_provider_repository import (
             SolutionProviderRepository,
             SolutionProviderRepository,
         )
         )

src/poetry/console/command_loader.py

+from __future__ import annotations
+
 from typing import Callable
 from typing import Callable
 
 
 from cleo.exceptions import LogicException
 from cleo.exceptions import LogicException

src/poetry/console/commands/about.py

+from __future__ import annotations
+
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command
 
 
 
 

src/poetry/console/commands/add.py

+from __future__ import annotations
+
 import contextlib
 import contextlib
 
 
-from typing import Dict
-from typing import List
 from typing import cast
 from typing import cast
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
@@ -246,8 +246,8 @@ You can specify a package in the following forms:
         return status
         return status
 
 
     def get_existing_packages_from_input(
     def get_existing_packages_from_input(
-        self, packages: List[str], section: Dict
-    ) -> List[str]:
+        self, packages: list[str], section: dict
+    ) -> list[str]:
         existing_packages = []
         existing_packages = []
 
 
         for name in packages:
         for name in packages:
@@ -257,7 +257,7 @@ You can specify a package in the following forms:
 
 
         return existing_packages
         return existing_packages
 
 
-    def notify_about_existing_packages(self, existing_packages: List[str]) -> None:
+    def notify_about_existing_packages(self, existing_packages: list[str]) -> None:
         self.line(
         self.line(
             "The following packages are already present in the pyproject.toml and will"
             "The following packages are already present in the pyproject.toml and will"
             " be skipped:\n"
             " be skipped:\n"

src/poetry/console/commands/build.py

+from __future__ import annotations
+
 from cleo.helpers import option
 from cleo.helpers import option
 
 
 from poetry.console.commands.env_command import EnvCommand
 from poetry.console.commands.env_command import EnvCommand

src/poetry/console/commands/cache/clear.py

+from __future__ import annotations
+
 import os
 import os
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument

src/poetry/console/commands/cache/list.py

-import os
+from __future__ import annotations
 
 
-from typing import Optional
+import os
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command
 
 
@@ -10,7 +10,7 @@ class CacheListCommand(Command):
     name = "cache list"
     name = "cache list"
     description = "List Poetry's caches."
     description = "List Poetry's caches."
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         from poetry.locations import REPOSITORY_CACHE_DIR
         from poetry.locations import REPOSITORY_CACHE_DIR
 
 
         if os.path.exists(str(REPOSITORY_CACHE_DIR)):
         if os.path.exists(str(REPOSITORY_CACHE_DIR)):

src/poetry/console/commands/check.py

+from __future__ import annotations
+
 from pathlib import Path
 from pathlib import Path
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command

src/poetry/console/commands/command.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
-from typing import Optional
 
 
 from cleo.commands.command import Command as BaseCommand
 from cleo.commands.command import Command as BaseCommand
 
 
@@ -11,21 +11,21 @@ if TYPE_CHECKING:
 
 
 
 
 class Command(BaseCommand):
 class Command(BaseCommand):
-    loggers: List[str] = []
+    loggers: list[str] = []
 
 
-    _poetry: Optional["Poetry"] = None
+    _poetry: Poetry | None = None
 
 
     @property
     @property
-    def poetry(self) -> "Poetry":
+    def poetry(self) -> Poetry:
         if self._poetry is None:
         if self._poetry is None:
             return self.get_application().poetry
             return self.get_application().poetry
 
 
         return self._poetry
         return self._poetry
 
 
-    def set_poetry(self, poetry: "Poetry") -> None:
+    def set_poetry(self, poetry: Poetry) -> None:
         self._poetry = poetry
         self._poetry = poetry
 
 
-    def get_application(self) -> "Application":
+    def get_application(self) -> Application:
         return self.application
         return self.application
 
 
     def reset_poetry(self) -> None:
     def reset_poetry(self) -> None:

src/poetry/console/commands/config.py

+from __future__ import annotations
+
 import json
 import json
 import re
 import re
 
 
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
-from typing import Union
 from typing import cast
 from typing import cast
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
@@ -49,7 +46,7 @@ To remove a repository (repo is a short alias for repositories):
     LIST_PROHIBITED_SETTINGS = {"http-basic", "pypi-token"}
     LIST_PROHIBITED_SETTINGS = {"http-basic", "pypi-token"}
 
 
     @property
     @property
-    def unique_config_values(self) -> Dict[str, Tuple[Any, Any, Any]]:
+    def unique_config_values(self) -> dict[str, tuple[Any, Any, Any]]:
         from pathlib import Path
         from pathlib import Path
 
 
         from poetry.config.config import boolean_normalizer
         from poetry.config.config import boolean_normalizer
@@ -104,7 +101,7 @@ To remove a repository (repo is a short alias for repositories):
 
 
         return unique_config_values
         return unique_config_values
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         from pathlib import Path
         from pathlib import Path
 
 
         from poetry.core.pyproject.exceptions import PyProjectException
         from poetry.core.pyproject.exceptions import PyProjectException
@@ -146,7 +143,7 @@ To remove a repository (repo is a short alias for repositories):
         # show the value if no value is provided
         # show the value if no value is provided
         if not self.argument("value") and not self.option("unset"):
         if not self.argument("value") and not self.option("unset"):
             m = re.match(r"^repos?(?:itories)?(?:\.(.+))?", self.argument("key"))
             m = re.match(r"^repos?(?:itories)?(?:\.(.+))?", self.argument("key"))
-            value: Union[str, Dict[str, Any]]
+            value: str | dict[str, Any]
             if m:
             if m:
                 if not m.group(1):
                 if not m.group(1):
                     value = {}
                     value = {}
@@ -173,7 +170,7 @@ To remove a repository (repo is a short alias for repositories):
 
 
             return 0
             return 0
 
 
-        values: List[str] = self.argument("value")
+        values: list[str] = self.argument("value")
 
 
         unique_config_values = self.unique_config_values
         unique_config_values = self.unique_config_values
         if setting_key in unique_config_values:
         if setting_key in unique_config_values:
@@ -281,10 +278,10 @@ To remove a repository (repo is a short alias for repositories):
 
 
     def _handle_single_value(
     def _handle_single_value(
         self,
         self,
-        source: "ConfigSource",
+        source: ConfigSource,
         key: str,
         key: str,
-        callbacks: Tuple[Any, Any, Any],
-        values: List[Any],
+        callbacks: tuple[Any, Any, Any],
+        values: list[Any],
     ) -> int:
     ) -> int:
         validator, normalizer, _ = callbacks
         validator, normalizer, _ = callbacks
 
 
@@ -300,7 +297,7 @@ To remove a repository (repo is a short alias for repositories):
         return 0
         return 0
 
 
     def _list_configuration(
     def _list_configuration(
-        self, config: Dict[str, Any], raw: Dict[str, Any], k: str = ""
+        self, config: dict[str, Any], raw: dict[str, Any], k: str = ""
     ) -> None:
     ) -> None:
         orig_k = k
         orig_k = k
         for key, value in sorted(config.items()):
         for key, value in sorted(config.items()):
@@ -334,11 +331,11 @@ To remove a repository (repo is a short alias for repositories):
 
 
     def _get_setting(
     def _get_setting(
         self,
         self,
-        contents: Dict,
-        setting: Optional[str] = None,
-        k: Optional[str] = None,
-        default: Optional[Any] = None,
-    ) -> List[Tuple[str, str]]:
+        contents: dict,
+        setting: str | None = None,
+        k: str | None = None,
+        default: Any | None = None,
+    ) -> list[tuple[str, str]]:
         orig_k = k
         orig_k = k
 
 
         if setting and setting.split(".")[0] not in contents:
         if setting and setting.split(".")[0] not in contents:

src/poetry/console/commands/debug/info.py

+from __future__ import annotations
+
 import sys
 import sys
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command

src/poetry/console/commands/debug/resolve.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
@@ -92,7 +94,7 @@ class DebugResolveCommand(InitCommand):
         self.line("")
         self.line("")
 
 
         if self.option("tree"):
         if self.option("tree"):
-            show_command: "ShowCommand" = self.application.find("show")
+            show_command: ShowCommand = self.application.find("show")
             show_command.init_styles(self.io)
             show_command.init_styles(self.io)
 
 
             packages = [op.package for op in ops]
             packages = [op.package for op in ops]

src/poetry/console/commands/env/info.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 
 
 from cleo.helpers import option
 from cleo.helpers import option
 
 
@@ -17,7 +18,7 @@ class EnvInfoCommand(Command):
 
 
     options = [option("path", "p", "Only display the environment's path.")]
     options = [option("path", "p", "Only display the environment's path.")]
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         from poetry.utils.env import EnvManager
         from poetry.utils.env import EnvManager
 
 
         env = EnvManager(self.poetry).get()
         env = EnvManager(self.poetry).get()
@@ -33,7 +34,7 @@ class EnvInfoCommand(Command):
         self._display_complete_info(env)
         self._display_complete_info(env)
         return None
         return None
 
 
-    def _display_complete_info(self, env: "Env") -> None:
+    def _display_complete_info(self, env: Env) -> None:
         env_python_version = ".".join(str(s) for s in env.version_info[:3])
         env_python_version = ".".join(str(s) for s in env.version_info[:3])
         self.line("")
         self.line("")
         self.line("<b>Virtualenv</b>")
         self.line("<b>Virtualenv</b>")

src/poetry/console/commands/env/list.py

+from __future__ import annotations
+
 from cleo.helpers import option
 from cleo.helpers import option
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command

src/poetry/console/commands/env/remove.py

+from __future__ import annotations
+
 from cleo.helpers import argument
 from cleo.helpers import argument
 from cleo.helpers import option
 from cleo.helpers import option
 
 

src/poetry/console/commands/env/use.py

+from __future__ import annotations
+
 from cleo.helpers import argument
 from cleo.helpers import argument
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command

src/poetry/console/commands/env_command.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command
@@ -10,13 +12,13 @@ if TYPE_CHECKING:
 class EnvCommand(Command):
 class EnvCommand(Command):
     def __init__(self) -> None:
     def __init__(self) -> None:
         # Set in poetry.console.application.Application.configure_installer
         # Set in poetry.console.application.Application.configure_installer
-        self._env: "Env" = None  # type: ignore[assignment]
+        self._env: Env = None  # type: ignore[assignment]
 
 
         super().__init__()
         super().__init__()
 
 
     @property
     @property
-    def env(self) -> "Env":
+    def env(self) -> Env:
         return self._env
         return self._env
 
 
-    def set_env(self, env: "Env") -> None:
+    def set_env(self, env: Env) -> None:
         self._env = env
         self._env = env

src/poetry/console/commands/export.py

+from __future__ import annotations
+
 from cleo.helpers import option
 from cleo.helpers import option
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command

src/poetry/console/commands/init.py

+from __future__ import annotations
+
 import os
 import os
 import re
 import re
 import sys
 import sys
@@ -6,12 +8,7 @@ import urllib.parse
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Mapping
 from typing import Mapping
-from typing import Optional
-from typing import Tuple
-from typing import Union
 
 
 from cleo.helpers import option
 from cleo.helpers import option
 from tomlkit import inline_table
 from tomlkit import inline_table
@@ -66,7 +63,7 @@ The <c1>init</c1> command creates a basic <comment>pyproject.toml</> file in the
     def __init__(self) -> None:
     def __init__(self) -> None:
         super().__init__()
         super().__init__()
 
 
-        self._pool: Optional["Pool"] = None
+        self._pool: Pool | None = None
 
 
     def handle(self) -> int:
     def handle(self) -> int:
         from pathlib import Path
         from pathlib import Path
@@ -197,7 +194,7 @@ You can specify a package in the following forms:
             if self.io.is_interactive():
             if self.io.is_interactive():
                 self.line("")
                 self.line("")
 
 
-        dev_requirements: Dict[str, str] = {}
+        dev_requirements: dict[str, str] = {}
         if self.option("dev-dependency"):
         if self.option("dev-dependency"):
             dev_requirements = self._format_requirements(
             dev_requirements = self._format_requirements(
                 self._determine_requirements(self.option("dev-dependency"))
                 self._determine_requirements(self.option("dev-dependency"))
@@ -245,8 +242,8 @@ You can specify a package in the following forms:
         return 0
         return 0
 
 
     def _generate_choice_list(
     def _generate_choice_list(
-        self, matches: List["Package"], canonicalized_name: str
-    ) -> List[str]:
+        self, matches: list[Package], canonicalized_name: str
+    ) -> list[str]:
         choices = []
         choices = []
         matches_names = [p.name for p in matches]
         matches_names = [p.name for p in matches]
         exact_match = canonicalized_name in matches_names
         exact_match = canonicalized_name in matches_names
@@ -266,10 +263,10 @@ You can specify a package in the following forms:
 
 
     def _determine_requirements(
     def _determine_requirements(
         self,
         self,
-        requires: List[str],
+        requires: list[str],
         allow_prereleases: bool = False,
         allow_prereleases: bool = False,
-        source: Optional[str] = None,
-    ) -> List[Dict[str, Union[str, List[str]]]]:
+        source: str | None = None,
+    ) -> list[dict[str, str | list[str]]]:
         if not requires:
         if not requires:
             requires = []
             requires = []
 
 
@@ -385,10 +382,10 @@ You can specify a package in the following forms:
     def _find_best_version_for_package(
     def _find_best_version_for_package(
         self,
         self,
         name: str,
         name: str,
-        required_version: Optional[str] = None,
+        required_version: str | None = None,
         allow_prereleases: bool = False,
         allow_prereleases: bool = False,
-        source: Optional[str] = None,
-    ) -> Tuple[str, str]:
+        source: str | None = None,
+    ) -> tuple[str, str]:
         from poetry.version.version_selector import VersionSelector
         from poetry.version.version_selector import VersionSelector
 
 
         selector = VersionSelector(self._get_pool())
         selector = VersionSelector(self._get_pool())
@@ -402,7 +399,7 @@ You can specify a package in the following forms:
 
 
         return package.pretty_name, selector.find_recommended_require_version(package)
         return package.pretty_name, selector.find_recommended_require_version(package)
 
 
-    def _parse_requirements(self, requirements: List[str]) -> List[Dict[str, Any]]:
+    def _parse_requirements(self, requirements: list[str]) -> list[dict[str, Any]]:
         from poetry.core.pyproject.exceptions import PyProjectException
         from poetry.core.pyproject.exceptions import PyProjectException
 
 
         from poetry.puzzle.provider import Provider
         from poetry.puzzle.provider import Provider
@@ -493,7 +490,7 @@ You can specify a package in the following forms:
             )
             )
             pair = pair.strip()
             pair = pair.strip()
 
 
-            require: Dict[str, str] = {}
+            require: dict[str, str] = {}
             if " " in pair:
             if " " in pair:
                 name, version = pair.split(" ", 2)
                 name, version = pair.split(" ", 2)
                 extras_m = re.search(r"\[([\w\d,-_]+)\]$", name)
                 extras_m = re.search(r"\[([\w\d,-_]+)\]$", name)
@@ -533,12 +530,12 @@ You can specify a package in the following forms:
         return result
         return result
 
 
     def _format_requirements(
     def _format_requirements(
-        self, requirements: List[Dict[str, str]]
-    ) -> Mapping[str, Union[str, Mapping[str, str]]]:
+        self, requirements: list[dict[str, str]]
+    ) -> Mapping[str, str | Mapping[str, str]]:
         requires = {}
         requires = {}
         for requirement in requirements:
         for requirement in requirements:
             name = requirement.pop("name")
             name = requirement.pop("name")
-            constraint: Union[str, "InlineTable"]
+            constraint: str | InlineTable
             if "version" in requirement and len(requirement) == 1:
             if "version" in requirement and len(requirement) == 1:
                 constraint = requirement["version"]
                 constraint = requirement["version"]
             else:
             else:
@@ -550,7 +547,7 @@ You can specify a package in the following forms:
 
 
         return requires
         return requires
 
 
-    def _validate_author(self, author: str, default: str) -> Optional[str]:
+    def _validate_author(self, author: str, default: str) -> str | None:
         from poetry.core.packages.package import AUTHOR_REGEX
         from poetry.core.packages.package import AUTHOR_REGEX
 
 
         author = author or default
         author = author or default
@@ -575,7 +572,7 @@ You can specify a package in the following forms:
 
 
         return license
         return license
 
 
-    def _get_pool(self) -> "Pool":
+    def _get_pool(self) -> Pool:
         from poetry.repositories import Pool
         from poetry.repositories import Pool
         from poetry.repositories.pypi_repository import PyPiRepository
         from poetry.repositories.pypi_repository import PyPiRepository
 
 

src/poetry/console/commands/install.py

+from __future__ import annotations
+
 from cleo.helpers import option
 from cleo.helpers import option
 
 
 from poetry.console.commands.installer_command import InstallerCommand
 from poetry.console.commands.installer_command import InstallerCommand

src/poetry/console/commands/installer_command.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 from poetry.console.commands.env_command import EnvCommand
 from poetry.console.commands.env_command import EnvCommand
@@ -10,7 +12,7 @@ if TYPE_CHECKING:
 class InstallerCommand(EnvCommand):
 class InstallerCommand(EnvCommand):
     def __init__(self) -> None:
     def __init__(self) -> None:
         # Set in poetry.console.application.Application.configure_installer
         # Set in poetry.console.application.Application.configure_installer
-        self._installer: "Installer" = None  # type: ignore[assignment]
+        self._installer: Installer = None  # type: ignore[assignment]
 
 
         super().__init__()
         super().__init__()
 
 
@@ -21,8 +23,8 @@ class InstallerCommand(EnvCommand):
         self._installer.set_locker(self.poetry.locker)
         self._installer.set_locker(self.poetry.locker)
 
 
     @property
     @property
-    def installer(self) -> "Installer":
+    def installer(self) -> Installer:
         return self._installer
         return self._installer
 
 
-    def set_installer(self, installer: "Installer") -> None:
+    def set_installer(self, installer: Installer) -> None:
         self._installer = installer
         self._installer = installer

src/poetry/console/commands/lock.py

+from __future__ import annotations
+
 from cleo.helpers import option
 from cleo.helpers import option
 
 
 from poetry.console.commands.installer_command import InstallerCommand
 from poetry.console.commands.installer_command import InstallerCommand

src/poetry/console/commands/new.py

+from __future__ import annotations
+
 import sys
 import sys
 
 
 from contextlib import suppress
 from contextlib import suppress

src/poetry/console/commands/plugin/add.py

+from __future__ import annotations
+
 import os
 import os
 
 
-from typing import Dict
-from typing import List
 from typing import cast
 from typing import cast
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
@@ -176,8 +176,8 @@ You can specify a package in the following forms:
         )
         )
 
 
     def get_existing_packages_from_input(
     def get_existing_packages_from_input(
-        self, packages: List[str], poetry_content: Dict, target_section: str
-    ) -> List[str]:
+        self, packages: list[str], poetry_content: dict, target_section: str
+    ) -> list[str]:
         existing_packages = []
         existing_packages = []
 
 
         for name in packages:
         for name in packages:
@@ -187,7 +187,7 @@ You can specify a package in the following forms:
 
 
         return existing_packages
         return existing_packages
 
 
-    def notify_about_existing_packages(self, existing_packages: List[str]) -> None:
+    def notify_about_existing_packages(self, existing_packages: list[str]) -> None:
         self.line(
         self.line(
             "The following plugins are already present in the "
             "The following plugins are already present in the "
             "<c2>pyproject.toml</c2> file and will be skipped:\n"
             "<c2>pyproject.toml</c2> file and will be skipped:\n"

src/poetry/console/commands/plugin/remove.py

+from __future__ import annotations
+
 import os
 import os
 
 
 from typing import cast
 from typing import cast

src/poetry/console/commands/plugin/show.py

+from __future__ import annotations
+
 from collections import defaultdict
 from collections import defaultdict
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import DefaultDict
 from typing import DefaultDict
-from typing import Dict
-from typing import List
-from typing import Union
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command
 
 
@@ -26,7 +25,7 @@ class PluginShowCommand(Command):
         from poetry.utils.helpers import canonicalize_name
         from poetry.utils.helpers import canonicalize_name
         from poetry.utils.helpers import pluralize
         from poetry.utils.helpers import pluralize
 
 
-        plugins: DefaultDict[str, Dict[str, Union["Package", List[str]]]] = defaultdict(
+        plugins: DefaultDict[str, dict[str, Package | list[str]]] = defaultdict(
             lambda: {
             lambda: {
                 "package": None,
                 "package": None,
                 "plugins": [],
                 "plugins": [],

src/poetry/console/commands/publish.py

+from __future__ import annotations
+
 from pathlib import Path
 from pathlib import Path
-from typing import Optional
 
 
 from cleo.helpers import option
 from cleo.helpers import option
 
 
@@ -41,7 +42,7 @@ the config command.
 
 
     loggers = ["poetry.masonry.publishing.publisher"]
     loggers = ["poetry.masonry.publishing.publisher"]
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         from poetry.publishing.publisher import Publisher
         from poetry.publishing.publisher import Publisher
 
 
         publisher = Publisher(self.poetry, self.io)
         publisher = Publisher(self.poetry, self.io)

src/poetry/console/commands/remove.py

+from __future__ import annotations
+
 from typing import Any
 from typing import Any
-from typing import Dict
-from typing import List
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
 from cleo.helpers import option
 from cleo.helpers import option
@@ -113,8 +113,8 @@ list of installed packages
         return status
         return status
 
 
     def _remove_packages(
     def _remove_packages(
-        self, packages: List[str], section: Dict[str, Any], group_name: str
-    ) -> List[str]:
+        self, packages: list[str], section: dict[str, Any], group_name: str
+    ) -> list[str]:
         removed = []
         removed = []
         group = self.poetry.package.dependency_group(group_name)
         group = self.poetry.package.dependency_group(group_name)
         section_keys = list(section.keys())
         section_keys = list(section.keys())

src/poetry/console/commands/run.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
-from typing import Dict
-from typing import Union
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
 
 
@@ -36,7 +36,7 @@ class RunCommand(EnvCommand):
             return 1
             return 1
 
 
     @property
     @property
-    def _module(self) -> "Module":
+    def _module(self) -> Module:
         from poetry.core.masonry.utils.module import Module
         from poetry.core.masonry.utils.module import Module
 
 
         poetry = self.poetry
         poetry = self.poetry
@@ -46,7 +46,7 @@ class RunCommand(EnvCommand):
 
 
         return module
         return module
 
 
-    def run_script(self, script: Union[str, Dict[str, str]], args: str) -> Any:
+    def run_script(self, script: str | dict[str, str], args: str) -> Any:
         if isinstance(script, dict):
         if isinstance(script, dict):
             script = script["callable"]
             script = script["callable"]
 
 

src/poetry/console/commands/search.py

+from __future__ import annotations
+
 from cleo.helpers import argument
 from cleo.helpers import argument
 
 
 from poetry.console.commands.command import Command
 from poetry.console.commands.command import Command

src/poetry/console/commands/self/update.py

+from __future__ import annotations
+
 import os
 import os
 import shutil
 import shutil
 import site
 import site
@@ -73,7 +75,7 @@ class SelfUpdateCommand(Command):
         return self._bin_dir
         return self._bin_dir
 
 
     @property
     @property
-    def pool(self) -> "Pool":
+    def pool(self) -> Pool:
         if self._pool is not None:
         if self._pool is not None:
             return self._pool
             return self._pool
 
 
@@ -103,7 +105,7 @@ class SelfUpdateCommand(Command):
             self.line("No release found for the specified version")
             self.line("No release found for the specified version")
             return 1
             return 1
 
 
-        def cmp(x: "Package", y: "Package") -> int:
+        def cmp(x: Package, y: Package) -> int:
             if x.version == y.version:
             if x.version == y.version:
                 return 0
                 return 0
             return int(x.version < y.version or -1)
             return int(x.version < y.version or -1)
@@ -144,7 +146,7 @@ class SelfUpdateCommand(Command):
 
 
         return 0
         return 0
 
 
-    def update(self, release: "Package") -> None:
+    def update(self, release: Package) -> None:
         from poetry.utils.env import EnvManager
         from poetry.utils.env import EnvManager
 
 
         version = release.version
         version = release.version
@@ -166,7 +168,7 @@ class SelfUpdateCommand(Command):
         self._update(version)
         self._update(version)
         self._make_bin()
         self._make_bin()
 
 
-    def _update(self, version: "Version") -> None:
+    def _update(self, version: Version) -> None:
         from poetry.core.packages.dependency import Dependency
         from poetry.core.packages.dependency import Dependency
         from poetry.core.packages.project_package import ProjectPackage
         from poetry.core.packages.project_package import ProjectPackage
 
 

src/poetry/console/commands/shell.py

+from __future__ import annotations
+
 import sys
 import sys
 
 
 from distutils.util import strtobool
 from distutils.util import strtobool

src/poetry/console/commands/show.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
-from typing import Optional
-from typing import Union
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
 from cleo.helpers import option
 from cleo.helpers import option
@@ -76,7 +75,7 @@ lists all packages available."""
 
 
     colors = ["cyan", "yellow", "green", "magenta", "blue"]
     colors = ["cyan", "yellow", "green", "magenta", "blue"]
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         from cleo.io.null_io import NullIO
         from cleo.io.null_io import NullIO
         from cleo.terminal import Terminal
         from cleo.terminal import Terminal
 
 
@@ -345,7 +344,7 @@ lists all packages available."""
         return None
         return None
 
 
     def display_package_tree(
     def display_package_tree(
-        self, io: "IO", package: "Package", installed_repo: "Repository"
+        self, io: IO, package: Package, installed_repo: Repository
     ) -> None:
     ) -> None:
         io.write(f"<c1>{package.pretty_name}</c1>")
         io.write(f"<c1>{package.pretty_name}</c1>")
         description = ""
         description = ""
@@ -379,10 +378,10 @@ lists all packages available."""
 
 
     def _display_tree(
     def _display_tree(
         self,
         self,
-        io: "IO",
-        dependency: "Dependency",
-        installed_repo: "Repository",
-        packages_in_tree: List[str],
+        io: IO,
+        dependency: Dependency,
+        installed_repo: Repository,
+        packages_in_tree: list[str],
         previous_tree_bar: str = "├",
         previous_tree_bar: str = "├",
         level: int = 1,
         level: int = 1,
     ) -> None:
     ) -> None:
@@ -425,7 +424,7 @@ lists all packages available."""
                     io, dependency, installed_repo, current_tree, tree_bar, level + 1
                     io, dependency, installed_repo, current_tree, tree_bar, level + 1
                 )
                 )
 
 
-    def _write_tree_line(self, io: "IO", line: str) -> None:
+    def _write_tree_line(self, io: IO, line: str) -> None:
         if not io.output.supports_utf8():
         if not io.output.supports_utf8():
             line = line.replace("└", "`-")
             line = line.replace("└", "`-")
             line = line.replace("├", "|-")
             line = line.replace("├", "|-")
@@ -434,7 +433,7 @@ lists all packages available."""
 
 
         io.write_line(line)
         io.write_line(line)
 
 
-    def init_styles(self, io: "IO") -> None:
+    def init_styles(self, io: IO) -> None:
         from cleo.formatters.style import Style
         from cleo.formatters.style import Style
 
 
         for color in self.colors:
         for color in self.colors:
@@ -443,8 +442,8 @@ lists all packages available."""
             io.error_output.formatter.set_style(color, style)
             io.error_output.formatter.set_style(color, style)
 
 
     def find_latest_package(
     def find_latest_package(
-        self, package: "Package", root: "ProjectPackage"
-    ) -> Union["Package", bool]:
+        self, package: Package, root: ProjectPackage
+    ) -> Package | bool:
         from cleo.io.null_io import NullIO
         from cleo.io.null_io import NullIO
 
 
         from poetry.puzzle.provider import Provider
         from poetry.puzzle.provider import Provider
@@ -470,7 +469,7 @@ lists all packages available."""
 
 
         return selector.find_best_candidate(name, f">={package.pretty_version}")
         return selector.find_best_candidate(name, f">={package.pretty_version}")
 
 
-    def get_update_status(self, latest: "Package", package: "Package") -> str:
+    def get_update_status(self, latest: Package, package: Package) -> str:
         from poetry.core.semver.helpers import parse_constraint
         from poetry.core.semver.helpers import parse_constraint
 
 
         if latest.full_pretty_version == package.full_pretty_version:
         if latest.full_pretty_version == package.full_pretty_version:
@@ -486,7 +485,7 @@ lists all packages available."""
         return "update-possible"
         return "update-possible"
 
 
     def get_installed_status(
     def get_installed_status(
-        self, locked: "Package", installed_repo: "InstalledRepository"
+        self, locked: Package, installed_repo: InstalledRepository
     ) -> str:
     ) -> str:
         for package in installed_repo.packages:
         for package in installed_repo.packages:
             if locked.name == package.name:
             if locked.name == package.name:

src/poetry/console/commands/source/add.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
 from cleo.helpers import option
 from cleo.helpers import option
@@ -41,14 +42,14 @@ class SourceAddCommand(Command):
     ]
     ]
 
 
     @staticmethod
     @staticmethod
-    def source_to_table(source: Source) -> "Table":
-        source_table: "Table" = table()
+    def source_to_table(source: Source) -> Table:
+        source_table: Table = table()
         for key, value in source.to_dict().items():
         for key, value in source.to_dict().items():
             source_table.add(key, value)
             source_table.add(key, value)
         source_table.add(nl())
         source_table.add(nl())
         return source_table
         return source_table
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         from poetry.factory import Factory
         from poetry.factory import Factory
         from poetry.repositories import Pool
         from poetry.repositories import Pool
 
 
@@ -64,7 +65,7 @@ class SourceAddCommand(Command):
             )
             )
             return 1
             return 1
 
 
-        new_source: Optional[Source] = Source(
+        new_source: Source | None = Source(
             name=name, url=url, default=is_default, secondary=is_secondary
             name=name, url=url, default=is_default, secondary=is_secondary
         )
         )
         existing_sources = self.poetry.get_sources()
         existing_sources = self.poetry.get_sources()

src/poetry/console/commands/source/remove.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
 from tomlkit import nl
 from tomlkit import nl
@@ -28,14 +29,14 @@ class SourceRemoveCommand(Command):
     ]
     ]
 
 
     @staticmethod
     @staticmethod
-    def source_to_table(source: "Source") -> "Table":
-        source_table: "Table" = table()
+    def source_to_table(source: Source) -> Table:
+        source_table: Table = table()
         for key, value in source.to_dict().items():
         for key, value in source.to_dict().items():
             source_table.add(key, value)
             source_table.add(key, value)
         source_table.add(nl())
         source_table.add(nl())
         return source_table
         return source_table
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         name = self.argument("name")
         name = self.argument("name")
 
 
         sources = AoT([])
         sources = AoT([])

src/poetry/console/commands/source/show.py

-from typing import Optional
+from __future__ import annotations
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
 
 
@@ -18,7 +18,7 @@ class SourceShowCommand(Command):
         ),
         ),
     ]
     ]
 
 
-    def handle(self) -> Optional[int]:
+    def handle(self) -> int | None:
         sources = self.poetry.get_sources()
         sources = self.poetry.get_sources()
         names = self.argument("source")
         names = self.argument("source")
 
 

src/poetry/console/commands/update.py

+from __future__ import annotations
+
 from cleo.helpers import argument
 from cleo.helpers import argument
 from cleo.helpers import option
 from cleo.helpers import option
 
 

src/poetry/console/commands/version.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 from cleo.helpers import argument
 from cleo.helpers import argument
@@ -76,7 +78,7 @@ patch, minor, major, prepatch, preminor, premajor, prerelease.
                     f" <info>{self.poetry.package.pretty_version}</>"
                     f" <info>{self.poetry.package.pretty_version}</>"
                 )
                 )
 
 
-    def increment_version(self, version: str, rule: str) -> "Version":
+    def increment_version(self, version: str, rule: str) -> Version:
         from poetry.core.semver.version import Version
         from poetry.core.semver.version import Version
 
 
         try:
         try:

src/poetry/console/exceptions.py

+from __future__ import annotations
+
 from cleo.exceptions import CleoSimpleException
 from cleo.exceptions import CleoSimpleException
 
 
 
 

src/poetry/console/io/inputs/run_argv_input.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
-from typing import Optional
-from typing import Union
 
 
 from cleo.io.inputs.argv_input import ArgvInput
 from cleo.io.inputs.argv_input import ArgvInput
 
 
@@ -13,22 +12,22 @@ if TYPE_CHECKING:
 class RunArgvInput(ArgvInput):
 class RunArgvInput(ArgvInput):
     def __init__(
     def __init__(
         self,
         self,
-        argv: Optional[List[str]] = None,
-        definition: Optional["Definition"] = None,
+        argv: list[str] | None = None,
+        definition: Definition | None = None,
     ) -> None:
     ) -> None:
         super().__init__(argv, definition=definition)
         super().__init__(argv, definition=definition)
 
 
-        self._parameter_options: List[str] = []
+        self._parameter_options: list[str] = []
 
 
     @property
     @property
-    def first_argument(self) -> Optional[str]:
+    def first_argument(self) -> str | None:
         return "run"
         return "run"
 
 
     def add_parameter_option(self, name: str) -> None:
     def add_parameter_option(self, name: str) -> None:
         self._parameter_options.append(name)
         self._parameter_options.append(name)
 
 
     def has_parameter_option(
     def has_parameter_option(
-        self, values: Union[str, List[str]], only_params: bool = False
+        self, values: str | list[str], only_params: bool = False
     ) -> bool:
     ) -> bool:
         if not isinstance(values, list):
         if not isinstance(values, list):
             values = [values]
             values = [values]

src/poetry/console/logging/formatters/__init__.py

+from __future__ import annotations
+
 from poetry.console.logging.formatters.builder_formatter import BuilderLogFormatter
 from poetry.console.logging.formatters.builder_formatter import BuilderLogFormatter
 
 
 
 

src/poetry/console/logging/formatters/builder_formatter.py

+from __future__ import annotations
+
 import re
 import re
 
 
 from poetry.console.logging.formatters.formatter import Formatter
 from poetry.console.logging.formatters.formatter import Formatter

src/poetry/console/logging/formatters/formatter.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 
 
@@ -6,5 +8,5 @@ if TYPE_CHECKING:
 
 
 
 
 class Formatter:
 class Formatter:
-    def format(self, record: "logging.LogRecord") -> str:
+    def format(self, record: logging.LogRecord) -> str:
         raise NotImplementedError()
         raise NotImplementedError()

src/poetry/console/logging/io_formatter.py

+from __future__ import annotations
+
 import logging
 import logging
 
 
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
@@ -18,7 +20,7 @@ class IOFormatter(logging.Formatter):
         "info": "fg=blue",
         "info": "fg=blue",
     }
     }
 
 
-    def format(self, record: "LogRecord") -> str:
+    def format(self, record: LogRecord) -> str:
         if not record.exc_info:
         if not record.exc_info:
             level = record.levelname.lower()
             level = record.levelname.lower()
             msg = record.msg
             msg = record.msg

src/poetry/console/logging/io_handler.py

+from __future__ import annotations
+
 import logging
 import logging
 
 
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
@@ -10,12 +12,12 @@ if TYPE_CHECKING:
 
 
 
 
 class IOHandler(logging.Handler):
 class IOHandler(logging.Handler):
-    def __init__(self, io: "IO") -> None:
+    def __init__(self, io: IO) -> None:
         self._io = io
         self._io = io
 
 
         super().__init__()
         super().__init__()
 
 
-    def emit(self, record: "LogRecord") -> None:
+    def emit(self, record: LogRecord) -> None:
         try:
         try:
             msg = self.format(record)
             msg = self.format(record)
             level = record.levelname.lower()
             level = record.levelname.lower()

src/poetry/exceptions.py

+from __future__ import annotations
+
+
 class PoetryException(Exception):
 class PoetryException(Exception):
 
 
     pass
     pass

src/poetry/factory.py

+from __future__ import annotations
+
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
-from typing import List
-from typing import Optional
 
 
 from cleo.io.null_io import NullIO
 from cleo.io.null_io import NullIO
 from poetry.core.factory import Factory as BaseFactory
 from poetry.core.factory import Factory as BaseFactory
@@ -30,8 +29,8 @@ class Factory(BaseFactory):
 
 
     def create_poetry(
     def create_poetry(
         self,
         self,
-        cwd: Optional[Path] = None,
-        io: Optional["IO"] = None,
+        cwd: Path | None = None,
+        io: IO | None = None,
         disable_plugins: bool = False,
         disable_plugins: bool = False,
     ) -> Poetry:
     ) -> Poetry:
         if io is None:
         if io is None:
@@ -90,7 +89,7 @@ class Factory(BaseFactory):
         return ProjectPackage(name, version, version)
         return ProjectPackage(name, version, version)
 
 
     @classmethod
     @classmethod
-    def create_config(cls, io: Optional["IO"] = None) -> Config:
+    def create_config(cls, io: IO | None = None) -> Config:
         if io is None:
         if io is None:
             io = NullIO()
             io = NullIO()
 
 
@@ -123,7 +122,7 @@ class Factory(BaseFactory):
 
 
     @classmethod
     @classmethod
     def configure_sources(
     def configure_sources(
-        cls, poetry: Poetry, sources: List[Dict[str, str]], config: Config, io: "IO"
+        cls, poetry: Poetry, sources: list[dict[str, str]], config: Config, io: IO
     ) -> None:
     ) -> None:
         for source in sources:
         for source in sources:
             repository = cls.create_legacy_repository(source, config)
             repository = cls.create_legacy_repository(source, config)
@@ -154,8 +153,8 @@ class Factory(BaseFactory):
 
 
     @classmethod
     @classmethod
     def create_legacy_repository(
     def create_legacy_repository(
-        cls, source: Dict[str, str], auth_config: Config
-    ) -> "LegacyRepository":
+        cls, source: dict[str, str], auth_config: Config
+    ) -> LegacyRepository:
         from poetry.repositories.legacy_repository import LegacyRepository
         from poetry.repositories.legacy_repository import LegacyRepository
         from poetry.utils.helpers import get_cert
         from poetry.utils.helpers import get_cert
         from poetry.utils.helpers import get_client_cert
         from poetry.utils.helpers import get_client_cert

src/poetry/inspection/info.py

+from __future__ import annotations
+
 import glob
 import glob
 import logging
 import logging
 import os
 import os
@@ -6,11 +8,7 @@ import zipfile
 
 
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
 from typing import Iterator
 from typing import Iterator
-from typing import List
-from typing import Optional
-from typing import Union
 
 
 import pkginfo
 import pkginfo
 
 
@@ -46,9 +44,7 @@ PEP517_META_BUILD_DEPS = ["pep517===0.8.2", "toml==0.10.1"]
 
 
 
 
 class PackageInfoError(ValueError):
 class PackageInfoError(ValueError):
-    def __init__(
-        self, path: Union[Path, str], *reasons: Union[BaseException, str]
-    ) -> None:
+    def __init__(self, path: Path | str, *reasons: BaseException | str) -> None:
         reasons = (f"Unable to determine package info for path: {path!s}",) + reasons
         reasons = (f"Unable to determine package info for path: {path!s}",) + reasons
         super().__init__("\n\n".join(str(msg).strip() for msg in reasons if msg))
         super().__init__("\n\n".join(str(msg).strip() for msg in reasons if msg))
 
 
@@ -56,14 +52,14 @@ class PackageInfoError(ValueError):
 class PackageInfo:
 class PackageInfo:
     def __init__(
     def __init__(
         self,
         self,
-        name: Optional[str] = None,
-        version: Optional[str] = None,
-        summary: Optional[str] = None,
-        platform: Optional[str] = None,
-        requires_dist: Optional[List[str]] = None,
-        requires_python: Optional[str] = None,
-        files: Optional[List[Dict[str, str]]] = None,
-        cache_version: Optional[str] = None,
+        name: str | None = None,
+        version: str | None = None,
+        summary: str | None = None,
+        platform: str | None = None,
+        requires_dist: list[str] | None = None,
+        requires_python: str | None = None,
+        files: list[dict[str, str]] | None = None,
+        cache_version: str | None = None,
     ):
     ):
         self.name = name
         self.name = name
         self.version = version
         self.version = version
@@ -78,10 +74,10 @@ class PackageInfo:
         self._source_reference = None
         self._source_reference = None
 
 
     @property
     @property
-    def cache_version(self) -> Optional[str]:
+    def cache_version(self) -> str | None:
         return self._cache_version
         return self._cache_version
 
 
-    def update(self, other: "PackageInfo") -> "PackageInfo":
+    def update(self, other: PackageInfo) -> PackageInfo:
         self.name = other.name or self.name
         self.name = other.name or self.name
         self.version = other.version or self.version
         self.version = other.version or self.version
         self.summary = other.summary or self.summary
         self.summary = other.summary or self.summary
@@ -92,7 +88,7 @@ class PackageInfo:
         self._cache_version = other.cache_version or self._cache_version
         self._cache_version = other.cache_version or self._cache_version
         return self
         return self
 
 
-    def asdict(self) -> Dict[str, Optional[Union[str, List[str]]]]:
+    def asdict(self) -> dict[str, str | list[str] | None]:
         """
         """
         Helper method to convert package info into a dictionary used for caching.
         Helper method to convert package info into a dictionary used for caching.
         """
         """
@@ -108,7 +104,7 @@ class PackageInfo:
         }
         }
 
 
     @classmethod
     @classmethod
-    def load(cls, data: Dict[str, Optional[Union[str, List[str]]]]) -> "PackageInfo":
+    def load(cls, data: dict[str, str | list[str] | None]) -> PackageInfo:
         """
         """
         Helper method to load data from a dictionary produced by `PackageInfo.asdict()`.
         Helper method to load data from a dictionary produced by `PackageInfo.asdict()`.
 
 
@@ -125,9 +121,9 @@ class PackageInfo:
 
 
     def to_package(
     def to_package(
         self,
         self,
-        name: Optional[str] = None,
-        extras: Optional[List[str]] = None,
-        root_dir: Optional[Path] = None,
+        name: str | None = None,
+        extras: list[str] | None = None,
+        root_dir: Path | None = None,
     ) -> Package:
     ) -> Package:
         """
         """
         Create a new `poetry.core.packages.package.Package` instance using metadata from
         Create a new `poetry.core.packages.package.Package` instance using metadata from
@@ -208,8 +204,8 @@ class PackageInfo:
 
 
     @classmethod
     @classmethod
     def _from_distribution(
     def _from_distribution(
-        cls, dist: Union[pkginfo.BDist, pkginfo.SDist, pkginfo.Wheel]
-    ) -> "PackageInfo":
+        cls, dist: pkginfo.BDist | pkginfo.SDist | pkginfo.Wheel
+    ) -> PackageInfo:
         """
         """
         Helper method to parse package information from a `pkginfo.Distribution`
         Helper method to parse package information from a `pkginfo.Distribution`
         instance.
         instance.
@@ -241,7 +237,7 @@ class PackageInfo:
         return info
         return info
 
 
     @classmethod
     @classmethod
-    def _from_sdist_file(cls, path: Path) -> "PackageInfo":
+    def _from_sdist_file(cls, path: Path) -> PackageInfo:
         """
         """
         Helper method to parse package information from an sdist file. We attempt to
         Helper method to parse package information from an sdist file. We attempt to
         first inspect the file using `pkginfo.SDist`. If this does not provide us with
         first inspect the file using `pkginfo.SDist`. If this does not provide us with
@@ -306,7 +302,7 @@ class PackageInfo:
         return any((path / f).exists() for f in SetupReader.FILES)
         return any((path / f).exists() for f in SetupReader.FILES)
 
 
     @classmethod
     @classmethod
-    def from_setup_files(cls, path: Path) -> "PackageInfo":
+    def from_setup_files(cls, path: Path) -> PackageInfo:
         """
         """
         Mechanism to parse package information from a `setup.[py|cfg]` file. This uses
         Mechanism to parse package information from a `setup.[py|cfg]` file. This uses
         the implementation at `poetry.utils.setup_reader.SetupReader` in order to parse
         the implementation at `poetry.utils.setup_reader.SetupReader` in order to parse
@@ -377,7 +373,7 @@ class PackageInfo:
             yield Path(d)
             yield Path(d)
 
 
     @classmethod
     @classmethod
-    def from_metadata(cls, path: Path) -> Optional["PackageInfo"]:
+    def from_metadata(cls, path: Path) -> PackageInfo | None:
         """
         """
         Helper method to parse package information from an unpacked metadata directory.
         Helper method to parse package information from an unpacked metadata directory.
 
 
@@ -412,7 +408,7 @@ class PackageInfo:
         return None
         return None
 
 
     @classmethod
     @classmethod
-    def from_package(cls, package: Package) -> "PackageInfo":
+    def from_package(cls, package: Package) -> PackageInfo:
         """
         """
         Helper method to inspect a `Package` object, in order to generate package info.
         Helper method to inspect a `Package` object, in order to generate package info.
 
 
@@ -435,7 +431,7 @@ class PackageInfo:
         )
         )
 
 
     @staticmethod
     @staticmethod
-    def _get_poetry_package(path: Path) -> Optional["ProjectPackage"]:
+    def _get_poetry_package(path: Path) -> ProjectPackage | None:
         # Note: we ignore any setup.py file at this step
         # Note: we ignore any setup.py file at this step
         # TODO: add support for handling non-poetry PEP-517 builds
         # TODO: add support for handling non-poetry PEP-517 builds
         if PyProjectTOML(path.joinpath("pyproject.toml")).is_poetry_project():
         if PyProjectTOML(path.joinpath("pyproject.toml")).is_poetry_project():
@@ -443,7 +439,7 @@ class PackageInfo:
         return None
         return None
 
 
     @classmethod
     @classmethod
-    def _pep517_metadata(cls, path: Path) -> "PackageInfo":
+    def _pep517_metadata(cls, path: Path) -> PackageInfo:
         """
         """
         Helper method to use PEP-517 library to build and read package metadata.
         Helper method to use PEP-517 library to build and read package metadata.
 
 
@@ -513,7 +509,7 @@ class PackageInfo:
         raise PackageInfoError(path, "Exhausted all core metadata sources.")
         raise PackageInfoError(path, "Exhausted all core metadata sources.")
 
 
     @classmethod
     @classmethod
-    def from_directory(cls, path: Path, disable_build: bool = False) -> "PackageInfo":
+    def from_directory(cls, path: Path, disable_build: bool = False) -> PackageInfo:
         """
         """
         Generate package information from a package source directory. If `disable_build`
         Generate package information from a package source directory. If `disable_build`
         is not `True` and introspection of all available metadata fails, the package is
         is not `True` and introspection of all available metadata fails, the package is
@@ -548,7 +544,7 @@ class PackageInfo:
         return info
         return info
 
 
     @classmethod
     @classmethod
-    def from_sdist(cls, path: Path) -> "PackageInfo":
+    def from_sdist(cls, path: Path) -> PackageInfo:
         """
         """
         Gather package information from an sdist file, packed or unpacked.
         Gather package information from an sdist file, packed or unpacked.
 
 
@@ -562,7 +558,7 @@ class PackageInfo:
         return cls.from_directory(path=path)
         return cls.from_directory(path=path)
 
 
     @classmethod
     @classmethod
-    def from_wheel(cls, path: Path) -> "PackageInfo":
+    def from_wheel(cls, path: Path) -> PackageInfo:
         """
         """
         Gather package information from a wheel.
         Gather package information from a wheel.
 
 
@@ -574,7 +570,7 @@ class PackageInfo:
             return PackageInfo()
             return PackageInfo()
 
 
     @classmethod
     @classmethod
-    def from_bdist(cls, path: Path) -> "PackageInfo":
+    def from_bdist(cls, path: Path) -> PackageInfo:
         """
         """
         Gather package information from a bdist (wheel etc.).
         Gather package information from a bdist (wheel etc.).
 
 
@@ -592,7 +588,7 @@ class PackageInfo:
             raise PackageInfoError(path, e)
             raise PackageInfoError(path, e)
 
 
     @classmethod
     @classmethod
-    def from_path(cls, path: Path) -> "PackageInfo":
+    def from_path(cls, path: Path) -> PackageInfo:
         """
         """
         Gather package information from a given path (bdist, sdist, directory).
         Gather package information from a given path (bdist, sdist, directory).
 
 

src/poetry/installation/__init__.py

+from __future__ import annotations
+
 from poetry.installation.installer import Installer
 from poetry.installation.installer import Installer

src/poetry/installation/base_installer.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 
 
@@ -6,11 +8,11 @@ if TYPE_CHECKING:
 
 
 
 
 class BaseInstaller:
 class BaseInstaller:
-    def install(self, package: "Package") -> None:
+    def install(self, package: Package) -> None:
         raise NotImplementedError
         raise NotImplementedError
 
 
-    def update(self, source: "Package", target: "Package") -> None:
+    def update(self, source: Package, target: Package) -> None:
         raise NotImplementedError
         raise NotImplementedError
 
 
-    def remove(self, package: "Package") -> None:
+    def remove(self, package: Package) -> None:
         raise NotImplementedError
         raise NotImplementedError

src/poetry/installation/chef.py

+from __future__ import annotations
+
 import hashlib
 import hashlib
 import json
 import json
 
 
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
-from typing import Optional
 
 
 from poetry.core.packages.utils.link import Link
 from poetry.core.packages.utils.link import Link
 
 
@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 
 
 
 
 class Chef:
 class Chef:
-    def __init__(self, config: "Config", env: "Env") -> None:
+    def __init__(self, config: Config, env: Env) -> None:
         self._config = config
         self._config = config
         self._env = env
         self._env = env
         self._cache_dir = (
         self._cache_dir = (
@@ -41,7 +41,7 @@ class Chef:
     def is_wheel(self, archive: Path) -> bool:
     def is_wheel(self, archive: Path) -> bool:
         return archive.suffix == ".whl"
         return archive.suffix == ".whl"
 
 
-    def get_cached_archive_for_link(self, link: Link) -> Optional[Link]:
+    def get_cached_archive_for_link(self, link: Link) -> Link | None:
         # If the archive is already a wheel, there is no need to cache it.
         # If the archive is already a wheel, there is no need to cache it.
         if link.is_wheel:
         if link.is_wheel:
             return link
             return link
@@ -74,7 +74,7 @@ class Chef:
 
 
         return min(candidates)[1]
         return min(candidates)[1]
 
 
-    def get_cached_archives_for_link(self, link: Link) -> List[Link]:
+    def get_cached_archives_for_link(self, link: Link) -> list[Link]:
         cache_dir = self.get_cache_directory_for_link(link)
         cache_dir = self.get_cache_directory_for_link(link)
 
 
         archive_types = ["whl", "tar.gz", "tar.bz2", "bz2", "zip"]
         archive_types = ["whl", "tar.gz", "tar.bz2", "bz2", "zip"]

src/poetry/installation/chooser.py

+from __future__ import annotations
+
 import re
 import re
 
 
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
-from typing import Optional
-from typing import Tuple
 
 
 from packaging.tags import Tag
 from packaging.tags import Tag
 
 
@@ -40,12 +39,12 @@ class Wheel:
             Tag(x, y, z) for x in self.pyversions for y in self.abis for z in self.plats
             Tag(x, y, z) for x in self.pyversions for y in self.abis for z in self.plats
         }
         }
 
 
-    def get_minimum_supported_index(self, tags: List[Tag]) -> Optional[int]:
+    def get_minimum_supported_index(self, tags: list[Tag]) -> int | None:
         indexes = [tags.index(t) for t in self.tags if t in tags]
         indexes = [tags.index(t) for t in self.tags if t in tags]
 
 
         return min(indexes) if indexes else None
         return min(indexes) if indexes else None
 
 
-    def is_supported_by_environment(self, env: "Env") -> bool:
+    def is_supported_by_environment(self, env: Env) -> bool:
         return bool(set(env.supported_tags).intersection(self.tags))
         return bool(set(env.supported_tags).intersection(self.tags))
 
 
 
 
@@ -54,11 +53,11 @@ class Chooser:
     A Chooser chooses an appropriate release archive for packages.
     A Chooser chooses an appropriate release archive for packages.
     """
     """
 
 
-    def __init__(self, pool: "Pool", env: "Env") -> None:
+    def __init__(self, pool: Pool, env: Env) -> None:
         self._pool = pool
         self._pool = pool
         self._env = env
         self._env = env
 
 
-    def choose_for(self, package: "Package") -> "Link":
+    def choose_for(self, package: Package) -> Link:
         """
         """
         Return the url of the selected archive for a given package.
         Return the url of the selected archive for a given package.
         """
         """
@@ -84,7 +83,7 @@ class Chooser:
 
 
         return chosen
         return chosen
 
 
-    def _get_links(self, package: "Package") -> List["Link"]:
+    def _get_links(self, package: Package) -> list[Link]:
         if package.source_type:
         if package.source_type:
             repository = self._pool.repository(package.source_reference)
             repository = self._pool.repository(package.source_reference)
 
 
@@ -118,7 +117,7 @@ class Chooser:
 
 
         return selected_links
         return selected_links
 
 
-    def _sort_key(self, package: "Package", link: "Link") -> Tuple:
+    def _sort_key(self, package: Package, link: Link) -> tuple:
         """
         """
         Function to pass as the `key` argument to a call to sorted() to sort
         Function to pass as the `key` argument to a call to sorted() to sort
         InstallationCandidates by preference.
         InstallationCandidates by preference.
@@ -176,9 +175,7 @@ class Chooser:
             pri,
             pri,
         )
         )
 
 
-    def _is_link_hash_allowed_for_package(
-        self, link: "Link", package: "Package"
-    ) -> bool:
+    def _is_link_hash_allowed_for_package(self, link: Link, package: Package) -> bool:
         if not link.hash:
         if not link.hash:
             return True
             return True
 
 

src/poetry/installation/installer.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Iterable
 from typing import Iterable
-from typing import List
-from typing import Optional
 from typing import Sequence
 from typing import Sequence
-from typing import Union
 
 
 from cleo.io.null_io import NullIO
 from cleo.io.null_io import NullIO
 
 
@@ -35,14 +34,14 @@ if TYPE_CHECKING:
 class Installer:
 class Installer:
     def __init__(
     def __init__(
         self,
         self,
-        io: "IO",
-        env: "Env",
-        package: "ProjectPackage",
-        locker: "Locker",
+        io: IO,
+        env: Env,
+        package: ProjectPackage,
+        locker: Locker,
         pool: Pool,
         pool: Pool,
-        config: "Config",
-        installed: Union[Repository, None] = None,
-        executor: Optional[Executor] = None,
+        config: Config,
+        installed: Repository | None = None,
+        executor: Executor | None = None,
     ):
     ):
         self._io = io
         self._io = io
         self._env = env
         self._env = env
@@ -83,15 +82,15 @@ class Installer:
         return self._executor
         return self._executor
 
 
     @property
     @property
-    def installer(self) -> "BaseInstaller":
+    def installer(self) -> BaseInstaller:
         return self._installer
         return self._installer
 
 
-    def set_package(self, package: "ProjectPackage") -> "Installer":
+    def set_package(self, package: ProjectPackage) -> Installer:
         self._package = package
         self._package = package
 
 
         return self
         return self
 
 
-    def set_locker(self, locker: "Locker") -> "Installer":
+    def set_locker(self, locker: Locker) -> Installer:
         self._locker = locker
         self._locker = locker
 
 
         return self
         return self
@@ -114,7 +113,7 @@ class Installer:
 
 
         return self._do_install(local_repo)
         return self._do_install(local_repo)
 
 
-    def dry_run(self, dry_run: bool = True) -> "Installer":
+    def dry_run(self, dry_run: bool = True) -> Installer:
         self._dry_run = dry_run
         self._dry_run = dry_run
         self._executor.dry_run(dry_run)
         self._executor.dry_run(dry_run)
 
 
@@ -125,12 +124,12 @@ class Installer:
 
 
     def requires_synchronization(
     def requires_synchronization(
         self, requires_synchronization: bool = True
         self, requires_synchronization: bool = True
-    ) -> "Installer":
+    ) -> Installer:
         self._requires_synchronization = requires_synchronization
         self._requires_synchronization = requires_synchronization
 
 
         return self
         return self
 
 
-    def verbose(self, verbose: bool = True) -> "Installer":
+    def verbose(self, verbose: bool = True) -> Installer:
         self._verbose = verbose
         self._verbose = verbose
         self._executor.verbose(verbose)
         self._executor.verbose(verbose)
 
 
@@ -139,27 +138,27 @@ class Installer:
     def is_verbose(self) -> bool:
     def is_verbose(self) -> bool:
         return self._verbose
         return self._verbose
 
 
-    def without_groups(self, groups: List[str]) -> "Installer":
+    def without_groups(self, groups: list[str]) -> Installer:
         self._without_groups = groups
         self._without_groups = groups
 
 
         return self
         return self
 
 
-    def with_groups(self, groups: List[str]) -> "Installer":
+    def with_groups(self, groups: list[str]) -> Installer:
         self._with_groups = groups
         self._with_groups = groups
 
 
         return self
         return self
 
 
-    def only_groups(self, groups: List[str]) -> "Installer":
+    def only_groups(self, groups: list[str]) -> Installer:
         self._only_groups = groups
         self._only_groups = groups
 
 
         return self
         return self
 
 
-    def update(self, update: bool = True) -> "Installer":
+    def update(self, update: bool = True) -> Installer:
         self._update = update
         self._update = update
 
 
         return self
         return self
 
 
-    def lock(self, update: bool = True) -> "Installer":
+    def lock(self, update: bool = True) -> Installer:
         """
         """
         Prepare the installer for locking only.
         Prepare the installer for locking only.
         """
         """
@@ -172,7 +171,7 @@ class Installer:
     def is_updating(self) -> bool:
     def is_updating(self) -> bool:
         return self._update
         return self._update
 
 
-    def execute_operations(self, execute: bool = True) -> "Installer":
+    def execute_operations(self, execute: bool = True) -> Installer:
         self._execute_operations = execute
         self._execute_operations = execute
 
 
         if not execute:
         if not execute:
@@ -180,17 +179,17 @@ class Installer:
 
 
         return self
         return self
 
 
-    def whitelist(self, packages: Iterable[str]) -> "Installer":
+    def whitelist(self, packages: Iterable[str]) -> Installer:
         self._whitelist = [canonicalize_name(p) for p in packages]
         self._whitelist = [canonicalize_name(p) for p in packages]
 
 
         return self
         return self
 
 
-    def extras(self, extras: list) -> "Installer":
+    def extras(self, extras: list) -> Installer:
         self._extras = extras
         self._extras = extras
 
 
         return self
         return self
 
 
-    def use_executor(self, use_executor: bool = True) -> "Installer":
+    def use_executor(self, use_executor: bool = True) -> Installer:
         self._use_executor = use_executor
         self._use_executor = use_executor
 
 
         return self
         return self
@@ -362,7 +361,7 @@ class Installer:
                 self._io.write_line("")
                 self._io.write_line("")
                 self._io.write_line("<info>Writing lock file</>")
                 self._io.write_line("<info>Writing lock file</>")
 
 
-    def _execute(self, operations: List["OperationTypes"]) -> int:
+    def _execute(self, operations: list[OperationTypes]) -> int:
         if self._use_executor:
         if self._use_executor:
             return self._executor.execute(operations)
             return self._executor.execute(operations)
 
 
@@ -400,7 +399,7 @@ class Installer:
 
 
         return 0
         return 0
 
 
-    def _execute_operation(self, operation: "Operation") -> None:
+    def _execute_operation(self, operation: Operation) -> None:
         """
         """
         Execute a given operation.
         Execute a given operation.
         """
         """
@@ -478,7 +477,7 @@ class Installer:
         self._installer.remove(operation.package)
         self._installer.remove(operation.package)
 
 
     def _populate_local_repo(
     def _populate_local_repo(
-        self, local_repo: Repository, ops: Sequence["Operation"]
+        self, local_repo: Repository, ops: Sequence[Operation]
     ) -> None:
     ) -> None:
         for op in ops:
         for op in ops:
             if isinstance(op, Uninstall):
             if isinstance(op, Uninstall):
@@ -493,7 +492,7 @@ class Installer:
 
 
     def _get_operations_from_lock(
     def _get_operations_from_lock(
         self, locked_repository: Repository
         self, locked_repository: Repository
-    ) -> Sequence["Operation"]:
+    ) -> Sequence[Operation]:
         installed_repo = self._installed_repository
         installed_repo = self._installed_repository
         ops = []
         ops = []
 
 
@@ -522,7 +521,7 @@ class Installer:
 
 
         return ops
         return ops
 
 
-    def _filter_operations(self, ops: Sequence["Operation"], repo: Repository) -> None:
+    def _filter_operations(self, ops: Sequence[Operation], repo: Repository) -> None:
         extra_packages = self._get_extra_packages(repo)
         extra_packages = self._get_extra_packages(repo)
         for op in ops:
         for op in ops:
             if isinstance(op, Update):
             if isinstance(op, Update):
@@ -551,7 +550,7 @@ class Installer:
             if package.optional and package.name not in extra_packages:
             if package.optional and package.name not in extra_packages:
                 op.skip("Not required")
                 op.skip("Not required")
 
 
-    def _get_extra_packages(self, repo: Repository) -> List[str]:
+    def _get_extra_packages(self, repo: Repository) -> list[str]:
         """
         """
         Returns all package names required by extras.
         Returns all package names required by extras.
 
 
@@ -564,7 +563,7 @@ class Installer:
 
 
         return list(get_extra_package_names(repo.packages, extras, self._extras))
         return list(get_extra_package_names(repo.packages, extras, self._extras))
 
 
-    def _get_installer(self) -> "BaseInstaller":
+    def _get_installer(self) -> BaseInstaller:
         return PipInstaller(self._env, self._io, self._pool)
         return PipInstaller(self._env, self._io, self._pool)
 
 
     def _get_installed(self) -> InstalledRepository:
     def _get_installed(self) -> InstalledRepository:

src/poetry/installation/noop_installer.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
 
 
 from poetry.installation.base_installer import BaseInstaller
 from poetry.installation.base_installer import BaseInstaller
 
 
@@ -10,27 +11,27 @@ if TYPE_CHECKING:
 
 
 class NoopInstaller(BaseInstaller):
 class NoopInstaller(BaseInstaller):
     def __init__(self) -> None:
     def __init__(self) -> None:
-        self._installs: List["Package"] = []
-        self._updates: List["Package"] = []
-        self._removals: List["Package"] = []
+        self._installs: list[Package] = []
+        self._updates: list[Package] = []
+        self._removals: list[Package] = []
 
 
     @property
     @property
-    def installs(self) -> List["Package"]:
+    def installs(self) -> list[Package]:
         return self._installs
         return self._installs
 
 
     @property
     @property
-    def updates(self) -> List["Package"]:
+    def updates(self) -> list[Package]:
         return self._updates
         return self._updates
 
 
     @property
     @property
-    def removals(self) -> List["Package"]:
+    def removals(self) -> list[Package]:
         return self._removals
         return self._removals
 
 
-    def install(self, package: "Package") -> None:
+    def install(self, package: Package) -> None:
         self._installs.append(package)
         self._installs.append(package)
 
 
-    def update(self, source: "Package", target: "Package") -> None:
+    def update(self, source: Package, target: Package) -> None:
         self._updates.append((source, target))
         self._updates.append((source, target))
 
 
-    def remove(self, package: "Package") -> None:
+    def remove(self, package: Package) -> None:
         self._removals.append(package)
         self._removals.append(package)

src/poetry/installation/operations/__init__.py

+from __future__ import annotations
+
 from typing import Union
 from typing import Union
 
 
 from poetry.installation.operations.install import Install
 from poetry.installation.operations.install import Install

src/poetry/installation/operations/install.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 
 
 from poetry.installation.operations.operation import Operation
 from poetry.installation.operations.operation import Operation
 
 
@@ -10,14 +11,14 @@ if TYPE_CHECKING:
 
 
 class Install(Operation):
 class Install(Operation):
     def __init__(
     def __init__(
-        self, package: "Package", reason: Optional[str] = None, priority: int = 0
+        self, package: Package, reason: str | None = None, priority: int = 0
     ) -> None:
     ) -> None:
         super().__init__(reason, priority=priority)
         super().__init__(reason, priority=priority)
 
 
         self._package = package
         self._package = package
 
 
     @property
     @property
-    def package(self) -> "Package":
+    def package(self) -> Package:
         return self._package
         return self._package
 
 
     @property
     @property

src/poetry/installation/operations/operation.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 from typing import TypeVar
 from typing import TypeVar
-from typing import Union
 
 
 
 
 if TYPE_CHECKING:
 if TYPE_CHECKING:
@@ -11,13 +11,11 @@ T = TypeVar("T", bound="Operation")
 
 
 
 
 class Operation:
 class Operation:
-    def __init__(
-        self, reason: Optional[str] = None, priority: Union[int, float] = 0
-    ) -> None:
+    def __init__(self, reason: str | None = None, priority: int | float = 0) -> None:
         self._reason = reason
         self._reason = reason
 
 
         self._skipped = False
         self._skipped = False
-        self._skip_reason: Optional[str] = None
+        self._skip_reason: str | None = None
         self._priority = priority
         self._priority = priority
 
 
     @property
     @property
@@ -25,7 +23,7 @@ class Operation:
         raise NotImplementedError
         raise NotImplementedError
 
 
     @property
     @property
-    def reason(self) -> Optional[str]:
+    def reason(self) -> str | None:
         return self._reason
         return self._reason
 
 
     @property
     @property
@@ -33,18 +31,18 @@ class Operation:
         return self._skipped
         return self._skipped
 
 
     @property
     @property
-    def skip_reason(self) -> Optional[str]:
+    def skip_reason(self) -> str | None:
         return self._skip_reason
         return self._skip_reason
 
 
     @property
     @property
-    def priority(self) -> Union[float, int]:
+    def priority(self) -> float | int:
         return self._priority
         return self._priority
 
 
     @property
     @property
-    def package(self) -> "Package":
+    def package(self) -> Package:
         raise NotImplementedError()
         raise NotImplementedError()
 
 
-    def format_version(self, package: "Package") -> str:
+    def format_version(self, package: Package) -> str:
         return package.full_pretty_version
         return package.full_pretty_version
 
 
     def skip(self: T, reason: str) -> T:
     def skip(self: T, reason: str) -> T:

src/poetry/installation/operations/uninstall.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
-from typing import Union
 
 
 from poetry.installation.operations.operation import Operation
 from poetry.installation.operations.operation import Operation
 
 
@@ -12,16 +12,16 @@ if TYPE_CHECKING:
 class Uninstall(Operation):
 class Uninstall(Operation):
     def __init__(
     def __init__(
         self,
         self,
-        package: "Package",
-        reason: Optional[str] = None,
-        priority: Union[float, int] = float("inf"),
+        package: Package,
+        reason: str | None = None,
+        priority: float | int = float("inf"),
     ) -> None:
     ) -> None:
         super().__init__(reason, priority=priority)
         super().__init__(reason, priority=priority)
 
 
         self._package = package
         self._package = package
 
 
     @property
     @property
-    def package(self) -> "Package":
+    def package(self) -> Package:
         return self._package
         return self._package
 
 
     @property
     @property

src/poetry/installation/operations/update.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 
 
 from poetry.installation.operations.operation import Operation
 from poetry.installation.operations.operation import Operation
 
 
@@ -11,9 +12,9 @@ if TYPE_CHECKING:
 class Update(Operation):
 class Update(Operation):
     def __init__(
     def __init__(
         self,
         self,
-        initial: "Package",
-        target: "Package",
-        reason: Optional[str] = None,
+        initial: Package,
+        target: Package,
+        reason: str | None = None,
         priority: int = 0,
         priority: int = 0,
     ) -> None:
     ) -> None:
         self._initial_package = initial
         self._initial_package = initial
@@ -22,15 +23,15 @@ class Update(Operation):
         super().__init__(reason, priority=priority)
         super().__init__(reason, priority=priority)
 
 
     @property
     @property
-    def initial_package(self) -> "Package":
+    def initial_package(self) -> Package:
         return self._initial_package
         return self._initial_package
 
 
     @property
     @property
-    def target_package(self) -> "Package":
+    def target_package(self) -> Package:
         return self._target_package
         return self._target_package
 
 
     @property
     @property
-    def package(self) -> "Package":
+    def package(self) -> Package:
         return self._target_package
         return self._target_package
 
 
     @property
     @property

src/poetry/installation/pip_installer.py

+from __future__ import annotations
+
 import os
 import os
 import tempfile
 import tempfile
 import urllib.parse
 import urllib.parse
@@ -6,7 +8,6 @@ from pathlib import Path
 from subprocess import CalledProcessError
 from subprocess import CalledProcessError
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
-from typing import Union
 
 
 from poetry.core.pyproject.toml import PyProjectTOML
 from poetry.core.pyproject.toml import PyProjectTOML
 
 
@@ -26,12 +27,12 @@ if TYPE_CHECKING:
 
 
 
 
 class PipInstaller(BaseInstaller):
 class PipInstaller(BaseInstaller):
-    def __init__(self, env: "Env", io: "IO", pool: "Pool") -> None:
+    def __init__(self, env: Env, io: IO, pool: Pool) -> None:
         self._env = env
         self._env = env
         self._io = io
         self._io = io
         self._pool = pool
         self._pool = pool
 
 
-    def install(self, package: "Package", update: bool = False) -> None:
+    def install(self, package: Package, update: bool = False) -> None:
         if package.source_type == "directory":
         if package.source_type == "directory":
             self.install_directory(package)
             self.install_directory(package)
 
 
@@ -101,7 +102,7 @@ class PipInstaller(BaseInstaller):
 
 
             self.run(*args)
             self.run(*args)
 
 
-    def update(self, package: "Package", target: "Package") -> None:
+    def update(self, package: Package, target: Package) -> None:
         if package.source_type != target.source_type:
         if package.source_type != target.source_type:
             # If the source type has changed, we remove the current
             # If the source type has changed, we remove the current
             # package to avoid perpetual updates in some cases
             # package to avoid perpetual updates in some cases
@@ -109,7 +110,7 @@ class PipInstaller(BaseInstaller):
 
 
         self.install(target, update=True)
         self.install(target, update=True)
 
 
-    def remove(self, package: "Package") -> None:
+    def remove(self, package: Package) -> None:
         try:
         try:
             self.run("uninstall", package.name, "-y")
             self.run("uninstall", package.name, "-y")
         except CalledProcessError as e:
         except CalledProcessError as e:
@@ -133,7 +134,7 @@ class PipInstaller(BaseInstaller):
     def run(self, *args: Any, **kwargs: Any) -> str:
     def run(self, *args: Any, **kwargs: Any) -> str:
         return self._env.run_pip(*args, **kwargs)
         return self._env.run_pip(*args, **kwargs)
 
 
-    def requirement(self, package: "Package", formatted: bool = False) -> str:
+    def requirement(self, package: Package, formatted: bool = False) -> str:
         if formatted and not package.source_type:
         if formatted and not package.source_type:
             req = f"{package.name}=={package.version}"
             req = f"{package.name}=={package.version}"
             for f in package.files:
             for f in package.files:
@@ -175,7 +176,7 @@ class PipInstaller(BaseInstaller):
 
 
         return f"{package.name}=={package.version}"
         return f"{package.name}=={package.version}"
 
 
-    def create_temporary_requirement(self, package: "Package") -> str:
+    def create_temporary_requirement(self, package: Package) -> str:
         fd, name = tempfile.mkstemp("reqs.txt", f"{package.name}-{package.version}")
         fd, name = tempfile.mkstemp("reqs.txt", f"{package.name}-{package.version}")
 
 
         try:
         try:
@@ -185,7 +186,7 @@ class PipInstaller(BaseInstaller):
 
 
         return name
         return name
 
 
-    def install_directory(self, package: "Package") -> Union[str, int]:
+    def install_directory(self, package: Package) -> str | int:
         from cleo.io.null_io import NullIO
         from cleo.io.null_io import NullIO
 
 
         from poetry.factory import Factory
         from poetry.factory import Factory
@@ -241,7 +242,7 @@ class PipInstaller(BaseInstaller):
             return pip_editable_install(directory=req, environment=self._env)
             return pip_editable_install(directory=req, environment=self._env)
         return pip_install(path=req, environment=self._env, deps=False, upgrade=True)
         return pip_install(path=req, environment=self._env, deps=False, upgrade=True)
 
 
-    def install_git(self, package: "Package") -> None:
+    def install_git(self, package: Package) -> None:
         from poetry.core.packages.package import Package
         from poetry.core.packages.package import Package
         from poetry.core.vcs.git import Git
         from poetry.core.vcs.git import Git
 
 

src/poetry/json/__init__.py

+from __future__ import annotations
+
 import json
 import json
 import os
 import os
 
 
-from typing import List
-
 import jsonschema
 import jsonschema
 
 
 
 
@@ -14,7 +14,7 @@ class ValidationError(ValueError):
     pass
     pass
 
 
 
 
-def validate_object(obj: dict, schema_name: str) -> List[str]:
+def validate_object(obj: dict, schema_name: str) -> list[str]:
     schema = os.path.join(SCHEMA_DIR, f"{schema_name}.json")
     schema = os.path.join(SCHEMA_DIR, f"{schema_name}.json")
 
 
     if not os.path.exists(schema):
     if not os.path.exists(schema):

src/poetry/layouts/__init__.py

-from typing import Type
+from __future__ import annotations
 
 
 from poetry.layouts.layout import Layout
 from poetry.layouts.layout import Layout
 from poetry.layouts.src import SrcLayout
 from poetry.layouts.src import SrcLayout
@@ -7,7 +7,7 @@ from poetry.layouts.src import SrcLayout
 _LAYOUTS = {"src": SrcLayout, "standard": Layout}
 _LAYOUTS = {"src": SrcLayout, "standard": Layout}
 
 
 
 
-def layout(name: str) -> Type[Layout]:
+def layout(name: str) -> type[Layout]:
     if name not in _LAYOUTS:
     if name not in _LAYOUTS:
         raise ValueError("Invalid layout")
         raise ValueError("Invalid layout")
 
 

src/poetry/layouts/layout.py

+from __future__ import annotations
+
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
-from typing import Optional
 
 
 from tomlkit import dumps
 from tomlkit import dumps
 from tomlkit import inline_table
 from tomlkit import inline_table
@@ -32,8 +32,8 @@ packages = []
 [tool.poetry.group.dev.dependencies]
 [tool.poetry.group.dev.dependencies]
 """
 """
 
 
-BUILD_SYSTEM_MIN_VERSION: Optional[str] = None
-BUILD_SYSTEM_MAX_VERSION: Optional[str] = None
+BUILD_SYSTEM_MIN_VERSION: str | None = None
+BUILD_SYSTEM_MAX_VERSION: str | None = None
 
 
 
 
 class Layout:
 class Layout:
@@ -45,11 +45,11 @@ class Layout:
         version: str = "0.1.0",
         version: str = "0.1.0",
         description: str = "",
         description: str = "",
         readme_format: str = "md",
         readme_format: str = "md",
-        author: Optional[str] = None,
-        license: Optional[str] = None,
+        author: str | None = None,
+        license: str | None = None,
         python: str = "*",
         python: str = "*",
-        dependencies: Optional[Dict[str, str]] = None,
-        dev_dependencies: Optional[Dict[str, str]] = None,
+        dependencies: dict[str, str] | None = None,
+        dev_dependencies: dict[str, str] | None = None,
     ):
     ):
         self._project = canonicalize_name(project).replace(".", "-")
         self._project = canonicalize_name(project).replace(".", "-")
         self._package_path_relative = Path(
         self._package_path_relative = Path(
@@ -85,7 +85,7 @@ class Layout:
     def package_path(self) -> Path:
     def package_path(self) -> Path:
         return self.basedir / self._package_path_relative
         return self.basedir / self._package_path_relative
 
 
-    def get_package_include(self) -> Optional["InlineTable"]:
+    def get_package_include(self) -> InlineTable | None:
         package = inline_table()
         package = inline_table()
 
 
         include = self._package_path_relative.parts[0]
         include = self._package_path_relative.parts[0]
@@ -112,9 +112,7 @@ class Layout:
 
 
         self._write_poetry(path)
         self._write_poetry(path)
 
 
-    def generate_poetry_content(
-        self, original: Optional["PyProjectTOML"] = None
-    ) -> str:
+    def generate_poetry_content(self, original: PyProjectTOML | None = None) -> str:
         template = POETRY_DEFAULT
         template = POETRY_DEFAULT
 
 
         content = loads(template)
         content = loads(template)

src/poetry/layouts/src.py

+from __future__ import annotations
+
 from pathlib import Path
 from pathlib import Path
 
 
 from poetry.layouts.layout import Layout
 from poetry.layouts.layout import Layout

src/poetry/locations.py

+from __future__ import annotations
+
 import os
 import os
 
 
 from pathlib import Path
 from pathlib import Path

src/poetry/masonry/api.py

+from __future__ import annotations
+
 from poetry.core.masonry.api import build_sdist
 from poetry.core.masonry.api import build_sdist
 from poetry.core.masonry.api import build_wheel
 from poetry.core.masonry.api import build_wheel
 from poetry.core.masonry.api import get_requires_for_build_sdist
 from poetry.core.masonry.api import get_requires_for_build_sdist

src/poetry/masonry/builders/__init__.py

+from __future__ import annotations
+
 from poetry.masonry.builders.editable import EditableBuilder
 from poetry.masonry.builders.editable import EditableBuilder

src/poetry/masonry/builders/editable.py

+from __future__ import annotations
+
 import hashlib
 import hashlib
 import os
 import os
 import shutil
 import shutil
@@ -5,7 +7,6 @@ import shutil
 from base64 import urlsafe_b64encode
 from base64 import urlsafe_b64encode
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
 
 
 from poetry.core.masonry.builders.builder import Builder
 from poetry.core.masonry.builders.builder import Builder
 from poetry.core.masonry.builders.sdist import SdistBuilder
 from poetry.core.masonry.builders.sdist import SdistBuilder
@@ -39,7 +40,7 @@ WINDOWS_CMD_TEMPLATE = """\
 
 
 
 
 class EditableBuilder(Builder):
 class EditableBuilder(Builder):
-    def __init__(self, poetry: "Poetry", env: "Env", io: "IO") -> None:
+    def __init__(self, poetry: Poetry, env: Env, io: IO) -> None:
         super().__init__(poetry)
         super().__init__(poetry)
 
 
         self._env = env
         self._env = env
@@ -109,7 +110,7 @@ class EditableBuilder(Builder):
             if not has_setup:
             if not has_setup:
                 os.remove(str(setup))
                 os.remove(str(setup))
 
 
-    def _add_pth(self) -> List[Path]:
+    def _add_pth(self) -> list[Path]:
         paths = {
         paths = {
             include.base.resolve().as_posix()
             include.base.resolve().as_posix()
             for include in self._module.includes
             for include in self._module.includes
@@ -147,7 +148,7 @@ class EditableBuilder(Builder):
             )
             )
             return []
             return []
 
 
-    def _add_scripts(self) -> List[Path]:
+    def _add_scripts(self) -> list[Path]:
         added = []
         added = []
         entry_points = self.convert_entry_points()
         entry_points = self.convert_entry_points()
 
 
@@ -202,7 +203,7 @@ class EditableBuilder(Builder):
 
 
         return added
         return added
 
 
-    def _add_dist_info(self, added_files: List[Path]) -> None:
+    def _add_dist_info(self, added_files: list[Path]) -> None:
         from poetry.core.masonry.builders.wheel import WheelBuilder
         from poetry.core.masonry.builders.wheel import WheelBuilder
 
 
         added_files = added_files[:]
         added_files = added_files[:]

src/poetry/mixology/__init__.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
-from typing import List
 
 
 from poetry.mixology.version_solver import VersionSolver
 from poetry.mixology.version_solver import VersionSolver
 
 
@@ -14,11 +14,11 @@ if TYPE_CHECKING:
 
 
 
 
 def resolve_version(
 def resolve_version(
-    root: "ProjectPackage",
-    provider: "Provider",
-    locked: Dict[str, "DependencyPackage"] = None,
-    use_latest: List[str] = None,
-) -> "SolverResult":
+    root: ProjectPackage,
+    provider: Provider,
+    locked: dict[str, DependencyPackage] = None,
+    use_latest: list[str] = None,
+) -> SolverResult:
     solver = VersionSolver(root, provider, locked=locked, use_latest=use_latest)
     solver = VersionSolver(root, provider, locked=locked, use_latest=use_latest)
 
 
     return solver.solve()
     return solver.solve()

src/poetry/mixology/assignment.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
-from typing import Optional
 
 
 from poetry.mixology.term import Term
 from poetry.mixology.term import Term
 
 
@@ -19,11 +20,11 @@ class Assignment(Term):
 
 
     def __init__(
     def __init__(
         self,
         self,
-        dependency: "Dependency",
+        dependency: Dependency,
         is_positive: bool,
         is_positive: bool,
         decision_level: int,
         decision_level: int,
         index: int,
         index: int,
-        cause: Optional["Incompatibility"] = None,
+        cause: Incompatibility | None = None,
     ) -> None:
     ) -> None:
         super().__init__(dependency, is_positive)
         super().__init__(dependency, is_positive)
 
 
@@ -40,13 +41,11 @@ class Assignment(Term):
         return self._index
         return self._index
 
 
     @property
     @property
-    def cause(self) -> "Incompatibility":
+    def cause(self) -> Incompatibility:
         return self._cause
         return self._cause
 
 
     @classmethod
     @classmethod
-    def decision(
-        cls, package: "Package", decision_level: int, index: int
-    ) -> "Assignment":
+    def decision(cls, package: Package, decision_level: int, index: int) -> Assignment:
         return cls(package.to_dependency(), True, decision_level, index)
         return cls(package.to_dependency(), True, decision_level, index)
 
 
     @classmethod
     @classmethod
@@ -54,10 +53,10 @@ class Assignment(Term):
         cls,
         cls,
         dependency: Any,
         dependency: Any,
         is_positive: bool,
         is_positive: bool,
-        cause: "Incompatibility",
+        cause: Incompatibility,
         decision_level: int,
         decision_level: int,
         index: int,
         index: int,
-    ) -> "Assignment":
+    ) -> Assignment:
         return cls(dependency, is_positive, decision_level, index, cause)
         return cls(dependency, is_positive, decision_level, index, cause)
 
 
     def is_decision(self) -> bool:
     def is_decision(self) -> bool:

src/poetry/mixology/failure.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
 
 
 from poetry.core.semver.helpers import parse_constraint
 from poetry.core.semver.helpers import parse_constraint
 
 
@@ -15,7 +13,7 @@ if TYPE_CHECKING:
 
 
 
 
 class SolveFailure(Exception):
 class SolveFailure(Exception):
-    def __init__(self, incompatibility: "Incompatibility") -> None:
+    def __init__(self, incompatibility: Incompatibility) -> None:
         self._incompatibility = incompatibility
         self._incompatibility = incompatibility
 
 
     @property
     @property
@@ -27,11 +25,11 @@ class SolveFailure(Exception):
 
 
 
 
 class _Writer:
 class _Writer:
-    def __init__(self, root: "Incompatibility") -> None:
+    def __init__(self, root: Incompatibility) -> None:
         self._root = root
         self._root = root
-        self._derivations: Dict["Incompatibility", int] = {}
-        self._lines: List[Tuple[str, Optional[int]]] = []
-        self._line_numbers: Dict["Incompatibility", int] = {}
+        self._derivations: dict[Incompatibility, int] = {}
+        self._lines: list[tuple[str, int | None]] = []
+        self._line_numbers: dict[Incompatibility, int] = {}
 
 
         self._count_derivations(self._root)
         self._count_derivations(self._root)
 
 
@@ -97,7 +95,7 @@ class _Writer:
         return "\n".join(buffer)
         return "\n".join(buffer)
 
 
     def _write(
     def _write(
-        self, incompatibility: "Incompatibility", message: str, numbered: bool = False
+        self, incompatibility: Incompatibility, message: str, numbered: bool = False
     ) -> None:
     ) -> None:
         if numbered:
         if numbered:
             number = len(self._line_numbers) + 1
             number = len(self._line_numbers) + 1
@@ -108,8 +106,8 @@ class _Writer:
 
 
     def _visit(
     def _visit(
         self,
         self,
-        incompatibility: "Incompatibility",
-        details_for_incompatibility: Dict,
+        incompatibility: Incompatibility,
+        details_for_incompatibility: dict,
         conclusion: bool = False,
         conclusion: bool = False,
     ) -> None:
     ) -> None:
         numbered = conclusion or self._derivations[incompatibility] > 1
         numbered = conclusion or self._derivations[incompatibility] > 1
@@ -237,7 +235,7 @@ class _Writer:
                 numbered=numbered,
                 numbered=numbered,
             )
             )
 
 
-    def _is_collapsible(self, incompatibility: "Incompatibility") -> bool:
+    def _is_collapsible(self, incompatibility: Incompatibility) -> bool:
         if self._derivations[incompatibility] > 1:
         if self._derivations[incompatibility] > 1:
             return False
             return False
 
 
@@ -265,7 +263,7 @@ class _Writer:
             cause.other.cause, ConflictCause
             cause.other.cause, ConflictCause
         )
         )
 
 
-    def _count_derivations(self, incompatibility: "Incompatibility") -> None:
+    def _count_derivations(self, incompatibility: Incompatibility) -> None:
         if incompatibility in self._derivations:
         if incompatibility in self._derivations:
             self._derivations[incompatibility] += 1
             self._derivations[incompatibility] += 1
         else:
         else:

src/poetry/mixology/incompatibility.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Callable
 from typing import Callable
-from typing import Dict
 from typing import Iterator
 from typing import Iterator
-from typing import List
-from typing import Optional
-from typing import Union
 
 
 from poetry.mixology.incompatibility_cause import ConflictCause
 from poetry.mixology.incompatibility_cause import ConflictCause
 from poetry.mixology.incompatibility_cause import DependencyCause
 from poetry.mixology.incompatibility_cause import DependencyCause
@@ -21,7 +19,7 @@ if TYPE_CHECKING:
 
 
 
 
 class Incompatibility:
 class Incompatibility:
-    def __init__(self, terms: List["Term"], cause: "IncompatibilityCause") -> None:
+    def __init__(self, terms: list[Term], cause: IncompatibilityCause) -> None:
         # Remove the root package from generated incompatibilities, since it will
         # Remove the root package from generated incompatibilities, since it will
         # always be satisfied. This makes error reporting clearer, and may also
         # always be satisfied. This makes error reporting clearer, and may also
         # make solving more efficient.
         # make solving more efficient.
@@ -43,7 +41,7 @@ class Incompatibility:
             or terms[0].dependency.complete_name == terms[-1].dependency.complete_name
             or terms[0].dependency.complete_name == terms[-1].dependency.complete_name
         ):
         ):
             # Coalesce multiple terms about the same package if possible.
             # Coalesce multiple terms about the same package if possible.
-            by_name: Dict[str, Dict[str, "Term"]] = {}
+            by_name: dict[str, dict[str, Term]] = {}
             for term in terms:
             for term in terms:
                 if term.dependency.complete_name not in by_name:
                 if term.dependency.complete_name not in by_name:
                     by_name[term.dependency.complete_name] = {}
                     by_name[term.dependency.complete_name] = {}
@@ -81,27 +79,27 @@ class Incompatibility:
         self._cause = cause
         self._cause = cause
 
 
     @property
     @property
-    def terms(self) -> List["Term"]:
+    def terms(self) -> list[Term]:
         return self._terms
         return self._terms
 
 
     @property
     @property
     def cause(
     def cause(
         self,
         self,
-    ) -> Union[
-        RootCause,
-        NoVersionsCause,
-        DependencyCause,
-        ConflictCause,
-        PythonCause,
-        PlatformCause,
-        PackageNotFoundCause,
-    ]:
+    ) -> (
+        RootCause
+        | NoVersionsCause
+        | DependencyCause
+        | ConflictCause
+        | PythonCause
+        | PlatformCause
+        | PackageNotFoundCause
+    ):
         return self._cause
         return self._cause
 
 
     @property
     @property
     def external_incompatibilities(
     def external_incompatibilities(
         self,
         self,
-    ) -> Iterator[Union[ConflictCause, "Incompatibility"]]:
+    ) -> Iterator[ConflictCause | Incompatibility]:
         """
         """
         Returns all external incompatibilities in this incompatibility's
         Returns all external incompatibilities in this incompatibility's
         derivation graph.
         derivation graph.
@@ -226,10 +224,10 @@ class Incompatibility:
 
 
     def and_to_string(
     def and_to_string(
         self,
         self,
-        other: "Incompatibility",
+        other: Incompatibility,
         details: dict,
         details: dict,
-        this_line: Optional[int],
-        other_line: Optional[int],
+        this_line: int | None,
+        other_line: int | None,
     ) -> str:
     ) -> str:
         requires_both = self._try_requires_both(other, details, this_line, other_line)
         requires_both = self._try_requires_both(other, details, this_line, other_line)
         if requires_both is not None:
         if requires_both is not None:
@@ -260,11 +258,11 @@ class Incompatibility:
 
 
     def _try_requires_both(
     def _try_requires_both(
         self,
         self,
-        other: "Incompatibility",
+        other: Incompatibility,
         details: dict,
         details: dict,
-        this_line: Optional[int],
-        other_line: Optional[int],
-    ) -> Optional[str]:
+        this_line: int | None,
+        other_line: int | None,
+    ) -> str | None:
         if len(self._terms) == 1 or len(other.terms) == 1:
         if len(self._terms) == 1 or len(other.terms) == 1:
             return None
             return None
 
 
@@ -309,8 +307,8 @@ class Incompatibility:
         return "".join(buffer)
         return "".join(buffer)
 
 
     def _try_requires_through(
     def _try_requires_through(
-        self, other: "Incompatibility", details: dict, this_line: int, other_line: int
-    ) -> Optional[str]:
+        self, other: Incompatibility, details: dict, this_line: int, other_line: int
+    ) -> str | None:
         if len(self._terms) == 1 or len(other.terms) == 1:
         if len(self._terms) == 1 or len(other.terms) == 1:
             return None
             return None
 
 
@@ -387,8 +385,8 @@ class Incompatibility:
         return "".join(buffer)
         return "".join(buffer)
 
 
     def _try_requires_forbidden(
     def _try_requires_forbidden(
-        self, other: "Incompatibility", details: dict, this_line: int, other_line: int
-    ) -> Optional[str]:
+        self, other: Incompatibility, details: dict, this_line: int, other_line: int
+    ) -> str | None:
         if len(self._terms) != 1 and len(other.terms) != 1:
         if len(self._terms) != 1 and len(other.terms) != 1:
             return None
             return None
 
 
@@ -442,7 +440,7 @@ class Incompatibility:
 
 
         return "".join(buffer)
         return "".join(buffer)
 
 
-    def _terse(self, term: "Term", allow_every: bool = False) -> str:
+    def _terse(self, term: Term, allow_every: bool = False) -> str:
         if allow_every and term.constraint.is_any():
         if allow_every and term.constraint.is_any():
             return f"every version of {term.dependency.complete_name}"
             return f"every version of {term.dependency.complete_name}"
 
 
@@ -451,9 +449,7 @@ class Incompatibility:
 
 
         return f"{term.dependency.pretty_name} ({term.dependency.pretty_constraint})"
         return f"{term.dependency.pretty_name} ({term.dependency.pretty_constraint})"
 
 
-    def _single_term_where(
-        self, callable: Callable[["Term"], bool]
-    ) -> Optional["Term"]:
+    def _single_term_where(self, callable: Callable[[Term], bool]) -> Term | None:
         found = None
         found = None
         for term in self._terms:
         for term in self._terms:
             if not callable(term):
             if not callable(term):

src/poetry/mixology/incompatibility_cause.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 
 
@@ -32,16 +34,16 @@ class ConflictCause(IncompatibilityCause):
     during conflict resolution.
     during conflict resolution.
     """
     """
 
 
-    def __init__(self, conflict: "Incompatibility", other: "Incompatibility") -> None:
+    def __init__(self, conflict: Incompatibility, other: Incompatibility) -> None:
         self._conflict = conflict
         self._conflict = conflict
         self._other = other
         self._other = other
 
 
     @property
     @property
-    def conflict(self) -> "Incompatibility":
+    def conflict(self) -> Incompatibility:
         return self._conflict
         return self._conflict
 
 
     @property
     @property
-    def other(self) -> "Incompatibility":
+    def other(self) -> Incompatibility:
         return self._other
         return self._other
 
 
     def __str__(self) -> str:
     def __str__(self) -> str:

src/poetry/mixology/partial_solution.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
-from typing import List
 
 
 from poetry.mixology.assignment import Assignment
 from poetry.mixology.assignment import Assignment
 from poetry.mixology.set_relation import SetRelation
 from poetry.mixology.set_relation import SetRelation
@@ -27,16 +27,16 @@ class PartialSolution:
     def __init__(self) -> None:
     def __init__(self) -> None:
         # The assignments that have been made so far, in the order they were
         # The assignments that have been made so far, in the order they were
         # assigned.
         # assigned.
-        self._assignments: List[Assignment] = []
+        self._assignments: list[Assignment] = []
 
 
         # The decisions made for each package.
         # The decisions made for each package.
-        self._decisions: Dict[str, "Package"] = {}
+        self._decisions: dict[str, Package] = {}
 
 
         # The intersection of all positive Assignments for each package, minus any
         # The intersection of all positive Assignments for each package, minus any
         # negative Assignments that refer to that package.
         # negative Assignments that refer to that package.
         #
         #
         # This is derived from self._assignments.
         # This is derived from self._assignments.
-        self._positive: Dict[str, "Term"] = {}
+        self._positive: dict[str, Term] = {}
 
 
         # The union of all negative Assignments for each package.
         # The union of all negative Assignments for each package.
         #
         #
@@ -44,7 +44,7 @@ class PartialSolution:
         # map.
         # map.
         #
         #
         # This is derived from self._assignments.
         # This is derived from self._assignments.
-        self._negative: Dict[str, Dict[str, "Term"]] = {}
+        self._negative: dict[str, dict[str, Term]] = {}
 
 
         # The number of distinct solutions that have been attempted so far.
         # The number of distinct solutions that have been attempted so far.
         self._attempted_solutions = 1
         self._attempted_solutions = 1
@@ -53,7 +53,7 @@ class PartialSolution:
         self._backtracking = False
         self._backtracking = False
 
 
     @property
     @property
-    def decisions(self) -> List["Package"]:
+    def decisions(self) -> list[Package]:
         return list(self._decisions.values())
         return list(self._decisions.values())
 
 
     @property
     @property
@@ -65,14 +65,14 @@ class PartialSolution:
         return self._attempted_solutions
         return self._attempted_solutions
 
 
     @property
     @property
-    def unsatisfied(self) -> List["Dependency"]:
+    def unsatisfied(self) -> list[Dependency]:
         return [
         return [
             term.dependency
             term.dependency
             for term in self._positive.values()
             for term in self._positive.values()
             if term.dependency.complete_name not in self._decisions
             if term.dependency.complete_name not in self._decisions
         ]
         ]
 
 
-    def decide(self, package: "Package") -> None:
+    def decide(self, package: Package) -> None:
         """
         """
         Adds an assignment of package as a decision
         Adds an assignment of package as a decision
         and increments the decision level.
         and increments the decision level.
@@ -92,7 +92,7 @@ class PartialSolution:
         )
         )
 
 
     def derive(
     def derive(
-        self, dependency: "Dependency", is_positive: bool, cause: "Incompatibility"
+        self, dependency: Dependency, is_positive: bool, cause: Incompatibility
     ) -> None:
     ) -> None:
         """
         """
         Adds an assignment of package as a derivation.
         Adds an assignment of package as a derivation.
@@ -170,7 +170,7 @@ class PartialSolution:
 
 
             self._negative[name][ref] = term
             self._negative[name][ref] = term
 
 
-    def satisfier(self, term: "Term") -> Assignment:
+    def satisfier(self, term: Term) -> Assignment:
         """
         """
         Returns the first Assignment in this solution such that the sublist of
         Returns the first Assignment in this solution such that the sublist of
         assignments up to and including that entry collectively satisfies term.
         assignments up to and including that entry collectively satisfies term.
@@ -203,10 +203,10 @@ class PartialSolution:
 
 
         raise RuntimeError(f"[BUG] {term} is not satisfied.")
         raise RuntimeError(f"[BUG] {term} is not satisfied.")
 
 
-    def satisfies(self, term: "Term") -> bool:
+    def satisfies(self, term: Term) -> bool:
         return self.relation(term) == SetRelation.SUBSET
         return self.relation(term) == SetRelation.SUBSET
 
 
-    def relation(self, term: "Term") -> int:
+    def relation(self, term: Term) -> int:
         positive = self._positive.get(term.dependency.complete_name)
         positive = self._positive.get(term.dependency.complete_name)
         if positive is not None:
         if positive is not None:
             return positive.relation(term)
             return positive.relation(term)

src/poetry/mixology/result.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
 
 
 
 
 if TYPE_CHECKING:
 if TYPE_CHECKING:
@@ -10,8 +11,8 @@ if TYPE_CHECKING:
 class SolverResult:
 class SolverResult:
     def __init__(
     def __init__(
         self,
         self,
-        root: "ProjectPackage",
-        packages: List["Package"],
+        root: ProjectPackage,
+        packages: list[Package],
         attempted_solutions: int,
         attempted_solutions: int,
     ) -> None:
     ) -> None:
         self._root = root
         self._root = root
@@ -19,7 +20,7 @@ class SolverResult:
         self._attempted_solutions = attempted_solutions
         self._attempted_solutions = attempted_solutions
 
 
     @property
     @property
-    def packages(self) -> List["Package"]:
+    def packages(self) -> list[Package]:
         return self._packages
         return self._packages
 
 
     @property
     @property

src/poetry/mixology/set_relation.py

+from __future__ import annotations
+
+
 class SetRelation:
 class SetRelation:
     """
     """
     An enum of possible relationships between two sets.
     An enum of possible relationships between two sets.

src/poetry/mixology/solutions/providers/__init__.py

+from __future__ import annotations
+
 from poetry.mixology.solutions.providers.python_requirement_solution_provider import (
 from poetry.mixology.solutions.providers.python_requirement_solution_provider import (
     PythonRequirementSolutionProvider,
     PythonRequirementSolutionProvider,
 )
 )

src/poetry/mixology/solutions/providers/python_requirement_solution_provider.py

+from __future__ import annotations
+
 import re
 import re
 
 
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
 
 
 from crashtest.contracts.has_solutions_for_exception import HasSolutionsForException
 from crashtest.contracts.has_solutions_for_exception import HasSolutionsForException
 
 
@@ -25,7 +26,7 @@ class PythonRequirementSolutionProvider(HasSolutionsForException):
 
 
         return bool(m)
         return bool(m)
 
 
-    def get_solutions(self, exception: Exception) -> List["Solution"]:
+    def get_solutions(self, exception: Exception) -> list[Solution]:
         from poetry.mixology.solutions.solutions.python_requirement_solution import (
         from poetry.mixology.solutions.solutions.python_requirement_solution import (
             PythonRequirementSolution,
             PythonRequirementSolution,
         )
         )

src/poetry/mixology/solutions/solutions/__init__.py

+from __future__ import annotations
+
 from poetry.mixology.solutions.solutions.python_requirement_solution import (
 from poetry.mixology.solutions.solutions.python_requirement_solution import (
     PythonRequirementSolution,
     PythonRequirementSolution,
 )
 )

src/poetry/mixology/solutions/solutions/python_requirement_solution.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
 
 
 from crashtest.contracts.solution import Solution
 from crashtest.contracts.solution import Solution
 
 
@@ -9,7 +10,7 @@ if TYPE_CHECKING:
 
 
 
 
 class PythonRequirementSolution(Solution):
 class PythonRequirementSolution(Solution):
-    def __init__(self, exception: "PackageNotFoundCause") -> None:
+    def __init__(self, exception: PackageNotFoundCause) -> None:
         from poetry.core.semver.helpers import parse_constraint
         from poetry.core.semver.helpers import parse_constraint
 
 
         from poetry.mixology.incompatibility_cause import PythonCause
         from poetry.mixology.incompatibility_cause import PythonCause
@@ -54,7 +55,7 @@ class PythonRequirementSolution(Solution):
         return self._description
         return self._description
 
 
     @property
     @property
-    def documentation_links(self) -> List[str]:
+    def documentation_links(self) -> list[str]:
         return [
         return [
             "https://python-poetry.org/docs/dependency-specification/#python-restricted-dependencies",  # noqa: E501
             "https://python-poetry.org/docs/dependency-specification/#python-restricted-dependencies",  # noqa: E501
             "https://python-poetry.org/docs/dependency-specification/#using-environment-markers",  # noqa: E501
             "https://python-poetry.org/docs/dependency-specification/#using-environment-markers",  # noqa: E501

src/poetry/mixology/term.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
 
 
 from poetry.mixology.set_relation import SetRelation
 from poetry.mixology.set_relation import SetRelation
 
 
@@ -17,26 +18,26 @@ class Term:
     See https://github.com/dart-lang/pub/tree/master/doc/solver.md#term.
     See https://github.com/dart-lang/pub/tree/master/doc/solver.md#term.
     """
     """
 
 
-    def __init__(self, dependency: "Dependency", is_positive: bool) -> None:
+    def __init__(self, dependency: Dependency, is_positive: bool) -> None:
         self._dependency = dependency
         self._dependency = dependency
         self._positive = is_positive
         self._positive = is_positive
 
 
     @property
     @property
-    def inverse(self) -> "Term":
+    def inverse(self) -> Term:
         return Term(self._dependency, not self.is_positive())
         return Term(self._dependency, not self.is_positive())
 
 
     @property
     @property
-    def dependency(self) -> "Dependency":
+    def dependency(self) -> Dependency:
         return self._dependency
         return self._dependency
 
 
     @property
     @property
-    def constraint(self) -> "VersionTypes":
+    def constraint(self) -> VersionTypes:
         return self._dependency.constraint
         return self._dependency.constraint
 
 
     def is_positive(self) -> bool:
     def is_positive(self) -> bool:
         return self._positive
         return self._positive
 
 
-    def satisfies(self, other: "Term") -> bool:
+    def satisfies(self, other: Term) -> bool:
         """
         """
         Returns whether this term satisfies another.
         Returns whether this term satisfies another.
         """
         """
@@ -45,7 +46,7 @@ class Term:
             and self.relation(other) == SetRelation.SUBSET
             and self.relation(other) == SetRelation.SUBSET
         )
         )
 
 
-    def relation(self, other: "Term") -> int:
+    def relation(self, other: Term) -> int:
         """
         """
         Returns the relationship between the package versions
         Returns the relationship between the package versions
         allowed by this term and another.
         allowed by this term and another.
@@ -107,7 +108,7 @@ class Term:
                 # not foo ^1.5.0 is a superset of not foo ^1.0.0
                 # not foo ^1.5.0 is a superset of not foo ^1.0.0
                 return SetRelation.OVERLAPPING
                 return SetRelation.OVERLAPPING
 
 
-    def intersect(self, other: "Term") -> Optional["Term"]:
+    def intersect(self, other: Term) -> Term | None:
         """
         """
         Returns a Term that represents the packages
         Returns a Term that represents the packages
         allowed by both this term and another
         allowed by both this term and another
@@ -139,14 +140,14 @@ class Term:
         else:
         else:
             return None
             return None
 
 
-    def difference(self, other: "Term") -> "Term":
+    def difference(self, other: Term) -> Term:
         """
         """
         Returns a Term that represents packages
         Returns a Term that represents packages
         allowed by this term and not by the other
         allowed by this term and not by the other
         """
         """
         return self.intersect(other.inverse)
         return self.intersect(other.inverse)
 
 
-    def _compatible_dependency(self, other: "Dependency") -> bool:
+    def _compatible_dependency(self, other: Dependency) -> bool:
         return (
         return (
             self.dependency.is_root
             self.dependency.is_root
             or other.is_root
             or other.is_root
@@ -154,8 +155,8 @@ class Term:
         )
         )
 
 
     def _non_empty_term(
     def _non_empty_term(
-        self, constraint: "VersionTypes", is_positive: bool
-    ) -> Optional["Term"]:
+        self, constraint: VersionTypes, is_positive: bool
+    ) -> Term | None:
         if constraint.is_empty():
         if constraint.is_empty():
             return None
             return None
 
 

src/poetry/mixology/version_solver.py

+from __future__ import annotations
+
 import time
 import time
 
 
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
-from typing import Union
 
 
 from poetry.core.packages.dependency import Dependency
 from poetry.core.packages.dependency import Dependency
 
 
@@ -42,10 +39,10 @@ class VersionSolver:
 
 
     def __init__(
     def __init__(
         self,
         self,
-        root: "ProjectPackage",
-        provider: "Provider",
-        locked: Dict[str, "Package"] = None,
-        use_latest: List[str] = None,
+        root: ProjectPackage,
+        provider: Provider,
+        locked: dict[str, Package] = None,
+        use_latest: list[str] = None,
     ):
     ):
         self._root = root
         self._root = root
         self._provider = provider
         self._provider = provider
@@ -56,7 +53,7 @@ class VersionSolver:
 
 
         self._use_latest = use_latest
         self._use_latest = use_latest
 
 
-        self._incompatibilities: Dict[str, List[Incompatibility]] = {}
+        self._incompatibilities: dict[str, list[Incompatibility]] = {}
         self._solution = PartialSolution()
         self._solution = PartialSolution()
 
 
     @property
     @property
@@ -128,7 +125,7 @@ class VersionSolver:
 
 
     def _propagate_incompatibility(
     def _propagate_incompatibility(
         self, incompatibility: Incompatibility
         self, incompatibility: Incompatibility
-    ) -> Union[str, object, None]:
+    ) -> str | object | None:
         """
         """
         If incompatibility is almost satisfied by _solution, adds the
         If incompatibility is almost satisfied by _solution, adds the
         negation of the unsatisfied term to _solution.
         negation of the unsatisfied term to _solution.
@@ -307,7 +304,7 @@ class VersionSolver:
 
 
         raise SolveFailure(incompatibility)
         raise SolveFailure(incompatibility)
 
 
-    def _choose_package_version(self) -> Optional[str]:
+    def _choose_package_version(self) -> str | None:
         """
         """
         Tries to select a version of a required package.
         Tries to select a version of a required package.
 
 
@@ -321,7 +318,7 @@ class VersionSolver:
 
 
         # Prefer packages with as few remaining versions as possible,
         # Prefer packages with as few remaining versions as possible,
         # so that if a conflict is necessary it's forced quickly.
         # so that if a conflict is necessary it's forced quickly.
-        def _get_min(dependency: Dependency) -> Tuple[bool, int]:
+        def _get_min(dependency: Dependency) -> tuple[bool, int]:
             if dependency.name in self._use_latest:
             if dependency.name in self._use_latest:
                 # If we're forced to use the latest version of a package, it effectively
                 # If we're forced to use the latest version of a package, it effectively
                 # only has one version to choose from.
                 # only has one version to choose from.
@@ -438,7 +435,7 @@ class VersionSolver:
                 incompatibility
                 incompatibility
             )
             )
 
 
-    def _get_locked(self, dependency: Dependency) -> Optional["Package"]:
+    def _get_locked(self, dependency: Dependency) -> Package | None:
         if dependency.name in self._use_latest:
         if dependency.name in self._use_latest:
             return None
             return None
 
 

src/poetry/packages/__init__.py

+from __future__ import annotations
+
 from poetry.packages.dependency_package import DependencyPackage
 from poetry.packages.dependency_package import DependencyPackage
 from poetry.packages.locker import Locker
 from poetry.packages.locker import Locker
 from poetry.packages.package_collection import PackageCollection
 from poetry.packages.package_collection import PackageCollection

src/poetry/packages/dependency_package.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Any
-from typing import List
-from typing import Union
 
 
 
 
 if TYPE_CHECKING:
 if TYPE_CHECKING:
@@ -10,25 +10,25 @@ if TYPE_CHECKING:
 
 
 
 
 class DependencyPackage:
 class DependencyPackage:
-    def __init__(self, dependency: "Dependency", package: "Package") -> None:
+    def __init__(self, dependency: Dependency, package: Package) -> None:
         self._dependency = dependency
         self._dependency = dependency
         self._package = package
         self._package = package
 
 
     @property
     @property
-    def dependency(self) -> "Dependency":
+    def dependency(self) -> Dependency:
         return self._dependency
         return self._dependency
 
 
     @property
     @property
-    def package(self) -> "Package":
+    def package(self) -> Package:
         return self._package
         return self._package
 
 
-    def clone(self) -> "DependencyPackage":
+    def clone(self) -> DependencyPackage:
         return self.__class__(self._dependency, self._package.clone())
         return self.__class__(self._dependency, self._package.clone())
 
 
-    def with_features(self, features: List[str]) -> "DependencyPackage":
+    def with_features(self, features: list[str]) -> DependencyPackage:
         return self.__class__(self._dependency, self._package.with_features(features))
         return self.__class__(self._dependency, self._package.with_features(features))
 
 
-    def without_features(self) -> "DependencyPackage":
+    def without_features(self) -> DependencyPackage:
         return self.with_features([])
         return self.with_features([])
 
 
     def __getattr__(self, name: str) -> Any:
     def __getattr__(self, name: str) -> Any:
@@ -49,7 +49,7 @@ class DependencyPackage:
     def __hash__(self) -> int:
     def __hash__(self) -> int:
         return hash(self._package)
         return hash(self._package)
 
 
-    def __eq__(self, other: Union["Package", "DependencyPackage"]) -> bool:
+    def __eq__(self, other: Package | DependencyPackage) -> bool:
         if isinstance(other, DependencyPackage):
         if isinstance(other, DependencyPackage):
             other = other.package
             other = other.package
 
 

src/poetry/packages/locker.py

+from __future__ import annotations
+
 import json
 import json
 import logging
 import logging
 import os
 import os
@@ -7,15 +9,9 @@ from copy import deepcopy
 from hashlib import sha256
 from hashlib import sha256
 from pathlib import Path
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Dict
 from typing import Iterable
 from typing import Iterable
 from typing import Iterator
 from typing import Iterator
-from typing import List
-from typing import Optional
 from typing import Sequence
 from typing import Sequence
-from typing import Set
-from typing import Tuple
-from typing import Union
 
 
 from poetry.core.packages.dependency import Dependency
 from poetry.core.packages.dependency import Dependency
 from poetry.core.packages.package import Package
 from poetry.core.packages.package import Package
@@ -49,7 +45,7 @@ class Locker:
 
 
     _relevant_keys = ["dependencies", "group", "source", "extras"]
     _relevant_keys = ["dependencies", "group", "source", "extras"]
 
 
-    def __init__(self, lock: Union[str, Path], local_config: dict) -> None:
+    def __init__(self, lock: str | Path, local_config: dict) -> None:
         self._lock = TOMLFile(lock)
         self._lock = TOMLFile(lock)
         self._local_config = local_config
         self._local_config = local_config
         self._lock_data = None
         self._lock_data = None
@@ -60,7 +56,7 @@ class Locker:
         return self._lock
         return self._lock
 
 
     @property
     @property
-    def lock_data(self) -> "TOMLDocument":
+    def lock_data(self) -> TOMLDocument:
         if self._lock_data is None:
         if self._lock_data is None:
             self._lock_data = self._get_lock_data()
             self._lock_data = self._get_lock_data()
 
 
@@ -87,7 +83,7 @@ class Locker:
 
 
         return False
         return False
 
 
-    def locked_repository(self, with_dev_reqs: bool = False) -> "Repository":
+    def locked_repository(self, with_dev_reqs: bool = False) -> Repository:
         """
         """
         Searches and returns a repository of locked packages.
         Searches and returns a repository of locked packages.
         """
         """
@@ -204,8 +200,8 @@ class Locker:
 
 
     @staticmethod
     @staticmethod
     def __get_locked_package(
     def __get_locked_package(
-        _dependency: Dependency, packages_by_name: Dict[str, List[Package]]
-    ) -> Optional[Package]:
+        _dependency: Dependency, packages_by_name: dict[str, list[Package]]
+    ) -> Package | None:
         """
         """
         Internal helper to identify corresponding locked package using dependency
         Internal helper to identify corresponding locked package using dependency
         version constraints.
         version constraints.
@@ -218,13 +214,13 @@ class Locker:
     @classmethod
     @classmethod
     def __walk_dependency_level(
     def __walk_dependency_level(
         cls,
         cls,
-        dependencies: List[Dependency],
+        dependencies: list[Dependency],
         level: int,
         level: int,
         pinned_versions: bool,
         pinned_versions: bool,
-        packages_by_name: Dict[str, List[Package]],
-        project_level_dependencies: Set[str],
-        nested_dependencies: Dict[Tuple[str, str], Dependency],
-    ) -> Dict[Tuple[str, str], Dependency]:
+        packages_by_name: dict[str, list[Package]],
+        project_level_dependencies: set[str],
+        nested_dependencies: dict[tuple[str, str], Dependency],
+    ) -> dict[tuple[str, str], Dependency]:
         if not dependencies:
         if not dependencies:
             return nested_dependencies
             return nested_dependencies
 
 
@@ -286,8 +282,8 @@ class Locker:
     @classmethod
     @classmethod
     def get_project_dependencies(
     def get_project_dependencies(
         cls,
         cls,
-        project_requires: List[Dependency],
-        locked_packages: List[Package],
+        project_requires: list[Dependency],
+        locked_packages: list[Package],
         pinned_versions: bool = False,
         pinned_versions: bool = False,
         with_nested: bool = False,
         with_nested: bool = False,
     ) -> Iterable[Dependency]:
     ) -> Iterable[Dependency]:
@@ -346,9 +342,9 @@ class Locker:
 
 
     def get_project_dependency_packages(
     def get_project_dependency_packages(
         self,
         self,
-        project_requires: List[Dependency],
+        project_requires: list[Dependency],
         dev: bool = False,
         dev: bool = False,
-        extras: Optional[Union[bool, Sequence[str]]] = None,
+        extras: bool | Sequence[str] | None = None,
     ) -> Iterator[DependencyPackage]:
     ) -> Iterator[DependencyPackage]:
         repository = self.locked_repository(with_dev_reqs=dev)
         repository = self.locked_repository(with_dev_reqs=dev)
 
 
@@ -397,7 +393,7 @@ class Locker:
 
 
             yield DependencyPackage(dependency=dependency, package=package)
             yield DependencyPackage(dependency=dependency, package=package)
 
 
-    def set_lock_data(self, root: Package, packages: List[Package]) -> bool:
+    def set_lock_data(self, root: Package, packages: list[Package]) -> bool:
         files = table()
         files = table()
         packages = self._lock_packages(packages)
         packages = self._lock_packages(packages)
         # Retrieving hashes
         # Retrieving hashes
@@ -440,7 +436,7 @@ class Locker:
 
 
         return False
         return False
 
 
-    def _write_lock_data(self, data: "TOMLDocument") -> None:
+    def _write_lock_data(self, data: TOMLDocument) -> None:
         self.lock.write(data)
         self.lock.write(data)
 
 
         # Checking lock file data consistency
         # Checking lock file data consistency
@@ -465,7 +461,7 @@ class Locker:
 
 
         return content_hash
         return content_hash
 
 
-    def _get_lock_data(self) -> "TOMLDocument":
+    def _get_lock_data(self) -> TOMLDocument:
         if not self._lock.exists():
         if not self._lock.exists():
             raise RuntimeError("No lockfile found. Unable to read locked packages")
             raise RuntimeError("No lockfile found. Unable to read locked packages")
 
 
@@ -498,7 +494,7 @@ class Locker:
 
 
         return lock_data
         return lock_data
 
 
-    def _lock_packages(self, packages: List[Package]) -> list:
+    def _lock_packages(self, packages: list[Package]) -> list:
         locked = []
         locked = []
 
 
         for package in sorted(packages, key=lambda x: x.name):
         for package in sorted(packages, key=lambda x: x.name):
@@ -619,5 +615,5 @@ class Locker:
 
 
 
 
 class NullLocker(Locker):
 class NullLocker(Locker):
-    def set_lock_data(self, root: Package, packages: List[Package]) -> bool:
+    def set_lock_data(self, root: Package, packages: list[Package]) -> bool:
         pass
         pass

src/poetry/packages/package_collection.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import List
-from typing import Union
 
 
 from poetry.packages.dependency_package import DependencyPackage
 from poetry.packages.dependency_package import DependencyPackage
 
 
@@ -13,8 +13,8 @@ if TYPE_CHECKING:
 class PackageCollection(list):
 class PackageCollection(list):
     def __init__(
     def __init__(
         self,
         self,
-        dependency: "Dependency",
-        packages: List[Union["Package", DependencyPackage]] = None,
+        dependency: Dependency,
+        packages: list[Package | DependencyPackage] = None,
     ) -> None:
     ) -> None:
         self._dependency = dependency
         self._dependency = dependency
 
 
@@ -26,7 +26,7 @@ class PackageCollection(list):
         for package in packages:
         for package in packages:
             self.append(package)
             self.append(package)
 
 
-    def append(self, package: Union["Package", DependencyPackage]) -> None:
+    def append(self, package: Package | DependencyPackage) -> None:
         if isinstance(package, DependencyPackage):
         if isinstance(package, DependencyPackage):
             package = package.package
             package = package.package
 
 

src/poetry/packages/project_package.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
-from typing import Optional
-from typing import Union
 
 
 from poetry.core.packages.project_package import ProjectPackage as _ProjectPackage
 from poetry.core.packages.project_package import ProjectPackage as _ProjectPackage
 
 
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
 
 class ProjectPackage(_ProjectPackage):
 class ProjectPackage(_ProjectPackage):
     def set_version(
     def set_version(
-        self, version: Union[str, "Version"], pretty_version: Optional[str] = None
+        self, version: str | Version, pretty_version: str | None = None
     ) -> None:
     ) -> None:
         from poetry.core.semver.version import Version
         from poetry.core.semver.version import Version
 
 

src/poetry/plugins/__init__.py

+from __future__ import annotations
+
 from poetry.plugins.application_plugin import ApplicationPlugin
 from poetry.plugins.application_plugin import ApplicationPlugin
 from poetry.plugins.plugin import Plugin
 from poetry.plugins.plugin import Plugin
 
 

src/poetry/plugins/application_plugin.py

+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 from typing import TYPE_CHECKING
 
 
 from poetry.plugins.base_plugin import BasePlugin
 from poetry.plugins.base_plugin import BasePlugin
@@ -14,5 +16,5 @@ class ApplicationPlugin(BasePlugin):
 
 
     type = "application.plugin"
     type = "application.plugin"
 
 
-    def activate(self, application: "Application") -> None:
+    def activate(self, application: Application) -> None:
         raise NotImplementedError()
         raise NotImplementedError()