classiq 0.37.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

classiq/{applications_model_constructors → applications/grover}/grover_model_constructor.py

@@ -8,18 +8,12 @@ from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
-from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_type import QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -32,44 +26,6 @@ _OUTPUT_VARIABLE_NAME = "result"
 _PREDICATE_FUNCTION_NAME = "expr_predicate"
 
 
-def split_registers(
-    register_names: List[str],
-    register_sizes: List[int],
-    input_wire_name: str,
-) -> List[QuantumStatement]:
-    if len(register_names) == 0:
-        return []
-    wires = (
-        [input_wire_name]
-        + [f"split{i}" for i in range(len(register_names) - 2)]
-        + [register_names[-1]]
-    )
-
-    if len(register_names) == 1:
-        return [
-            BindOperation(
-                in_handle=HandleBinding(name=wires[0]),
-                out_handle=HandleBinding(name=wires[1]),
-            )
-        ]
-
-    return [
-        QuantumFunctionCall(
-            function="split",
-            params={
-                "out1_size": Expression(expr=f"{int(register_sizes[i])}"),
-                "out2_size": Expression(expr=f"{int(sum(register_sizes[i + 1:]))}"),
-            },
-            inputs={"in": HandleBinding(name=wires[i])},
-            outputs={
-                "out1": HandleBinding(name=register),
-                "out2": HandleBinding(name=wires[i + 1]),
-            },
-        )
-        for i, register in enumerate(register_names[:-1])
-    ]
-
-
 def _arithmetic_oracle_io_dict(
     definitions: List[Tuple[str, RegisterUserInput]], handle_name: str
 ) -> Dict[str, HandleBinding]:
@@ -89,12 +45,12 @@ def _construct_arithmetic_oracle(
     predicate_function: str,
     definitions: List[Tuple[str, RegisterUserInput]],
 ) -> QuantumFunctionCall:
-    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "vars")
-    predicate_var_binding["res"] = HandleBinding(name="result")
+    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "arg0")
+    predicate_var_binding["res"] = HandleBinding(name="arg1")
     return QuantumFunctionCall(
-        function="simple_oracle",
+        function="phase_oracle",
         inouts={
-            "target": HandleBinding(name="oq"),
+            "target": HandleBinding(name="arg0"),
         },
         operands={
             "predicate": QuantumLambdaFunction(
@@ -117,38 +73,17 @@ def grover_main_port_declarations(
         name: PortDeclaration(
             name=name,
             size=Expression(expr=f"{reg.size}"),
-            quantum_type=QuantumNumeric(),
+            quantum_type=QuantumNumeric(
+                size=Expression(expr=f"{reg.size}"),
+                is_signed=Expression(expr=f"{reg.is_signed}"),
+                fraction_digits=Expression(expr=f"{reg.fraction_places}"),
+            ),
             direction=direction,
         )
         for name, reg in definitions
     }
 
 
-def _generate_variable_declaration_statements(
-    definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[VariableDeclarationStatement]:
-    ret = [VariableDeclarationStatement(name="gsq")]
-    if len(definitions) >= 2:
-        ret += [
-            VariableDeclarationStatement(name=f"split{i}")
-            for i in range(len(definitions) - 2)
-        ]
-    return ret
-
-
-def reinterpret_registers(
-    definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[QuantumStatement]:
-    return [
-        NumericReinterpretationOperation(
-            target=HandleBinding(name=name),
-            fraction_digits=Expression(expr=f"{definition.fraction_places}"),
-            is_signed=Expression(expr=f"{definition.is_signed}"),
-        )
-        for name, definition in definitions
-    ]
-
-
 def construct_grover_model(
     definitions: List[Tuple[str, RegisterUserInput]],
     expression: str,
@@ -170,7 +105,6 @@ def construct_grover_model(
                 name=_PREDICATE_FUNCTION_NAME,
                 port_declarations=predicate_port_decls,
                 body=[
-                    *reinterpret_registers(definitions),
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
@@ -184,23 +118,22 @@ def construct_grover_model(
                     definitions, PortDeclarationDirection.Output
                 ),
                 body=[
-                    *_generate_variable_declaration_statements(definitions),
+                    VariableDeclarationStatement(name="packed_vars"),
                     QuantumFunctionCall(
                         function="allocate",
                         positional_args=[
                             Expression(expr=f"{num_qubits}"),
-                            HandleBinding(name="gsq"),
+                            HandleBinding(name="packed_vars"),
                         ],
                     ),
                     QuantumFunctionCall(
                         function="grover_search",
                         params={
-                            "num_qubits": Expression(expr=f"{num_qubits}"),
                             "reps": Expression(expr=f"{num_reps}"),
                         },
-                        inouts={"gsq": HandleBinding(name="gsq")},
+                        inouts={"packed_vars": HandleBinding(name="packed_vars")},
                         operands={
-                            "oracle_op": QuantumLambdaFunction(
+                            "oracle": QuantumLambdaFunction(
                                 body=[
                                     _construct_arithmetic_oracle(
                                         _PREDICATE_FUNCTION_NAME,
@@ -210,18 +143,14 @@ def construct_grover_model(
                             )
                         },
                     ),
-                    *split_registers(
-                        [name for name, _ in definitions],
-                        [reg.size for _, reg in definitions],
-                        "gsq",
+                    BindOperation(
+                        in_handles=[HandleBinding(name="packed_vars")],
+                        out_handles=[
+                            HandleBinding(name=name) for name, _ in definitions
+                        ],
                     ),
-                    *reinterpret_registers(definitions),
                 ],
             ),
         ],
-        classical_execution_code=f"""
-{_OUTPUT_VARIABLE_NAME} = sample()
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
     )
     return grover_model.get_model()

classiq/applications/libraries/qmci_library.py

@@ -0,0 +1,35 @@
+from typing import cast
+
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+
+from classiq.qmod import (  # type:ignore[attr-defined]
+    QArray,
+    QBit,
+    QCallable,
+    QNum,
+    Z,
+    amplitude_estimation,
+    qfunc,
+)
+
+
+@qfunc
+def qmci(
+    space_transform: QCallable[QArray[QBit], QBit],
+    phase: QNum,
+    packed_vars: QArray[QBit],
+) -> None:
+    amplitude_estimation(
+        lambda reg: Z(reg[reg.len - 1]),
+        lambda reg: space_transform(reg[0 : reg.len - 1], reg[reg.len - 1]),
+        phase,
+        packed_vars,
+    )
+
+
+QMCI_LIBRARY = [
+    cast(
+        NativeFunctionDefinition,
+        qmci.create_model().function_dict["qmci"],
+    ),
+]

classiq/applications/qnn/circuit_utils.py

@@ -5,8 +5,8 @@ from typing import Iterable, List, Tuple, Union
 from torch import Tensor
 
 from classiq.interface.generator.circuit_code.types_and_constants import QasmVersion
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.types import Arguments, Circuit
 from classiq.exceptions import ClassiqQNNError, ClassiqValueError
@@ -95,7 +95,7 @@ def _get_extracted_parameters(obj: CircuitOrExtractedParameters) -> ParametersTu
     # This `if` is for caching
     if isinstance(obj, tuple):
         weight_params, input_params = obj
-    elif isinstance(obj, GeneratedCircuit):
+    elif isinstance(obj, QuantumProgram):
         weight_params, input_params = extract_parameters(obj)
     else:
         raise ClassiqValueError("Invalid object passed to `map_parameters`")

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from torch import Tensor
 
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.circuit_utils import extract_parameters, validate_circuit
 from classiq.applications.qnn.types import ExecuteFunction, PostProcessFunction
@@ -23,7 +23,7 @@ class QuantumGradient(abc.ABC):
         self._execute = execute
         self._post_process = post_process
 
-        circuit = GeneratedCircuit.parse_raw(quantum_program)
+        circuit = QuantumProgram.parse_raw(quantum_program)
         validate_circuit(circuit)
         self._quantum_program = quantum_program
         self._parameters_names = extract_parameters(circuit)

classiq/applications/qnn/types.py

@@ -5,13 +5,13 @@ from torch import Tensor
 
 from classiq.interface.executor.execution_result import ResultsCollection, SavedResult
 
-from classiq import GeneratedCircuit
+from classiq import QuantumProgram
 from classiq.synthesis import SerializedQuantumProgram
 
 Arguments = Dict[str, float]
 MultipleArguments = Tuple[Arguments, ...]
 
-Circuit = GeneratedCircuit
+Circuit = QuantumProgram
 ExecuteFunction = Callable[
     [SerializedQuantumProgram, MultipleArguments], ResultsCollection
 ]

classiq/applications/qsvm/__init__.py

@@ -4,5 +4,9 @@ from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
+from .qsvm_model_constructor import construct_qsvm_model
 
-__all__ = ["QSVMFeatureMapEntanglement"]
+__all__ = [
+    "QSVMFeatureMapEntanglement",
+    "construct_qsvm_model",
+]

classiq/applications/qsvm/qsvm.py

@@ -1,15 +1,12 @@
-from typing import Any, List, Union
+from typing import List
 
-import numpy as np
-
-from classiq.interface.applications.qsvm import DataList, QSVMData, QSVMPreferences
-
-Data = Union[DataList, np.ndarray]
-Labels = Union[List[Any], np.ndarray]
+from classiq.interface.applications.qsvm import Data, Labels, QSVMData, QSVMPreferences
 
 __all__ = [
     "QSVMData",
     "QSVMPreferences",
+    "Data",
+    "Labels",
 ]
 
 

classiq/applications/qsvm/qsvm_data_generation.py

@@ -24,11 +24,8 @@ def generate_data(
 
     results = {}
     for index, s in enumerate(sources):
-        temp = []
-        # for each dimension
-        for point in s:
-            # draw from a gaussian distribution
-            temp.append(np.random.normal(point, std, amount))
+        # for each dimension draw from a gaussian distribution
+        temp = [np.random.normal(point, std, amount) for point in s]
         # combine the list of np.arrays
         results[index] = np.array(list(zip(*temp)))
 

classiq/exceptions.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List
+from typing import Iterable, List
 
 _logger = logging.getLogger(__name__)
 
@@ -129,3 +129,45 @@ class ClassiqMismatchIOsError(ClassiqError):
 
 class ClassiqNotImplementedError(ClassiqError, NotImplementedError):
     pass
+
+
+class ClassiqCombOptError(ClassiqError):
+    pass
+
+
+class ClassiqCombOptNoSolutionError(ClassiqError):
+
+    def __init__(self) -> None:
+        super().__init__("There is no valid solution for this optimization problem.")
+
+
+class ClassiqCombOptTrivialProblemError(ClassiqError):
+
+    def __init__(self, solution: List[int]) -> None:
+        super().__init__(
+            message=f"The problem doesn't have free decision variables. "
+            f"The trivial solution is {solution}."
+        )
+
+
+class ClassiqCombOptInvalidEncodingTypeError(ClassiqError):
+
+    def __init__(self, encoding_type: str, valid_types: Iterable[str]) -> None:
+        super().__init__(
+            f"Invalid variable encoding type {encoding_type}. "
+            f"The available encoding types are {list(valid_types)}"
+        )
+
+
+class ClassiqNonNumericCoefficientInPauliError(ClassiqError):
+    pass
+
+
+class ClassiqCombOptNotSupportedProblemError(ClassiqCombOptError):
+    pass
+
+
+class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
+
+    def __init__(self) -> None:
+        super().__init__("Invalid hamiltonian")

classiq/execution/all_hardware_devices.py

@@ -0,0 +1,13 @@
+from typing import List
+
+from classiq.interface.hardware import HardwareInformation
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+
+
+def get_all_hardware_devices() -> List[HardwareInformation]:
+    """
+    Returns a list of all hardware devices known to Classiq.
+    """
+    return async_utils.run(ApiWrapper.call_get_all_hardware_devices())

classiq/executor.py

@@ -13,6 +13,7 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.execution_request import (
     EstimateOperatorsExecution,
     ExecutionRequest,
+    QuantumCodeExecution,
 )
 from classiq.interface.executor.execution_result import (
     ResultsCollection,
@@ -20,19 +21,20 @@ from classiq.interface.executor.execution_result import (
     TaggedEstimationResult,
     TaggedExecutionDetails,
 )
+from classiq.interface.executor.quantum_code import MultipleArguments, QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
-from classiq.interface.executor.quantum_program import MultipleArguments, QuantumProgram
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq.execution.jobs import ExecutionJob
-from classiq.model.model import DEFAULT_RESULT_NAME
 from classiq.synthesis import SerializedQuantumProgram
 
+DEFAULT_RESULT_NAME = "result"
+
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
-ProgramAndResult: TypeAlias = Tuple[QuantumProgram, BatchExecutionResult]
+ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
 BackendPreferencesAndResult: TypeAlias = Tuple[
     BackendPreferencesTypes, int, BatchExecutionResult
 ]
@@ -41,8 +43,8 @@ _MAX_ARGUMENTS_SIZE = 1024
 
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
-) -> GeneratedCircuit:
-    return GeneratedCircuit.parse_raw(quantum_program)
+) -> QuantumProgram:
+    return QuantumProgram.parse_raw(quantum_program)
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
@@ -55,7 +57,7 @@ execute = syncify_function(execute_async)
 
 
 async def _execute_qnn_async_estimate(
-    quantum_program: QuantumProgram,
+    quantum_program: QuantumCode,
     execution_preferences: ExecutionPreferences,
     observables: PauliOperators,
 ) -> ResultsCollection:
@@ -79,11 +81,11 @@ async def _execute_qnn_async_estimate(
 
 
 async def _execute_qnn_async_program(
-    quantum_program: QuantumProgram,
+    quantum_program: QuantumCode,
     execution_preferences: ExecutionPreferences,
 ) -> ResultsCollection:
     request = ExecutionRequest(
-        execution_payload=quantum_program.dict(),
+        execution_payload=QuantumCodeExecution(**quantum_program.dict()),
         preferences=execution_preferences,
     )
 
@@ -154,7 +156,7 @@ def set_initial_values(
 
 
 __all__ = [
-    "QuantumProgram",
+    "QuantumCode",
     "QuantumInstructionSet",
     "execute_qnn",
     "OperatorsEstimation",

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.37.1'
+SEMVER_VERSION = '0.39.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -8,7 +8,9 @@ from classiq.interface.backend.quantum_backend_providers import AnalyzerProvider
 from classiq.interface.chemistry.ground_state_problem import MoleculeProblem
 from classiq.interface.executor.optimizer_preferences import OptimizerPreferences
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
-from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.model.preferences.preferences import (
+    TranspilationOption,
+)
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
@@ -44,7 +46,8 @@ class AnalysisOptionalDevicesParams(HardwareListParams):
 
 class AnalysisHardwareTranspilationParams(pydantic.BaseModel):
     hardware_data: Optional[SynthesisHardwareData]
-    model_preferences: Preferences
+    random_seed: int
+    transpilation_option: TranspilationOption
 
 
 class AnalysisHardwareListParams(AnalysisParams, HardwareListParams):
@@ -87,7 +90,7 @@ class ChemistryGenerationParams(pydantic.BaseModel):
     def initial_point(self) -> Optional[numpy.ndarray]:
         if self.optimizer_preferences.initial_point is not None:
             return numpy.ndarray(
-                self.optimizer_preferences.initial_point  # type: ignore
+                self.optimizer_preferences.initial_point  # type: ignore[arg-type]
             )
         else:
             return None

classiq/interface/analyzer/result.py

@@ -1,13 +1,15 @@
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, List, Literal, Optional, Set, Tuple, Union
 from uuid import UUID
 
 import pydantic
-from pydantic import AnyHttpUrl
+from pydantic import Field
+from typing_extensions import Annotated
 
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 Match = List[List[int]]
 
@@ -18,6 +20,7 @@ class GraphStatus(StrEnum):
 
 
 class GraphResult(VersionedModel):
+    kind: Literal["graph"] = Field(default="graph")
     details: str
 
 
@@ -38,10 +41,6 @@ class QasmCode(pydantic.BaseModel):
     code: str
 
 
-class PreSignedS3Url(VersionedModel):
-    url: AnyHttpUrl
-
-
 class AnalysisStatus(StrEnum):
     NONE = "none"
     SUCCESS = "success"
@@ -79,7 +78,7 @@ class HardwareComparisonInformation(pydantic.BaseModel):
     def validate_equal_length(cls, values: Dict[str, list]) -> Dict[str, list]:
         lengths = list(map(len, values.values()))
         if len(set(lengths)) != 1:
-            raise ValueError("All lists should have the same length")
+            raise ClassiqValueError("All lists should have the same length")
         return values
 
 
@@ -103,10 +102,15 @@ class SingleHardwareInformation(pydantic.BaseModel):
     )
 
 
-class HardwareComparisonData(pydantic.BaseModel):
+class HardwareComparisonData(VersionedModel):
+    kind: Literal["hardware_comparison"] = Field(default="hardware_comparison")
     data: List[SingleHardwareInformation]
 
 
+HardwareComparisonGraphType = Annotated[
+    Union[HardwareComparisonData, GraphResult], Field(discriminator="kind")
+]
+
 _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: Dict[str, str] = {
     s.upper(): s.capitalize() for s in SingleHardwareInformation.__fields__
 }

classiq/interface/applications/qsvm.py

@@ -1,5 +1,13 @@
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Iterable as IterableType, List, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Iterable as IterableType,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
 
 import numpy as np
 import pydantic
@@ -95,11 +103,13 @@ class QSVMData(VersionedModel):
         extra = "forbid"
 
     @pydantic.validator("data", pre=True)
-    def set_data(cls, data):
+    def set_data(cls, data: Union[IterableType, ArrayLike]) -> list:
         return listify(data)
 
     @pydantic.validator("labels", pre=True)
-    def set_labels(cls, labels):
+    def set_labels(
+        cls, labels: Optional[Union[IterableType, ArrayLike]]
+    ) -> Optional[list]:
         if labels is None:
             return None
         else:
@@ -112,3 +122,7 @@ class QSVMTestResult(VersionedModel):
 
 class QSVMPredictResult(VersionedModel):
     data: list  # serialized np.array
+
+
+Data = Union[DataList, np.ndarray]
+Labels = Union[List[Any], np.ndarray]

classiq/interface/ast_node.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.helpers.hashable_pydantic_base_model import (
+    HashablePydanticBaseModel,
+)
+
+
+class SourceReference(pydantic.BaseModel):
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    file_name: Optional[str] = pydantic.Field(default=None)
+
+
+class ASTNode(pydantic.BaseModel):
+    source_ref: Optional[SourceReference] = pydantic.Field(default=None)
+
+
+class HashableASTNode(ASTNode, HashablePydanticBaseModel):
+    pass

classiq/interface/backend/backend_preferences.py

@@ -22,6 +22,8 @@ from classiq.interface.backend.quantum_backend_providers import (
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
+from classiq.exceptions import ClassiqValueError
+
 
 class BackendPreferences(BaseModel):
     # Due to the way the field is currently implemented, i.e. it redefined with different types
@@ -103,7 +105,7 @@ class AwsBackendPreferences(BackendPreferences):
     ) -> str:
         s3_bucket_name = s3_bucket_name.strip()
         if not s3_bucket_name.startswith("amazon-braket-"):
-            raise ValueError('S3 bucket name should start with "amazon-braket-"')
+            raise ClassiqValueError('S3 bucket name should start with "amazon-braket-"')
         return s3_bucket_name
 
     @pydantic.root_validator(pre=True)
@@ -273,7 +275,7 @@ def validate_backend_service_provider(backend_service_provider: Any) -> Provider
         for member in Provider:
             if member.lower() == backend_service_provider.lower():
                 return Provider(member)
-    raise ValueError(
+    raise ClassiqValueError(
         f"""Vendor {backend_service_provider} is not supported.
     The supported providers are {', '.join(Provider)}."""
     )

classiq/interface/backend/pydantic_backend.py

@@ -13,6 +13,8 @@ INVALID_EMAIL_OQC: str = "aa@aa.aa"
 INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
 MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
 
+EXECUTION_PARAMETER_PATTERN = "[_a-z][_a-z0-9]*"
+
 if TYPE_CHECKING:
     PydanticExecutionTimeout = int
     PydanticAwsRoleArn = str
@@ -46,4 +48,4 @@ else:
 
     PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
 
-    PydanticExecutionParameter = pydantic.constr(regex="[_a-z][_a-z0-9]*")
+    PydanticExecutionParameter = pydantic.constr(regex=EXECUTION_PARAMETER_PATTERN)