Merge branch 'main' into Chakradhar886-patch-1

Author: Chakradhar886

.github/chronus/package-lock.json

@@ -0,0 +1,9 @@
+{
+  "name": "azure-sdk-for-python-changelog-tools",
+  "private": true,
+  "description": "Pinned Node dev dependencies used by 'azpysdk changelog' (Chronus).",
+  "devDependencies": {
+    "@chronus/chronus": "1.3.1",
+    "@chronus/github": "1.0.6"
+  }
+}

.github/chronus/package.json

@@ -79,7 +79,7 @@ jobs:
 
       - name: Install azure-sdk-tools on in global uv, discover azpysdk checks
         run: |
-          uv pip install --system eng/tools/azure-sdk-tools[ghtools,conda,systemperf]
+          uv pip install --system -e eng/tools/azure-sdk-tools[ghtools,conda,systemperf]
 
           # Discover available azpysdk commands from the {command1,command2,...} line in help output
           CHECKS=$(azpysdk -h 2>&1 | \
@@ -88,6 +88,7 @@ jobs:
             tr -d '{}' | \
             tr ',' '\n' | \
             grep -v '^next-' | \
+            grep -v '^changelog$' | \
             sort | \
             paste -sd,)
 

.github/workflows/azure-sdk-tools.yml

@@ -0,0 +1,19 @@
+{
+  "mcpServers": {
+    "azure-sdk-mcp": {
+      "type": "stdio",
+      "command": "pwsh",
+      "args": [
+        "./eng/common/mcp/azure-sdk-mcp.ps1",
+        "-Run"
+      ]
+    },
+    "github-agentic-workflows": {
+      "command": "gh",
+      "args": [
+        "aw",
+        "mcp-server"
+      ]
+    }
+  }
+}

.mcp.json

@@ -495,6 +495,7 @@
     "vnet",
     "volcz",
     "vsts",
+    "waza",
     "wchar",
     "wesh",
     "westcentralus",

.vscode/cspell.json

@@ -130,30 +130,46 @@ Almost anything can be used as a type in annotations.
    or [collections.abc](https://docs.python.org/3/library/collections.abc.html), or external packages
 3) Types from the [typing](https://docs.python.org/3/library/typing.html)
    or [typing_extensions](https://github.com/python/typing_extensions) modules
-4) Built-in generic types, like `list` or `dict`*.
-   > *Note: Supported in Python 3.9+. For <3.9, You must include `from __future__ import annotations` import to be able to pass in generic `list[str]` as a type hint rather than `typing.List[str]`.
+4) Built-in generic types, like `list` or `dict`.
 
-Here are a few considerations and notes on Python version support:
+Here are a few considerations and notes on Python version support. The Azure SDK for Python supports Python 3.10 and higher, so the examples in this guide assume Python 3.10 as the baseline.
 
 - With [PEP585](https://peps.python.org/pep-0585/) and [PEP563](https://peps.python.org/pep-0563/), importing certain
   generic collection types from `typing` has been [deprecated](https://peps.python.org/pep-0585/#implementation) in
   favor for using the types in `collections.abc` or generic collection type hints (like `list`) from the standard library.
-  If you'd like to use types from `collections.abc`, you can check the Python version at runtime (`collections.abc` types did not have [] notation / indexing support added until 3.9).
+  Since Python 3.10 is the minimum supported version, you can import directly from `collections.abc` and use `[]` indexing without a version check:
 
 ```python
-import sys
+from collections.abc import Sequence
+```
+
+- The `typing-extensions` library backports types that are introduced only in later versions of Python so that they can be used in earlier Python versions. Since the Azure SDK for Python supports Python 3.10 and higher, most commonly used typing constructs (e.g. `Protocol`, `Literal`, `TypedDict`, `Final`, `runtime_checkable`, `TypeAlias`, `ParamSpec`, `Concatenate`) are available directly from `typing` and do not need `typing-extensions`.
 
-if sys.version_info < (3, 9):
-    from typing import Sequence
-else:
-    from collections.abc import Sequence
+```python
+from typing import Protocol
 ```
 
-- The `typing-extensions` library backports types that are introduced only in later versions of Python (e.g. `Protocol`
-  which was introduced in Python 3.8) so that they can be used in earlier Python versions.
+  Features added after 3.10 still require `typing-extensions` on the Python 3.10 baseline, including:
+
+  - `Self` (3.11)
+  - `LiteralString` (3.11)
+  - `Required` / `NotRequired` for `TypedDict` (3.11)
+  - Generic `TypedDict` (3.11)
+  - `Never` / `assert_never` / `assert_type` / `reveal_type` (3.11)
+  - `TypeVarTuple` / `Unpack` (3.11)
+  - `dataclass_transform` (3.11)
+  - `@override` (3.12)
+  - PEP 695 `type` statement / `TypeAliasType` (3.12)
+  - `ReadOnly` for `TypedDict` (3.13)
 
 ```python
-from typing_extensions import Protocol
+# Self was added to typing in 3.11, so import from typing_extensions on 3.10
+from typing_extensions import Self
+
+class Tree:
+    @classmethod
+    def build(cls) -> Self:
+        return cls()
 ```
 
 If using `typing-extensions`, you must add it to the install dependencies for your library (do not rely on install by `azure-core`)
@@ -163,8 +179,7 @@ from `typing` if supported, or `typing-extensions` if the Python version is too
 check yourself.
 
 See the [typing-extensions](https://github.com/python/typing_extensions) docs to check what has been
-backported. This document calls out which types are needed through `typing-extensions` based on support of Python 3.7+.
-Some commonly used types imported from `typing-extensions` are Literal, TypedDict, Protocol, runtime_checkable, and Final.
+backported. This document calls out which types are needed through `typing-extensions` only when they are not yet available in the standard `typing` module on Python 3.10.
 
 ## Install and run type checkers on your client library code
 
@@ -382,7 +397,7 @@ def begin_export_project(
 
 Per PEP 484, type checkers have moved towards requiring the Optional type to be made explicit when a default of None is provided.
 
-> Note: The `X | None` syntax is only supported in Python 3.10+.
+> Note: Since Python 3.10 is the minimum supported version, you can also use the `X | None` syntax (PEP 604) instead of `Optional[X]`.
 
 ### Typing for collections
 
@@ -422,11 +437,10 @@ specified a generic `typing.Dict` here, the `entity` passed must be a `dict` or
 accepted.
 
 With [PEP 589](https://peps.python.org/pep-0589/), a `TypedDict` was introduced in Python 3.8 which allows you to add
-type hints for dictionaries with a fixed set of keys. The syntax for this looks similar to building a dataclass:
+type hints for dictionaries with a fixed set of keys. It is available directly from `typing` in Python 3.10. The syntax for this looks similar to building a dataclass:
 
 ```python
-# from typing import TypedDict  # Python >= 3.8
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 
 class Employee(TypedDict):
@@ -464,11 +478,10 @@ e.g. `isinstance(employee, Employee)` will throw a `TypeError`. Usage of `TypedD
 type checkers and Intellisense how a specific dict should be constructed and help the type checkers warn users if
 they try to access keys which don't exist.
 
-Use of generic TypedDict is also supported via typing_extensions (>=4.3.0). For example,
+Generic `TypedDict` is supported in Python 3.11+. On Python 3.10, use `typing_extensions` (>=4.3.0) to use generic `TypedDict`. For example,
 
 ```python
-# from typing import TypedDict  # Python >= 3.8
-from typing_extensions import TypedDict
+from typing_extensions import TypedDict  # use typing_extensions for generic TypedDict on 3.10
 from typing import Generic, TypeVar, List
 
 T = TypeVar("T")
@@ -486,8 +499,6 @@ employee = Employee[str](name="krista", title="swe", id=123, current=True, addit
 
 See the [TypedDict](https://docs.python.org/3/library/typing.html#typing.TypedDict) docs for more options.
 
-> Note that TypedDict is backported to older versions of Python by using typing_extensions.
-
 #### List
 
 The [typing.List](https://docs.python.org/3/library/typing.html#typing.List) docs make a recommendation:
@@ -801,14 +812,11 @@ If it's possible that a type alias could be confused with a global assignment, e
 This removes ambiguity for the type checker and indicates this isn't a normal variable assignment.
 
 ```python
-# from typing import TypeAlias Python >=3.10
-from typing_extensions import TypeAlias
+from typing import TypeAlias
 
 x: TypeAlias = 1
 ```
 
-> Note that TypeAlias is backported to older versions of Python by using typing_extensions.
-
 ### Use typing.overload to overload a function
 
 `typing.overload` allows for annotating different combinations of typed arguments for a function. This can be useful when the
@@ -1095,8 +1103,7 @@ Below we create a `SupportsFly` protocol class which expects a `fly()` method on
 into `ascend()`.
 
 ```python
-# from typing import Protocol  # Python >=3.8
-from typing_extensions import Protocol
+from typing import Protocol
 
 
 class SupportsFly(Protocol):
@@ -1157,8 +1164,7 @@ See more on Protocols in the [reference documentation](https://docs.python.org/3
 If a Protocol is marked with @runtime_checkable, it can be used with `isinstance()` and `issubclass()` at runtime.
 
 ```python
-# from typing import runtime_checkable  Python >=3.8
-from typing_extensions import runtime_checkable, Protocol
+from typing import runtime_checkable, Protocol
 
 
 @runtime_checkable
@@ -1173,17 +1179,14 @@ assert isinstance(Penguin, SupportsFly)  # False
 Because this is a runtime check, only the presence of the required methods defined by the Protocol is checked -- not
 their type signatures.
 
-> Note that runtime_checkable is backported to older versions of Python by using typing_extensions.
-
 ### Use typing.Literal to restrict based on exact values
 
 [PEP 586](https://peps.python.org/pep-0586/) introduced the `typing.Literal` type which can be used to indicate that an
 expression has a literal specific value. A Literal can contain one or more literal bool, int, str, bytes, or enum
 values:
 
 ```python
-# from typing import Literal  Python >=3.8
-from typing_extensions import Literal
+from typing import Literal
 
 doc_type = Literal["prebuilt-receipt"]
 allowed_content_types = Literal["application/json", "text/plain", "image/png", "image/jpeg"]
@@ -1249,7 +1252,7 @@ main.py:51: note: Revealed type is "__main__.SelectionMark"
 To solve this issue, we can update the `get_element` function to have overloads based on their Literal `kind`:
 
 ```python
-from typing_extensions import Literal, overload
+from typing import Literal, overload
 
 
 @overload
@@ -1293,8 +1296,7 @@ making `isinstance` checks to understand the result. The following example shows
 a Union of types which each contain a discriminator property, `kind`, typed as a Literal.
 
 ```python
-from typing import Union
-from typing_extensions import Literal
+from typing import Union, Literal
 
 
 # client library code
@@ -1361,8 +1363,6 @@ elif isinstance(ele, FormLine):
 
 Therefore, it is preferred to use `typing.Literal` in this situation to provide the best type checking experience for our users.
 
-> Note that Literal is backported to older versions of Python by using typing_extensions.
-
 ### Use typing.NewType to restrict a type to a specific context
 
 `NewType` can be useful to catch errors where a particular type is expected. `NewType` will take an existing type and
@@ -1398,8 +1398,7 @@ At runtime, `NewType` will return an object that returns its argument when calle
 It is best used when a variable's scope spans a large amount of modules and you want to ensure that it stays immutable (i.e. no line of code tries to change it).
 
 ```python
-# from typing import Final  Python >=3.8
-from typing_extensions import Final
+from typing import Final
 
 MAX_BLOB_SIZE: Final = 4 * 1024 * 1024
 ```
@@ -1414,7 +1413,7 @@ Found 1 error in 1 file (checked 1 source file)
 Additionally, If you have a method that should not be overridden or a class that should not be subclassed, consider decorating with `@final`.
 
 ```python
-from typing_extensions import final
+from typing import final
 
 class BlobClient:
     @final

doc/dev/static_type_checking.md

@@ -85,14 +85,19 @@ class Tree:
 - Do use the latest typing features available. If not supported by older versions of Python, consider taking a dependency and importing from `typing-extensions`.
 
 ```python
-# from typing import TypedDict Python >3.8
-from typing_extensions import TypedDict
+# Self was added to typing in 3.11, so import from typing_extensions on 3.10
+from typing_extensions import Self
+
+class Tree:
+    @classmethod
+    def build(cls) -> Self:
+        return cls()
 ```
 
 ### Importing types
 
 - Do use only publicly exposed client library types in type hints.
-- Do import types from modules such as `typing`, `typing_extensions`, `collections`, and `collections.abc`(Note that indexing support for generic collection types from `collections.abc` is only supported on Python 3.9+).
+- Do import types from modules such as `typing`, `typing_extensions`, `collections`, and `collections.abc`. Generic collection types from `collections.abc` support `[]` indexing on Python 3.10 (the minimum supported version).
 - Do not import regular type hints under a `typing.TYPE_CHECKING` block. You may use `TYPE_CHECKING` to fix a circular import or avoid importing a type only needed in type annotations that is otherwise costly to load at runtime.
 
 ```python
@@ -278,7 +283,7 @@ class Triangle:
 - Mark your `Protocol`s as `@runtime_checkable` so users can use them in `isinstance` and `issubclass` checks.
 
 ```python
-from typing_extensions import Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 @runtime_checkable
 class TokenCredential(Protocol):
@@ -386,7 +391,7 @@ CredentialTypes = Union[AzureKeyCredential, TokenCredential, AzureSasCredential,
 - You can use `typing.Literal` when you want to restrict based on exact values.
 
 ```python
-from typing_extensions import Literal
+from typing import Literal
 
 PrimaryColors = Literal["red", "yellow", "blue"]
 ```
@@ -398,15 +403,15 @@ PrimaryColors = Literal["red", "yellow", "blue"]
 - If you have a type that should not change or get re-assigned in the code, consider typing it as `typing.Final`.
 
 ```python
-from typing_extensions import Final
+from typing import Final
 
 MAX_BLOB_SIZE: Final = 4 * 1024 * 1024
 ```
 
 - If you have a method that should not be overridden or a class that should not be subclassed, consider decorating with `@final`.
 
 ```python
-from typing_extensions import final
+from typing import final
 
 class BlobClient:
     @final

doc/dev/static_type_checking_cheat_sheet.md

@@ -4,16 +4,18 @@ This page describes the Python version support policy for the Azure SDK for Pyth
 
 End of support means, in the SDK context, that new features will not be supported for those unsupported Python versions. It will still be possible to install older SDK versions from PyPI as necessary.
 
+> **Note:** The "SDKs End Of Support" date is inclusive — the listed day is the last supported day, and the next day is the first unsupported day.
+
 | Python Version | PSF End of Support | SDKs End Of Support |
 |----------------|--------------------|---------------------|
 | 2.7 ([PEP 373](https://peps.python.org/pep-0373/))                   | April 2020       | January 2022   |
 | 3.6 ([PEP 494](https://www.python.org/dev/peps/pep-0494/#lifespan))  | December 2021    | August 2022    |
 | 3.7 ([PEP 537](https://www.python.org/dev/peps/pep-0537/#lifespan))  | June 2023        | December 2023  |
 | 3.8 ([PEP 569](https://www.python.org/dev/peps/pep-0569/#lifespan))  | October 2024     | April 2025     |
-| 3.9 ([PEP 596](https://www.python.org/dev/peps/pep-0596/#lifespan))  | October 2025     | April 2026     |
-| 3.10 ([PEP 619](https://www.python.org/dev/peps/pep-0619/#lifespan)) | October 2026     | April 2027     |
-| 3.11 ([PEP 664](https://www.python.org/dev/peps/pep-0664/#lifespan)) | October 2027     | April 2028     |
-| 3.12 ([PEP 693](https://www.python.org/dev/peps/pep-0693/#lifespan)) | October 2028     | April 2029     |
-| 3.13 ([PEP 719](https://www.python.org/dev/peps/pep-0719/#lifespan)) | October 2029     | April 2030     |
-| 3.14 ([PEP 745](https://www.python.org/dev/peps/pep-0745/#lifespan)) | October 2030     | April 2031     |
-| 3.15 ([PEP 790](https://www.python.org/dev/peps/pep-0790/#lifespan)) | October 2031     | April 2032     |
+| 3.9 ([PEP 596](https://www.python.org/dev/peps/pep-0596/#lifespan))  | October 2025     | April 30, 2026     |
+| 3.10 ([PEP 619](https://www.python.org/dev/peps/pep-0619/#lifespan)) | October 2026     | April 30, 2027     |
+| 3.11 ([PEP 664](https://www.python.org/dev/peps/pep-0664/#lifespan)) | October 2027     | April 30, 2028     |
+| 3.12 ([PEP 693](https://www.python.org/dev/peps/pep-0693/#lifespan)) | October 2028     | April 30, 2029     |
+| 3.13 ([PEP 719](https://www.python.org/dev/peps/pep-0719/#lifespan)) | October 2029     | April 30, 2030     |
+| 3.14 ([PEP 745](https://www.python.org/dev/peps/pep-0745/#lifespan)) | October 2030     | April 30, 2031     |
+| 3.15 ([PEP 790](https://www.python.org/dev/peps/pep-0790/#lifespan)) | October 2031     | April 30, 2032     |