sqlspec 0.16.0__py3-none-any.whl → 0.16.1__py3-none-any.whl

sqlspec/builder/mixins/_update_operations.py

@@ -3,6 +3,7 @@
 from collections.abc import Mapping
 from typing import Any, Optional, Union
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -14,10 +15,14 @@ __all__ = ("UpdateFromClauseMixin", "UpdateSetClauseMixin", "UpdateTableClauseMi
 MIN_SET_ARGS = 2
 
 
+@trait
 class UpdateTableClauseMixin:
     """Mixin providing TABLE clause for UPDATE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def table(self, table_name: str, alias: Optional[str] = None) -> Self:
         """Set the table to update.
@@ -37,10 +42,24 @@ class UpdateTableClauseMixin:
         return self
 
 
+@trait
 class UpdateSetClauseMixin:
     """Mixin providing SET clause for UPDATE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate unique parameter name - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def set(self, *args: Any, **kwargs: Any) -> Self:
         """Set columns and values for the UPDATE statement.
@@ -79,14 +98,13 @@ class UpdateSetClauseMixin:
                 value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                 if has_query_builder_parameters(val):
                     for p_name, p_value in val.parameters.items():
-                        self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+                        self.add_parameter(p_value, name=p_name)
             else:
                 column_name = col if isinstance(col, str) else str(col)
-                # Extract just the column part if table.column format
                 if "." in column_name:
                     column_name = column_name.split(".")[-1]
-                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+                param_name = self._generate_unique_parameter_name(column_name)
+                param_name = self.add_parameter(val, name=param_name)[1]
                 value_expr = exp.Placeholder(this=param_name)
             assignments.append(exp.EQ(this=col_expr, expression=value_expr))
         elif (len(args) == 1 and isinstance(args[0], Mapping)) or kwargs:
@@ -100,14 +118,13 @@ class UpdateSetClauseMixin:
                     value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                     if has_query_builder_parameters(val):
                         for p_name, p_value in val.parameters.items():
-                            self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+                            self.add_parameter(p_value, name=p_name)
                 else:
-                    # Extract column name for parameter naming
                     column_name = col if isinstance(col, str) else str(col)
                     if "." in column_name:
                         column_name = column_name.split(".")[-1]
-                    param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
-                    param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+                    param_name = self._generate_unique_parameter_name(column_name)
+                    param_name = self.add_parameter(val, name=param_name)[1]
                     value_expr = exp.Placeholder(this=param_name)
                 assignments.append(exp.EQ(this=exp.column(col), expression=value_expr))
         else:
@@ -118,9 +135,15 @@ class UpdateSetClauseMixin:
         return self
 
 
+@trait
 class UpdateFromClauseMixin:
     """Mixin providing FROM clause for UPDATE builders (e.g., PostgreSQL style)."""
 
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Add a FROM clause to the UPDATE statement.
 
@@ -134,7 +157,7 @@ class UpdateFromClauseMixin:
         Raises:
             SQLBuilderError: If the current expression is not an UPDATE statement.
         """
-        if self._expression is None or not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
+        if self._expression is None or not isinstance(self._expression, exp.Update):
             msg = "Cannot add FROM clause to non-UPDATE expression. Set the main table first."
             raise SQLBuilderError(msg)
         table_expr: exp.Expression
@@ -152,9 +175,9 @@ class UpdateFromClauseMixin:
         else:
             msg = f"Unsupported table type for FROM clause: {type(table)}"
             raise SQLBuilderError(msg)
-        if self._expression.args.get("from") is None:  # type: ignore[attr-defined]
-            self._expression.set("from", exp.From(expressions=[]))  # type: ignore[attr-defined]
-        from_clause = self._expression.args["from"]  # type: ignore[attr-defined]
+        if self._expression.args.get("from") is None:
+            self._expression.set("from", exp.From(expressions=[]))
+        from_clause = self._expression.args["from"]
         if hasattr(from_clause, "append"):
             from_clause.append("expressions", table_expr)
         else:

sqlspec/builder/mixins/_where_clause.py

@@ -3,6 +3,7 @@
 
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -27,9 +28,10 @@ def _extract_column_name(column: Union[str, exp.Column]) -> str:
         return column
     if isinstance(column, exp.Column):
         # Extract the column name from SQLGlot Column expression
-        if column.this and hasattr(column.this, "this"):
+        try:
             return str(column.this.this)
-        return str(column.this) if column.this else "column"
+        except AttributeError:
+            return str(column.this) if column.this else "column"
     return "column"
 
 
@@ -40,9 +42,15 @@ if TYPE_CHECKING:
 __all__ = ("HavingClauseMixin", "WhereClauseMixin")
 
 
+@trait
 class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     def _handle_in_operator(
         self, column_exp: exp.Expression, value: Any, column_name: str = "column"
     ) -> exp.Expression:
@@ -52,13 +60,13 @@ class WhereClauseMixin:
             placeholders = []
             for i, v in enumerate(value):
                 if len(value) == 1:
-                    param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(column_name)
                 else:
-                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
                 _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.In(this=column_exp, expressions=placeholders)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         return exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)])
 
@@ -71,13 +79,13 @@ class WhereClauseMixin:
             placeholders = []
             for i, v in enumerate(value):
                 if len(value) == 1:
-                    param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(column_name)
                 else:
-                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
                 _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.Not(this=exp.In(this=column_exp, expressions=placeholders))
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         return exp.Not(this=exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)]))
 
@@ -98,8 +106,8 @@ class WhereClauseMixin:
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
-            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
             _, low_param = builder.add_parameter(low, name=low_param)
             _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Between(
@@ -115,8 +123,8 @@ class WhereClauseMixin:
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
-            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
             _, low_param = builder.add_parameter(low, name=low_param)
             _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Not(
@@ -137,7 +145,7 @@ class WhereClauseMixin:
         if len(condition) == 2:
             # (column, value) tuple for equality
             value = condition[1]
-            param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = builder._generate_unique_parameter_name(column_name)
             _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
 
@@ -147,35 +155,35 @@ class WhereClauseMixin:
             value = condition[2]
 
             if operator == "=":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator in {"!=", "<>"}:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.NEQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">=":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<=":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "LIKE":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "NOT LIKE":
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
                 _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
 
@@ -222,7 +230,7 @@ class WhereClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
+        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
 
@@ -274,7 +282,7 @@ class WhereClauseMixin:
         """Add WHERE column = value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.eq(exp.Placeholder(this=param_name))
@@ -284,7 +292,7 @@ class WhereClauseMixin:
         """Add WHERE column != value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.neq(exp.Placeholder(this=param_name))
@@ -294,7 +302,7 @@ class WhereClauseMixin:
         """Add WHERE column < value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.LT(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -304,7 +312,7 @@ class WhereClauseMixin:
         """Add WHERE column <= value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.LTE(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -314,7 +322,7 @@ class WhereClauseMixin:
         """Add WHERE column > value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.GT(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -324,7 +332,7 @@ class WhereClauseMixin:
         """Add WHERE column >= value clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = exp.GTE(this=col_expr, expression=exp.Placeholder(this=param_name))
@@ -334,8 +342,8 @@ class WhereClauseMixin:
         """Add WHERE column BETWEEN low AND high clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
-        high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+        low_param = builder._generate_unique_parameter_name(f"{column_name}_low")
+        high_param = builder._generate_unique_parameter_name(f"{column_name}_high")
         _, low_param = builder.add_parameter(low, name=low_param)
         _, high_param = builder.add_parameter(high, name=high_param)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
@@ -346,7 +354,7 @@ class WhereClauseMixin:
         """Add WHERE column LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         if escape is not None:
@@ -360,7 +368,7 @@ class WhereClauseMixin:
         """Add WHERE column NOT LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.like(exp.Placeholder(this=param_name)).not_()
@@ -370,7 +378,7 @@ class WhereClauseMixin:
         """Add WHERE column ILIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
         column_name = _extract_column_name(column)
-        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        param_name = builder._generate_unique_parameter_name(column_name)
         _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         condition: exp.Expression = col_expr.ilike(exp.Placeholder(this=param_name))
@@ -399,7 +407,7 @@ class WhereClauseMixin:
                 sql_str = subquery.sql
                 subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=builder.dialect_name))  # pyright: ignore
                 # Merge subquery parameters into parent builder
-                if hasattr(subquery, "parameters"):
+                if hasattr(subquery, "parameters") and isinstance(subquery.parameters, dict):  # pyright: ignore[reportAttributeAccessIssue]
                     for param_name, param_value in subquery.parameters.items():  # pyright: ignore[reportAttributeAccessIssue]
                         builder.add_parameter(param_value, name=param_name)
             else:
@@ -413,9 +421,9 @@ class WhereClauseMixin:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         condition = col_expr.isin(*parameters)
@@ -442,9 +450,9 @@ class WhereClauseMixin:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         condition = exp.Not(this=col_expr.isin(*parameters))
@@ -532,9 +540,9 @@ class WhereClauseMixin:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_any_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_any_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
@@ -572,9 +580,9 @@ class WhereClauseMixin:
         parameters = []
         for i, v in enumerate(values):
             if len(values) == 1:
-                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(column_name)
             else:
-                param_name = builder._generate_unique_parameter_name(f"{column_name}_not_any_{i + 1}")  # type: ignore[attr-defined]
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_not_any_{i + 1}")
             _, param_name = builder.add_parameter(v, name=param_name)
             parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
@@ -582,10 +590,14 @@ class WhereClauseMixin:
         return self.where(condition)
 
 
+@trait
 class HavingClauseMixin:
     """Mixin providing HAVING clause for SELECT builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def having(self, condition: Union[str, exp.Expression]) -> Self:
         """Add HAVING clause.

sqlspec/core/cache.py

@@ -245,19 +245,21 @@ class UnifiedCache(Generic[CacheValueT]):
             Cached value or None if not found or expired
         """
         with self._lock:
-            node: Optional[CacheNode] = self._cache.get(key)
+            node = self._cache.get(key)
             if node is None:
                 self._stats.record_miss()
                 return None
 
-            current_time: float = time.time()
-            ttl: Optional[int] = self._ttl
-            if ttl is not None and (current_time - node.timestamp) > ttl:
-                self._remove_node(node)
-                del self._cache[key]
-                self._stats.record_miss()
-                self._stats.record_eviction()
-                return None
+            # Optimize TTL check with early variable assignment
+            ttl = self._ttl
+            if ttl is not None:
+                current_time = time.time()
+                if (current_time - node.timestamp) > ttl:
+                    self._remove_node(node)
+                    del self._cache[key]
+                    self._stats.record_miss()
+                    self._stats.record_eviction()
+                    return None
 
             self._move_to_head(node)
             node.access_count += 1
@@ -272,7 +274,7 @@ class UnifiedCache(Generic[CacheValueT]):
             value: Value to cache
         """
         with self._lock:
-            existing_node: Optional[CacheNode] = self._cache.get(key)
+            existing_node = self._cache.get(key)
             if existing_node is not None:
                 existing_node.value = value
                 existing_node.timestamp = time.time()
@@ -280,14 +282,13 @@ class UnifiedCache(Generic[CacheValueT]):
                 self._move_to_head(existing_node)
                 return
 
-            new_node: CacheNode = CacheNode(key, value)
+            new_node = CacheNode(key, value)
             self._cache[key] = new_node
             self._add_to_head(new_node)
 
-            cache_size: int = len(self._cache)
-            max_size: int = self._max_size
-            if cache_size > max_size:
-                tail_node: Optional[CacheNode] = self._tail.prev
+            # Optimize size check with cached length
+            if len(self._cache) > self._max_size:
+                tail_node = self._tail.prev
                 if tail_node is not None and tail_node is not self._head:
                     self._remove_node(tail_node)
                     del self._cache[tail_node.key]
@@ -361,17 +362,13 @@ class UnifiedCache(Generic[CacheValueT]):
     def __contains__(self, key: CacheKey) -> bool:
         """Check if key exists in cache."""
         with self._lock:
-            node: Optional[CacheNode] = self._cache.get(key)
+            node = self._cache.get(key)
             if node is None:
                 return False
 
-            ttl: Optional[int] = self._ttl
-            if ttl is not None:
-                current_time: float = time.time()
-                if (current_time - node.timestamp) > ttl:
-                    return False
-
-            return True
+            # Optimize TTL check
+            ttl = self._ttl
+            return not (ttl is not None and time.time() - node.timestamp > ttl)
 
 
 @mypyc_attr(allow_interpreted_subclasses=False)
@@ -553,6 +550,8 @@ class ParameterCache:
         """
         # Create stable key from parameters and configuration
         try:
+            # Optimize type checking order
+            param_key: tuple[Any, ...]
             if isinstance(params, dict):
                 param_key = tuple(sorted(params.items()))
             elif isinstance(params, (list, tuple)):
@@ -560,12 +559,11 @@ class ParameterCache:
             else:
                 param_key = (params,)
 
-            key_data = ("parameters", param_key, config_hash)
-            return CacheKey(key_data)
+            return CacheKey(("parameters", param_key, config_hash))
         except (TypeError, ValueError):
-            param_key = (str(params), type(params).__name__)  # type: ignore[assignment]
-            key_data = ("parameters", param_key, config_hash)
-            return CacheKey(key_data)
+            # Fallback for unhashable types
+            param_key_fallback = (str(params), type(params).__name__)
+            return CacheKey(("parameters", param_key_fallback, config_hash))
 
     def clear(self) -> None:
         """Clear parameter cache."""