Auto-format code

Author: selenium-ci

py/cddl/ast.py

@@ -18,7 +18,6 @@
 """Abstract Syntax Tree (AST) data structures for CDDL definitions."""
 
 from dataclasses import dataclass, field
-from typing import Optional, List, Union
 
 
 @dataclass
@@ -27,18 +26,18 @@ class CddlField:
     name: str
     type: "CddlType"
     optional: bool = False
-    description: Optional[str] = None
+    description: str | None = None
 
 
 @dataclass
 class CddlType:
     """Base class for all CDDL type definitions."""
     name: str
     base_type: str = "unknown"  # Type category: ref, string, number, etc.
-    module: Optional[str] = None  # e.g., "session", "network"
-    description: Optional[str] = None
-    reference: Optional[str] = None  # For type references
-    value: Optional[str] = None  # For literal values
+    module: str | None = None  # e.g., "session", "network"
+    description: str | None = None
+    reference: str | None = None  # For type references
+    value: str | None = None  # For literal values
     is_primitive: bool = False  # Whether this is a primitive type
 
 
@@ -51,55 +50,55 @@ class CddlPrimitiveType(CddlType):
 @dataclass
 class CddlObject(CddlType):
     """Represents a CDDL object type with fields."""
-    fields: List[CddlField] = field(default_factory=list)
+    fields: list[CddlField] = field(default_factory=list)
     extensible: bool = False  # Whether object allows additional fields
 
 
 @dataclass
 class CddlEnum(CddlType):
     """Represents a CDDL enum type with string values."""
-    values: List[str] = field(default_factory=list)
+    values: list[str] = field(default_factory=list)
 
 
 @dataclass
 class CddlUnionVariant:
     """Represents one variant in a union type."""
     index: int = 0  # Index in union
-    type: Optional[CddlType] = None  # The type for this variant
-    discriminator_field: Optional[str] = None  # For tagged unions
-    discriminator_value: Optional[str] = None  # Value of discriminator field
+    type: CddlType | None = None  # The type for this variant
+    discriminator_field: str | None = None  # For tagged unions
+    discriminator_value: str | None = None  # Value of discriminator field
 
 
 @dataclass
 class CddlUnion(CddlType):
     """Represents a CDDL union type (multiple possible types)."""
-    variants: List[CddlUnionVariant] = field(default_factory=list)
+    variants: list[CddlUnionVariant] = field(default_factory=list)
 
 
 @dataclass
 class CddlArray(CddlType):
     """Represents a CDDL array type."""
-    item_type: Optional[CddlType] = None
+    item_type: CddlType | None = None
 
 
 @dataclass
 class CddlCommand(CddlType):
     """Represents a WebDriver BiDi command."""
     method: str = ""  # e.g., "session.new"
-    params: Optional[CddlObject] = None
-    result: Optional[CddlObject] = None
+    params: CddlObject | None = None
+    result: CddlObject | None = None
 
 
 @dataclass
 class CddlModule:
     """Represents a module grouping (e.g., all session.* types)."""
     name: str  # e.g., "session", "network"
     types: dict = field(default_factory=dict)  # Dict[name, CddlType]
-    commands: List[CddlCommand] = field(default_factory=list)
+    commands: list[CddlCommand] = field(default_factory=list)
 
 
 @dataclass
 class CddlSpecification:
     """Root node representing entire CDDL specification."""
-    modules: List[CddlModule] = field(default_factory=list)
+    modules: list[CddlModule] = field(default_factory=list)
     types: dict = field(default_factory=dict)  # Dict[name, CddlType] - Global types

py/cddl/downloader.py

@@ -19,16 +19,15 @@
 
 import re
 from pathlib import Path
-from typing import Optional
-from urllib.request import urlopen
 from urllib.error import URLError
+from urllib.request import urlopen
 
 # W3C WebDriver BiDi specification URL with CDDL index
 W3C_WEBDRIVER_BIDI_URL = "https://www.w3.org/TR/webdriver-bidi/"
 
 
 def download_cddl_spec(
-    output_dir: Optional[Path] = None,
+    output_dir: Path | None = None,
     force: bool = False,
 ) -> Path:
     """Download W3C WebDriver BiDi CDDL specification from HTML spec.
@@ -62,7 +61,7 @@ def download_cddl_spec(
     try:
         with urlopen(W3C_WEBDRIVER_BIDI_URL) as response:
             spec_html = response.read().decode("utf-8")
-        print(f"Downloaded specification")
+        print("Downloaded specification")
     except URLError as e:
         raise URLError(f"Failed to download W3C spec: {e}")
 
@@ -164,5 +163,5 @@ def read_cddl_file(file_path: Path) -> str:
     Returns:
         File content as string
     """
-    with open(file_path, "r", encoding="utf-8") as f:
+    with open(file_path, encoding="utf-8") as f:
         return f.read()

py/cddl/generator.py

@@ -20,10 +20,7 @@
 Generates Python dataclasses, Enums, and Union types from CDDL AST.
 """
 
-from typing import Dict, List, Optional, Tuple, Set
-from pathlib import Path
-from . import ast
-from . import type_guards
+from . import ast, type_guards
 
 
 class PythonCodeGenerator:
@@ -65,8 +62,8 @@ def __init__(self, strict_mode: bool = False):
             strict_mode: If True, validate all fields strictly
         """
         self.strict_mode = strict_mode
-        self.type_imports: Set[str] = set()
-        self.generated_code: Dict[str, str] = {}
+        self.type_imports: set[str] = set()
+        self.generated_code: dict[str, str] = {}
 
     def generate_module(self, module: ast.CddlModule) -> str:
         """Generate Python code for an entire module.
@@ -92,7 +89,7 @@ def generate_module(self, module: ast.CddlModule) -> str:
 
         return "\n".join(lines)
 
-    def _generate_type(self, cddl_type: ast.CddlType, module_name: str = "") -> Optional[str]:
+    def _generate_type(self, cddl_type: ast.CddlType, module_name: str = "") -> str | None:
         """Generate Python code for a single type.
         
         Args:
@@ -138,7 +135,7 @@ def _generate_dataclass(self, obj_type: ast.CddlObject) -> str:
             if obj_type.description:
                 lines.append(f'    """{obj_type.description}"""')
             else:
-                lines.append(f'    """Auto-generated from WebDriver BiDi CDDL."""')
+                lines.append('    """Auto-generated from WebDriver BiDi CDDL."""')
 
         # Generate fields
         if obj_type.fields:
@@ -170,7 +167,7 @@ def _generate_dataclass(self, obj_type: ast.CddlObject) -> str:
         lines.append("")
         lines.append("    @classmethod")
         lines.append("    def from_json(cls, data: Dict[str, Any]) -> '{class_name}':")
-        lines.append(f"        \"\"\"Create from JSON dict with lenient parsing.\"\"\"")
+        lines.append("        \"\"\"Create from JSON dict with lenient parsing.\"\"\"")
         lines.append("        kwargs = {}")
         for field in obj_type.fields:
             python_name = type_guards._snake_to_camel(field.name)
@@ -192,7 +189,7 @@ def _generate_enum(self, enum_type: ast.CddlEnum) -> str:
         """
         class_name = self._sanitize_name(enum_type.name)
         lines = [f"class {class_name}(str, Enum):"]
-        lines.append(f'    """Auto-generated enum from WebDriver BiDi CDDL."""')
+        lines.append('    """Auto-generated enum from WebDriver BiDi CDDL."""')
 
         if enum_type.values:
             for i, value in enumerate(enum_type.values):

py/cddl/main.py

@@ -20,7 +20,6 @@
 import argparse
 import logging
 from pathlib import Path
-from typing import Optional
 
 from . import downloader, parser, writer
 
@@ -185,12 +184,12 @@ def cmd_parse(args) -> int:
     # Parse CDDL
     logging.info(f"Parsing {cddl_file}...")
     try:
-        with open(cddl_file, "r") as f:
+        with open(cddl_file) as f:
             cddl_text = f.read()
 
         spec = parser.parse_cddl(cddl_text)
 
-        logging.info(f"Successfully parsed CDDL")
+        logging.info("Successfully parsed CDDL")
         logging.info(f"  Modules: {len(spec.modules)}")
         logging.info(f"  Types: {len(spec.types)}")
 
@@ -199,7 +198,7 @@ def cmd_parse(args) -> int:
             logging.info(f"    Module '{module.name}': {len(module.types)} types")
 
         if args.output:
-            logging.info(f"Output to JSON not yet implemented")
+            logging.info("Output to JSON not yet implemented")
 
         return 0
     except SyntaxError as e:
@@ -235,14 +234,14 @@ def cmd_generate(args) -> int:
     # Parse CDDL
     logging.info(f"Parsing {cddl_file}...")
     try:
-        with open(cddl_file, "r") as f:
+        with open(cddl_file) as f:
             cddl_text = f.read()
 
         spec = parser.parse_cddl(cddl_text)
         logging.info(f"Successfully parsed CDDL ({len(spec.types)} types)")
 
         # Generate code
-        logging.info(f"Generating Python code...")
+        logging.info("Generating Python code...")
         module_writer = writer.ModuleWriter(args.output_dir, strict_mode=args.strict)
         written_files = module_writer.write_specification(spec)
 
@@ -284,7 +283,7 @@ def cmd_generate_all(args) -> int:
         # Parse first CDDL file
         cddl_file = cddl_files[0]
         logging.info(f"Parsing {cddl_file}...")
-        with open(cddl_file, "r") as f:
+        with open(cddl_file) as f:
             cddl_text = f.read()
 
         spec = parser.parse_cddl(cddl_text)

py/cddl/parser.py

@@ -19,8 +19,8 @@
 
 from dataclasses import dataclass
 from enum import Enum, auto
-from typing import List, Optional, Set, Dict, Any, Union as UnionType
-import re
+from typing import Any
+
 from . import ast
 
 
@@ -81,9 +81,9 @@ def __init__(self, text: str):
         self.pos = 0
         self.line = 1
         self.column = 1
-        self.tokens: List[Token] = []
+        self.tokens: list[Token] = []
 
-    def tokenize(self) -> List[Token]:
+    def tokenize(self) -> list[Token]:
         """Tokenize the CDDL text.
 
         Returns:
@@ -288,7 +288,7 @@ def _make_token(self, token_type: TokenType) -> Token:
 class CddlParser:
     """Parser for CDDL specifications."""
 
-    def __init__(self, tokens: List[Token]):
+    def __init__(self, tokens: list[Token]):
         """Initialize parser with token stream.
 
         Args:
@@ -314,7 +314,7 @@ def parse(self) -> dict:
                     # Skip tokens if parse_definition returned None
                     # This prevents infinite loops
                     self._advance()
-            except SyntaxError as e:
+            except SyntaxError:
                 # Skip to next definition on error
                 # Look for next IDENTIFIER or EXTENSIBLE followed by ASSIGN
                 while not self._is_at_end():
@@ -353,7 +353,7 @@ def _expect(self, token_type: TokenType) -> Token:
         self._advance()
         return token
 
-    def _parse_definition(self) -> Optional[tuple]:
+    def _parse_definition(self) -> tuple | None:
         """Parse a CDDL type definition."""
         if self._is_at_end():
             return None
@@ -558,15 +558,15 @@ def _parse_array(self) -> dict:
 class AstTransformer:
     """Transform parsed CDDL dict intermediate representation to AST objects."""
 
-    def __init__(self, definitions: Dict[str, Any]):
+    def __init__(self, definitions: dict[str, Any]):
         """Initialize transformer with parsed definitions.
 
         Args:
             definitions: Dictionary of parsed CDDL definitions from CddlParser
         """
         self.definitions = definitions
-        self.cddl_types: Dict[str, ast.CddlType] = {}
-        self.modules: Dict[str, ast.CddlModule] = {}
+        self.cddl_types: dict[str, ast.CddlType] = {}
+        self.modules: dict[str, ast.CddlModule] = {}
 
     def transform(self) -> ast.CddlSpecification:
         """Transform parsed definitions to CddlSpecification AST.
@@ -614,7 +614,7 @@ def _organize_modules(self):
                 name="_global", types=global_types, commands=[]
             )
 
-    def _transform_type(self, name: str, definition: Any) -> Optional[ast.CddlType]:
+    def _transform_type(self, name: str, definition: Any) -> ast.CddlType | None:
         """Transform a single type definition to AST.
 
         Args:
@@ -725,7 +725,7 @@ def _transform_union(self, name: str, definition: dict) -> ast.CddlUnion:
             name=name, variants=variants, description=None
         )
 
-    def _flatten_union_variants(self, definition: dict) -> List[Any]:
+    def _flatten_union_variants(self, definition: dict) -> list[Any]:
         """Flatten nested union definitions into a list of variants.
 
         Args:

py/cddl/type_guards.py

@@ -17,7 +17,7 @@
 
 """Type guard functions for runtime validation during deserialization."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 def is_string(value: Any) -> bool:
@@ -51,10 +51,10 @@ def is_none(value: Any) -> bool:
 
 
 def validate_required_field(
-    json_dict: Dict[str, Any],
+    json_dict: dict[str, Any],
     field_name: str,
     expected_type: type,
-    camel_case: Optional[str] = None,
+    camel_case: str | None = None,
 ) -> Any:
     """Validate and extract a required field from JSON.
 
@@ -86,11 +86,11 @@ def validate_required_field(
 
 
 def validate_optional_field(
-    json_dict: Dict[str, Any],
+    json_dict: dict[str, Any],
     field_name: str,
     expected_type: type,
     default: Any = None,
-    camel_case: Optional[str] = None,
+    camel_case: str | None = None,
 ) -> Any:
     """Validate and extract an optional field from JSON.
 
@@ -123,11 +123,11 @@ def validate_optional_field(
 
 
 def validate_object(
-    json_dict: Dict[str, Any],
-    required_fields: Dict[str, type],
-    optional_fields: Optional[Dict[str, type]] = None,
+    json_dict: dict[str, Any],
+    required_fields: dict[str, type],
+    optional_fields: dict[str, type] | None = None,
     lenient: bool = True,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Validate object fields with lenient or strict mode.
 
     Args: