sqlspec 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

sqlspec/builder/mixins/_merge_operations.py

@@ -11,6 +11,7 @@ from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters
 
@@ -30,7 +31,6 @@ class MergeIntoClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -50,7 +50,6 @@ class MergeIntoClauseMixin:
             self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
             current_expr = self.get_expression()
 
-        # Type guard: current_expr is now guaranteed to be an Expression
         assert current_expr is not None
         current_expr.set("this", exp.to_table(table, alias=alias) if isinstance(table, str) else table)
         return self
@@ -62,7 +61,6 @@ class MergeUsingClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -71,6 +69,11 @@ class MergeUsingClauseMixin:
         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 using(self, source: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
         """Set the source data for the MERGE operation (USING clause).
 
@@ -90,11 +93,35 @@ class MergeUsingClauseMixin:
             self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
             current_expr = self.get_expression()
 
-        # Type guard: current_expr is now guaranteed to be an Expression
         assert current_expr is not None
         source_expr: exp.Expression
         if isinstance(source, str):
             source_expr = exp.to_table(source, alias=alias)
+        elif isinstance(source, dict):
+            columns = list(source.keys())
+            values = list(source.values())
+
+            parameterized_values: list[exp.Expression] = []
+            for col, val in zip(columns, values):
+                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)
+                _, param_name = self.add_parameter(val, name=param_name)
+                parameterized_values.append(exp.Placeholder(this=param_name))
+
+            select_expr = exp.Select()
+            select_expressions = []
+            for i, col in enumerate(columns):
+                select_expressions.append(exp.alias_(parameterized_values[i], col))
+            select_expr.set("expressions", select_expressions)
+
+            from_expr = exp.From(this=exp.to_table("DUAL"))
+            select_expr.set("from", from_expr)
+
+            source_expr = exp.paren(select_expr)
+            if alias:
+                source_expr = exp.alias_(source_expr, alias, table=False)
         elif has_query_builder_parameters(source) and hasattr(source, "_expression"):
             subquery_builder_parameters = source.parameters
             if subquery_builder_parameters:
@@ -121,7 +148,6 @@ class MergeOnClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -143,7 +169,6 @@ class MergeOnClauseMixin:
             self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
             current_expr = self.get_expression()
 
-        # Type guard: current_expr is now guaranteed to be an Expression
         assert current_expr is not None
         condition_expr: exp.Expression
         if isinstance(condition, str):
@@ -170,7 +195,6 @@ class MergeMatchedClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -184,6 +208,42 @@ class MergeMatchedClauseMixin:
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _is_column_reference(self, value: str) -> bool:
+        """Check if a string value is a column reference rather than a literal.
+
+        Uses sqlglot to parse the value and determine if it represents a column
+        reference, function call, or other SQL expression rather than a literal.
+        """
+        if not isinstance(value, str):
+            return False
+
+        # If the string contains spaces and no SQL-like syntax, treat as literal
+        if " " in value and not any(x in value for x in [".", "(", ")", "*", "="]):
+            return False
+
+        # Only consider strings with dots (table.column), functions, or SQL keywords as column references
+        # Simple identifiers are treated as literals
+        if not any(x in value for x in [".", "(", ")"]):
+            # Check if it's a SQL keyword/function that should be treated as expression
+            sql_keywords = {"NULL", "CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME", "DEFAULT"}
+            if value.upper() not in sql_keywords:
+                return False
+
+        try:
+            # Try to parse as SQL expression
+            parsed: Optional[exp.Expression] = exp.maybe_parse(value)
+            if parsed is None:
+                return False
+
+            # Check for SQL literals that should be treated as expressions
+            return isinstance(
+                parsed,
+                (exp.Dot, exp.Anonymous, exp.Func, exp.Null, exp.CurrentTimestamp, exp.CurrentDate, exp.CurrentTime),
+            )
+        except Exception:
+            # If parsing fails, treat as literal
+            return False
+
     def _add_when_clause(self, when_clause: exp.When) -> None:
         """Helper to add a WHEN clause to the MERGE statement.
 
@@ -195,7 +255,6 @@ class MergeMatchedClauseMixin:
             self.set_expression(exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[])))
             current_expr = self.get_expression()
 
-        # Type guard: current_expr is now guaranteed to be an Expression
         assert current_expr is not None
         whens = current_expr.args.get("whens")
         if not whens:
@@ -230,7 +289,11 @@ class MergeMatchedClauseMixin:
             The current builder instance for method chaining.
         """
         # Combine set_values dict and kwargs
-        all_values = dict(set_values or {}, **kwargs)
+        all_values = {}
+        if set_values:
+            all_values.update(set_values)
+        if kwargs:
+            all_values.update(kwargs)
 
         if not all_values:
             msg = "No update values provided. Use set_values dict or kwargs."
@@ -239,35 +302,17 @@ class MergeMatchedClauseMixin:
         update_expressions: list[exp.EQ] = []
         for col, val in all_values.items():
             if hasattr(val, "expression") and hasattr(val, "sql"):
-                # Handle SQL objects (from sql.raw with parameters)
-                expression = getattr(val, "expression", None)
-                if expression is not None and isinstance(expression, exp.Expression):
-                    # Merge parameters from SQL object into builder
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    value_expr = expression
-                else:
-                    # If expression is None, fall back to parsing the raw SQL
-                    sql_text = getattr(val, "sql", "")
-                    # Merge parameters even when parsing raw SQL
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    # Check if sql_text is callable (like Expression.sql method)
-                    if callable(sql_text):
-                        sql_text = str(val)
-                    value_expr = exp.maybe_parse(sql_text) or exp.convert(str(sql_text))
+                value_expr = extract_sql_object_expression(val, builder=self)
             elif isinstance(val, exp.Expression):
                 value_expr = val
+            elif isinstance(val, str) and self._is_column_reference(val):
+                value_expr = exp.maybe_parse(val) or exp.column(val)
             else:
                 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)
-                param_name = self.add_parameter(val, name=param_name)[1]
+                _, param_name = self.add_parameter(val, name=param_name)
                 value_expr = exp.Placeholder(this=param_name)
 
             update_expressions.append(exp.EQ(this=exp.column(col), expression=value_expr))
@@ -337,7 +382,6 @@ class MergeNotMatchedClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -351,6 +395,54 @@ class MergeNotMatchedClauseMixin:
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _is_column_reference(self, value: str) -> bool:
+        """Check if a string value is a column reference rather than a literal.
+
+        Uses sqlglot to parse the value and determine if it represents a column
+        reference, function call, or other SQL expression rather than a literal.
+        """
+        if not isinstance(value, str):
+            return False
+
+        # If the string contains spaces and no SQL-like syntax, treat as literal
+        if " " in value and not any(x in value for x in [".", "(", ")", "*", "="]):
+            return False
+
+        try:
+            # Try to parse as SQL expression
+            parsed: Optional[exp.Expression] = exp.maybe_parse(value)
+            if parsed is None:
+                return False
+
+            # If it parses to a Column, Dot (table.column), Identifier, or other SQL constructs
+
+        except Exception:
+            # If parsing fails, fall back to conservative approach
+            # Only treat simple identifiers as column references
+            return (
+                value.replace("_", "").replace(".", "").isalnum()
+                and (value[0].isalpha() or value[0] == "_")
+                and " " not in value
+                and "'" not in value
+                and '"' not in value
+            )
+        return bool(
+            isinstance(
+                parsed,
+                (
+                    exp.Column,
+                    exp.Dot,
+                    exp.Identifier,
+                    exp.Anonymous,
+                    exp.Func,
+                    exp.Null,
+                    exp.CurrentTimestamp,
+                    exp.CurrentDate,
+                    exp.CurrentTime,
+                ),
+            )
+        )
+
     def _add_when_clause(self, when_clause: exp.When) -> None:
         """Helper to add a WHEN clause to the MERGE statement - provided by QueryBuilder."""
         msg = "Method must be provided by QueryBuilder subclass"
@@ -388,12 +480,16 @@ class MergeNotMatchedClauseMixin:
 
             parameterized_values: list[exp.Expression] = []
             for i, val in enumerate(values):
-                column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
-                if "." in column_name:
-                    column_name = column_name.split(".")[-1]
-                param_name = self._generate_unique_parameter_name(column_name)
-                param_name = self.add_parameter(val, name=param_name)[1]
-                parameterized_values.append(exp.Placeholder())
+                if isinstance(val, str) and self._is_column_reference(val):
+                    # Handle column references (like "s.data") as column expressions, not parameters
+                    parameterized_values.append(exp.maybe_parse(val) or exp.column(val))
+                else:
+                    column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
+                    if "." in column_name:
+                        column_name = column_name.split(".")[-1]
+                    param_name = self._generate_unique_parameter_name(column_name)
+                    _, param_name = self.add_parameter(val, name=param_name)
+                    parameterized_values.append(exp.Placeholder(this=param_name))
 
             insert_args["this"] = exp.Tuple(expressions=[exp.column(c) for c in columns])
             insert_args["expression"] = exp.Tuple(expressions=parameterized_values)
@@ -439,7 +535,6 @@ class MergeNotMatchedBySourceClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -458,6 +553,35 @@ class MergeNotMatchedBySourceClauseMixin:
         msg = "Method must be provided by QueryBuilder subclass"
         raise NotImplementedError(msg)
 
+    def _is_column_reference(self, value: str) -> bool:
+        """Check if a string value is a column reference rather than a literal.
+
+        Uses sqlglot to parse the value and determine if it represents a column
+        reference, function call, or other SQL expression rather than a literal.
+
+        Args:
+            value: The string value to check
+
+        Returns:
+            True if the value is a column reference, False if it's a literal
+        """
+        if not isinstance(value, str):
+            return False
+
+        try:
+            parsed: Optional[exp.Expression] = exp.maybe_parse(value)
+            if parsed is None:
+                return False
+
+        except Exception:
+            return False
+        return bool(
+            isinstance(
+                parsed,
+                (exp.Dot, exp.Anonymous, exp.Func, exp.Null, exp.CurrentTimestamp, exp.CurrentDate, exp.CurrentTime),
+            )
+        )
+
     def when_not_matched_by_source_then_update(
         self,
         set_values: Optional[dict[str, Any]] = None,
@@ -494,35 +618,17 @@ class MergeNotMatchedBySourceClauseMixin:
         update_expressions: list[exp.EQ] = []
         for col, val in all_values.items():
             if hasattr(val, "expression") and hasattr(val, "sql"):
-                # Handle SQL objects (from sql.raw with parameters)
-                expression = getattr(val, "expression", None)
-                if expression is not None and isinstance(expression, exp.Expression):
-                    # Merge parameters from SQL object into builder
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    value_expr = expression
-                else:
-                    # If expression is None, fall back to parsing the raw SQL
-                    sql_text = getattr(val, "sql", "")
-                    # Merge parameters even when parsing raw SQL
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self.add_parameter(param_value, name=param_name)
-                    # Check if sql_text is callable (like Expression.sql method)
-                    if callable(sql_text):
-                        sql_text = str(val)
-                    value_expr = exp.maybe_parse(sql_text) or exp.convert(str(sql_text))
+                value_expr = extract_sql_object_expression(val, builder=self)
             elif isinstance(val, exp.Expression):
                 value_expr = val
+            elif isinstance(val, str) and self._is_column_reference(val):
+                value_expr = exp.maybe_parse(val) or exp.column(val)
             else:
                 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)
-                param_name = self.add_parameter(val, name=param_name)[1]
+                _, param_name = self.add_parameter(val, name=param_name)
                 value_expr = exp.Placeholder(this=param_name)
 
             update_expressions.append(exp.EQ(this=exp.column(col), expression=value_expr))

sqlspec/builder/mixins/_order_limit_operations.py

@@ -11,7 +11,7 @@ from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
-from sqlspec.builder._parsing_utils import parse_order_expression
+from sqlspec.builder._parsing_utils import extract_expression, parse_order_expression
 from sqlspec.exceptions import SQLBuilderError
 
 if TYPE_CHECKING:
@@ -29,7 +29,6 @@ class OrderByClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
     _expression: Optional[exp.Expression]
 
     def order_by(self, *items: Union[str, exp.Ordered, "Column"], desc: bool = False) -> Self:
@@ -58,9 +57,7 @@ class OrderByClauseMixin:
                     order_item = order_item.desc()
             else:
                 # Extract expression from Column objects or use as-is for sqlglot expressions
-                from sqlspec._sql import SQLFactory
-
-                extracted_item = SQLFactory._extract_expression(item)
+                extracted_item = extract_expression(item)
                 order_item = extracted_item
                 if desc and not isinstance(item, exp.Ordered):
                     order_item = order_item.desc()
@@ -75,7 +72,6 @@ class LimitOffsetClauseMixin:
 
     __slots__ = ()
 
-    # Type annotation for PyRight - this will be provided by the base class
     _expression: Optional[exp.Expression]
 
     def limit(self, value: int) -> Self:
@@ -122,7 +118,6 @@ class ReturningClauseMixin:
     """Mixin providing RETURNING clause."""
 
     __slots__ = ()
-    # Type annotation for PyRight - this will be provided by the base class
     _expression: Optional[exp.Expression]
 
     def returning(self, *columns: Union[str, exp.Expression, "Column", "ExpressionWrapper", "Case"]) -> Self:
@@ -145,8 +140,6 @@ class ReturningClauseMixin:
             msg = "RETURNING is only supported for INSERT, UPDATE, and DELETE statements."
             raise SQLBuilderError(msg)
         # Extract expressions from various wrapper types
-        from sqlspec._sql import SQLFactory
-
-        returning_exprs = [SQLFactory._extract_expression(c) for c in columns]
+        returning_exprs = [extract_expression(c) for c in columns]
         self._expression.set("returning", exp.Returning(expressions=returning_exprs))
         return self

sqlspec/builder/mixins/_select_operations.py

@@ -11,7 +11,7 @@ from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
-from sqlspec.builder._parsing_utils import parse_column_expression, parse_table_expression
+from sqlspec.builder._parsing_utils import parse_column_expression, parse_table_expression, to_expression
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters, is_expression
 
@@ -29,7 +29,6 @@ class SelectClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -865,12 +864,9 @@ class Case:
         Returns:
             Self for method chaining.
         """
-        from sqlspec._sql import SQLFactory
-
         cond_expr = exp.maybe_parse(condition) or exp.column(condition) if isinstance(condition, str) else condition
-        val_expr = SQLFactory._to_expression(value)
+        val_expr = to_expression(value)
 
-        # SQLGlot uses exp.If for CASE WHEN clauses, not exp.When
         when_clause = exp.If(this=cond_expr, true=val_expr)
         self._conditions.append(when_clause)
         return self
@@ -884,9 +880,7 @@ class Case:
         Returns:
             Self for method chaining.
         """
-        from sqlspec._sql import SQLFactory
-
-        self._default = SQLFactory._to_expression(value)
+        self._default = to_expression(value)
         return self
 
     def end(self) -> Self:

sqlspec/builder/mixins/_update_operations.py

@@ -6,12 +6,13 @@ table specification, SET clauses, and FROM clauses.
 """
 
 from collections.abc import Mapping
-from typing import Any, Optional, Union, cast
+from typing import Any, Optional, Union
 
 from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters
 
@@ -26,7 +27,6 @@ class UpdateTableClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -58,7 +58,6 @@ class UpdateSetClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 
@@ -93,24 +92,7 @@ class UpdateSetClauseMixin:
                     self.add_parameter(p_value, name=p_name)
             return value_expr
         if hasattr(val, "expression") and hasattr(val, "sql"):
-            # Handle SQL objects (from sql.raw with parameters)
-            expression = getattr(val, "expression", None)
-            if expression is not None and isinstance(expression, exp.Expression):
-                # Merge parameters from SQL object into builder
-                if hasattr(val, "parameters"):
-                    sql_parameters = getattr(val, "parameters", {})
-                    for param_name, param_value in sql_parameters.items():
-                        self.add_parameter(param_value, name=param_name)
-                return cast("exp.Expression", expression)
-            # If expression is None, fall back to parsing the raw SQL
-            sql_text = getattr(val, "sql", "")
-            # Merge parameters even when parsing raw SQL
-            if hasattr(val, "parameters"):
-                sql_parameters = getattr(val, "parameters", {})
-                for param_name, param_value in sql_parameters.items():
-                    self.add_parameter(param_value, name=param_name)
-            parsed_expr = exp.maybe_parse(sql_text)
-            return parsed_expr if parsed_expr is not None else exp.convert(str(sql_text))
+            return extract_sql_object_expression(val, builder=self)
         column_name = col if isinstance(col, str) else str(col)
         if "." in column_name:
             column_name = column_name.split(".")[-1]
@@ -170,7 +152,6 @@ class UpdateFromClauseMixin:
 
     __slots__ = ()
 
-    # Type annotations for PyRight - these will be provided by the base class
     def get_expression(self) -> Optional[exp.Expression]: ...
     def set_expression(self, expression: exp.Expression) -> None: ...
 

sqlspec/builder/mixins/_where_clause.py

@@ -16,6 +16,8 @@ from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.builder._parsing_utils import extract_column_name, parse_column_expression, parse_condition_expression
+from sqlspec.core.parameters import ParameterStyle, ParameterValidator
+from sqlspec.core.statement import SQL
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import (
     has_expression_and_parameters,
@@ -299,15 +301,11 @@ class WhereClauseMixin:
                 raise SQLBuilderError(msg)
 
             # Check if condition contains parameter placeholders
-            from sqlspec.core.parameters import ParameterStyle, ParameterValidator
-
             validator = ParameterValidator()
             param_info = validator.extract_parameters(condition)
 
             if param_info:
                 # String condition with placeholders - create SQL object with parameters
-                from sqlspec import sql as sql_factory
-
                 # Create parameter mapping based on the detected parameter info
                 param_dict = dict(kwargs)  # Start with named parameters
 
@@ -327,7 +325,7 @@ class WhereClauseMixin:
                     param_dict[f"param_{i}"] = value
 
                 # Create SQL object with parameters that will be processed correctly
-                condition = sql_factory.raw(condition, **param_dict)
+                condition = SQL(condition, param_dict)
                 # Fall through to existing SQL object handling logic
 
             elif len(values) == 1 and not kwargs:
@@ -819,15 +817,11 @@ class WhereClauseMixin:
                 raise SQLBuilderError(msg)
 
             # Check if condition contains parameter placeholders
-            from sqlspec.core.parameters import ParameterStyle, ParameterValidator
-
             validator = ParameterValidator()
             param_info = validator.extract_parameters(condition)
 
             if param_info:
                 # String condition with placeholders - create SQL object with parameters
-                from sqlspec import sql as sql_factory
-
                 # Create parameter mapping based on the detected parameter info
                 param_dict = dict(kwargs)  # Start with named parameters
 
@@ -847,7 +841,7 @@ class WhereClauseMixin:
                     param_dict[f"param_{i}"] = value
 
                 # Create SQL object with parameters that will be processed correctly
-                condition = sql_factory.raw(condition, **param_dict)
+                condition = SQL(condition, param_dict)
                 # Fall through to existing SQL object handling logic
 
             elif len(values) == 1 and not kwargs: