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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (70) hide show
  1. classiq/__init__.py +1 -0
  2. classiq/_internals/api_wrapper.py +24 -6
  3. classiq/_internals/authentication/device.py +6 -3
  4. classiq/_internals/authentication/token_manager.py +21 -5
  5. classiq/_internals/client.py +7 -2
  6. classiq/_internals/config.py +12 -0
  7. classiq/_internals/host_checker.py +1 -1
  8. classiq/_internals/jobs.py +3 -1
  9. classiq/_internals/type_validation.py +3 -6
  10. classiq/analyzer/analyzer.py +1 -0
  11. classiq/analyzer/rb.py +3 -5
  12. classiq/applications_model_constructors/chemistry_model_constructor.py +0 -1
  13. classiq/applications_model_constructors/grover_model_constructor.py +27 -18
  14. classiq/execution/jobs.py +13 -4
  15. classiq/executor.py +3 -2
  16. classiq/interface/_version.py +1 -1
  17. classiq/interface/analyzer/analysis_params.py +0 -6
  18. classiq/interface/analyzer/result.py +0 -4
  19. classiq/interface/backend/backend_preferences.py +2 -2
  20. classiq/interface/backend/quantum_backend_providers.py +1 -1
  21. classiq/interface/execution/resource_estimator.py +7 -0
  22. classiq/interface/execution/result.py +5 -0
  23. classiq/interface/generator/ansatz_library.py +3 -3
  24. classiq/interface/generator/arith/binary_ops.py +1 -3
  25. classiq/interface/generator/expressions/atomic_expression_functions.py +2 -0
  26. classiq/interface/generator/expressions/qmod_qnum_proxy.py +22 -0
  27. classiq/interface/generator/expressions/qmod_sized_proxy.py +2 -12
  28. classiq/interface/generator/functions/core_lib_declarations/quantum_functions/std_lib_functions.py +140 -14
  29. classiq/interface/generator/functions/core_lib_declarations/quantum_operators.py +3 -20
  30. classiq/interface/generator/functions/native_function_definition.py +3 -3
  31. classiq/interface/generator/model/constraints.py +3 -3
  32. classiq/interface/generator/model/preferences/preferences.py +10 -8
  33. classiq/interface/generator/noise_properties.py +5 -5
  34. classiq/interface/generator/qpe.py +5 -5
  35. classiq/interface/generator/quantum_function_call.py +5 -3
  36. classiq/interface/generator/visitor.py +1 -2
  37. classiq/interface/hardware.py +1 -1
  38. classiq/interface/model/native_function_definition.py +2 -24
  39. classiq/interface/model/quantum_expressions/amplitude_loading_operation.py +2 -2
  40. classiq/interface/model/quantum_expressions/arithmetic_operation.py +2 -2
  41. classiq/interface/model/quantum_expressions/control_state.py +38 -0
  42. classiq/interface/model/quantum_expressions/quantum_expression.py +12 -9
  43. classiq/interface/model/quantum_function_call.py +3 -0
  44. classiq/interface/model/quantum_function_declaration.py +3 -3
  45. classiq/interface/model/quantum_if_operation.py +95 -0
  46. classiq/interface/model/validations/handles_validator.py +7 -15
  47. classiq/interface/server/routes.py +10 -6
  48. classiq/model/function_handler.pyi +84 -84
  49. classiq/model/model.py +1 -0
  50. classiq/qmod/__init__.py +4 -1
  51. classiq/qmod/builtins/__init__.py +13 -1
  52. classiq/qmod/builtins/classical_execution_primitives.py +109 -0
  53. classiq/qmod/builtins/classical_functions.py +68 -0
  54. classiq/qmod/builtins/functions.py +47 -21
  55. classiq/qmod/builtins/operations.py +15 -29
  56. classiq/qmod/classical_function.py +40 -0
  57. classiq/qmod/declaration_inferrer.py +5 -2
  58. classiq/qmod/qmod_variable.py +15 -3
  59. classiq/qmod/quantum_callable.py +24 -3
  60. classiq/qmod/quantum_expandable.py +99 -17
  61. classiq/qmod/quantum_function.py +12 -2
  62. classiq/qmod/symbolic.py +109 -107
  63. classiq/qmod/symbolic_expr.py +1 -4
  64. classiq/qmod/symbolic_type.py +8 -0
  65. classiq/quantum_functions/decorators.py +2 -4
  66. classiq/quantum_functions/function_library.py +1 -0
  67. {classiq-0.36.1.dist-info → classiq-0.37.1.dist-info}/METADATA +1 -1
  68. {classiq-0.36.1.dist-info → classiq-0.37.1.dist-info}/RECORD +69 -61
  69. classiq/interface/model/local_variable_declaration.py +0 -7
  70. {classiq-0.36.1.dist-info → classiq-0.37.1.dist-info}/WHEEL +0 -0
classiq/qmod/symbolic.py CHANGED
@@ -1,7 +1,9 @@
1
1
  import sys
2
2
  from typing import Tuple
3
3
 
4
- from classiq.qmod.symbolic_expr import SymbolicExpr, SymbolicTypes
4
+ from classiq.qmod.qmod_parameter import QParamScalar
5
+ from classiq.qmod.symbolic_expr import SymbolicExpr
6
+ from classiq.qmod.symbolic_type import SymbolicTypes
5
7
 
6
8
  pi = SymbolicExpr("pi")
7
9
  E = SymbolicExpr("E")
@@ -11,217 +13,217 @@ EulerGamma = SymbolicExpr("EulerGamma")
11
13
  Catalan = SymbolicExpr("Catalan")
12
14
 
13
15
 
14
- def _symbolic_function(*args: SymbolicTypes) -> SymbolicExpr:
16
+ def symbolic_function(*args: SymbolicTypes) -> QParamScalar:
15
17
  str_args = [str(x) for x in args]
16
- return SymbolicExpr(f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})")
18
+ return QParamScalar(f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})")
17
19
 
18
20
 
19
- def sin(x: SymbolicTypes) -> SymbolicExpr:
20
- return _symbolic_function(x)
21
+ def sin(x: SymbolicTypes) -> QParamScalar:
22
+ return symbolic_function(x)
21
23
 
22
24
 
23
- def cos(x: SymbolicTypes) -> SymbolicExpr:
24
- return _symbolic_function(x)
25
+ def cos(x: SymbolicTypes) -> QParamScalar:
26
+ return symbolic_function(x)
25
27
 
26
28
 
27
- def tan(x: SymbolicTypes) -> SymbolicExpr:
28
- return _symbolic_function(x)
29
+ def tan(x: SymbolicTypes) -> QParamScalar:
30
+ return symbolic_function(x)
29
31
 
30
32
 
31
- def cot(x: SymbolicTypes) -> SymbolicExpr:
32
- return _symbolic_function(x)
33
+ def cot(x: SymbolicTypes) -> QParamScalar:
34
+ return symbolic_function(x)
33
35
 
34
36
 
35
- def sec(x: SymbolicTypes) -> SymbolicExpr:
36
- return _symbolic_function(x)
37
+ def sec(x: SymbolicTypes) -> QParamScalar:
38
+ return symbolic_function(x)
37
39
 
38
40
 
39
- def csc(x: SymbolicTypes) -> SymbolicExpr:
40
- return _symbolic_function(x)
41
+ def csc(x: SymbolicTypes) -> QParamScalar:
42
+ return symbolic_function(x)
41
43
 
42
44
 
43
- def asin(x: SymbolicTypes) -> SymbolicExpr:
44
- return _symbolic_function(x)
45
+ def asin(x: SymbolicTypes) -> QParamScalar:
46
+ return symbolic_function(x)
45
47
 
46
48
 
47
- def acos(x: SymbolicTypes) -> SymbolicExpr:
48
- return _symbolic_function(x)
49
+ def acos(x: SymbolicTypes) -> QParamScalar:
50
+ return symbolic_function(x)
49
51
 
50
52
 
51
- def atan(x: SymbolicTypes) -> SymbolicExpr:
52
- return _symbolic_function(x)
53
+ def atan(x: SymbolicTypes) -> QParamScalar:
54
+ return symbolic_function(x)
53
55
 
54
56
 
55
- def acot(x: SymbolicTypes) -> SymbolicExpr:
56
- return _symbolic_function(x)
57
+ def acot(x: SymbolicTypes) -> QParamScalar:
58
+ return symbolic_function(x)
57
59
 
58
60
 
59
- def asec(x: SymbolicTypes) -> SymbolicExpr:
60
- return _symbolic_function(x)
61
+ def asec(x: SymbolicTypes) -> QParamScalar:
62
+ return symbolic_function(x)
61
63
 
62
64
 
63
- def acsc(x: SymbolicTypes) -> SymbolicExpr:
64
- return _symbolic_function(x)
65
+ def acsc(x: SymbolicTypes) -> QParamScalar:
66
+ return symbolic_function(x)
65
67
 
66
68
 
67
- def sinh(x: SymbolicTypes) -> SymbolicExpr:
68
- return _symbolic_function(x)
69
+ def sinh(x: SymbolicTypes) -> QParamScalar:
70
+ return symbolic_function(x)
69
71
 
70
72
 
71
- def cosh(x: SymbolicTypes) -> SymbolicExpr:
72
- return _symbolic_function(x)
73
+ def cosh(x: SymbolicTypes) -> QParamScalar:
74
+ return symbolic_function(x)
73
75
 
74
76
 
75
- def tanh(x: SymbolicTypes) -> SymbolicExpr:
76
- return _symbolic_function(x)
77
+ def tanh(x: SymbolicTypes) -> QParamScalar:
78
+ return symbolic_function(x)
77
79
 
78
80
 
79
- def coth(x: SymbolicTypes) -> SymbolicExpr:
80
- return _symbolic_function(x)
81
+ def coth(x: SymbolicTypes) -> QParamScalar:
82
+ return symbolic_function(x)
81
83
 
82
84
 
83
- def sech(x: SymbolicTypes) -> SymbolicExpr:
84
- return _symbolic_function(x)
85
+ def sech(x: SymbolicTypes) -> QParamScalar:
86
+ return symbolic_function(x)
85
87
 
86
88
 
87
- def csch(x: SymbolicTypes) -> SymbolicExpr:
88
- return _symbolic_function(x)
89
+ def csch(x: SymbolicTypes) -> QParamScalar:
90
+ return symbolic_function(x)
89
91
 
90
92
 
91
- def asinh(x: SymbolicTypes) -> SymbolicExpr:
92
- return _symbolic_function(x)
93
+ def asinh(x: SymbolicTypes) -> QParamScalar:
94
+ return symbolic_function(x)
93
95
 
94
96
 
95
- def acosh(x: SymbolicTypes) -> SymbolicExpr:
96
- return _symbolic_function(x)
97
+ def acosh(x: SymbolicTypes) -> QParamScalar:
98
+ return symbolic_function(x)
97
99
 
98
100
 
99
- def atanh(x: SymbolicTypes) -> SymbolicExpr:
100
- return _symbolic_function(x)
101
+ def atanh(x: SymbolicTypes) -> QParamScalar:
102
+ return symbolic_function(x)
101
103
 
102
104
 
103
- def acoth(x: SymbolicTypes) -> SymbolicExpr:
104
- return _symbolic_function(x)
105
+ def acoth(x: SymbolicTypes) -> QParamScalar:
106
+ return symbolic_function(x)
105
107
 
106
108
 
107
- def asech(x: SymbolicTypes) -> SymbolicExpr:
108
- return _symbolic_function(x)
109
+ def asech(x: SymbolicTypes) -> QParamScalar:
110
+ return symbolic_function(x)
109
111
 
110
112
 
111
- def exp(x: SymbolicTypes) -> SymbolicExpr:
112
- return _symbolic_function(x)
113
+ def exp(x: SymbolicTypes) -> QParamScalar:
114
+ return symbolic_function(x)
113
115
 
114
116
 
115
- def log(x: SymbolicTypes, base: SymbolicTypes = E) -> SymbolicExpr:
116
- return _symbolic_function(x, base)
117
+ def log(x: SymbolicTypes, base: SymbolicTypes = E) -> QParamScalar:
118
+ return symbolic_function(x, base)
117
119
 
118
120
 
119
- def ln(x: SymbolicTypes) -> SymbolicExpr:
120
- return _symbolic_function(x)
121
+ def ln(x: SymbolicTypes) -> QParamScalar:
122
+ return symbolic_function(x)
121
123
 
122
124
 
123
- def sqrt(x: SymbolicTypes) -> SymbolicExpr:
124
- return _symbolic_function(x)
125
+ def sqrt(x: SymbolicTypes) -> QParamScalar:
126
+ return symbolic_function(x)
125
127
 
126
128
 
127
- def abs(x: SymbolicTypes) -> SymbolicExpr:
128
- return _symbolic_function(x)
129
+ def abs(x: SymbolicTypes) -> QParamScalar:
130
+ return symbolic_function(x)
129
131
 
130
132
 
131
- def floor(x: SymbolicTypes) -> SymbolicExpr:
132
- return _symbolic_function(x)
133
+ def floor(x: SymbolicTypes) -> QParamScalar:
134
+ return symbolic_function(x)
133
135
 
134
136
 
135
- def ceiling(x: SymbolicTypes) -> SymbolicExpr:
136
- return _symbolic_function(x)
137
+ def ceiling(x: SymbolicTypes) -> QParamScalar:
138
+ return symbolic_function(x)
137
139
 
138
140
 
139
- def erf(x: SymbolicTypes) -> SymbolicExpr:
140
- return _symbolic_function(x)
141
+ def erf(x: SymbolicTypes) -> QParamScalar:
142
+ return symbolic_function(x)
141
143
 
142
144
 
143
- def erfc(x: SymbolicTypes) -> SymbolicExpr:
144
- return _symbolic_function(x)
145
+ def erfc(x: SymbolicTypes) -> QParamScalar:
146
+ return symbolic_function(x)
145
147
 
146
148
 
147
- def gamma(x: SymbolicTypes) -> SymbolicExpr:
148
- return _symbolic_function(x)
149
+ def gamma(x: SymbolicTypes) -> QParamScalar:
150
+ return symbolic_function(x)
149
151
 
150
152
 
151
- def beta(x: SymbolicTypes) -> SymbolicExpr:
152
- return _symbolic_function(x)
153
+ def beta(x: SymbolicTypes) -> QParamScalar:
154
+ return symbolic_function(x)
153
155
 
154
156
 
155
- def besselj(x: SymbolicTypes) -> SymbolicExpr:
156
- return _symbolic_function(x)
157
+ def besselj(x: SymbolicTypes) -> QParamScalar:
158
+ return symbolic_function(x)
157
159
 
158
160
 
159
- def bessely(x: SymbolicTypes) -> SymbolicExpr:
160
- return _symbolic_function(x)
161
+ def bessely(x: SymbolicTypes) -> QParamScalar:
162
+ return symbolic_function(x)
161
163
 
162
164
 
163
- def besseli(x: SymbolicTypes) -> SymbolicExpr:
164
- return _symbolic_function(x)
165
+ def besseli(x: SymbolicTypes) -> QParamScalar:
166
+ return symbolic_function(x)
165
167
 
166
168
 
167
- def besselk(x: SymbolicTypes) -> SymbolicExpr:
168
- return _symbolic_function(x)
169
+ def besselk(x: SymbolicTypes) -> QParamScalar:
170
+ return symbolic_function(x)
169
171
 
170
172
 
171
- def dirichlet_eta(x: SymbolicTypes) -> SymbolicExpr:
172
- return _symbolic_function(x)
173
+ def dirichlet_eta(x: SymbolicTypes) -> QParamScalar:
174
+ return symbolic_function(x)
173
175
 
174
176
 
175
- def polygamma(x: SymbolicTypes) -> SymbolicExpr:
176
- return _symbolic_function(x)
177
+ def polygamma(x: SymbolicTypes) -> QParamScalar:
178
+ return symbolic_function(x)
177
179
 
178
180
 
179
- def loggamma(x: SymbolicTypes) -> SymbolicExpr:
180
- return _symbolic_function(x)
181
+ def loggamma(x: SymbolicTypes) -> QParamScalar:
182
+ return symbolic_function(x)
181
183
 
182
184
 
183
- def factorial(x: SymbolicTypes) -> SymbolicExpr:
184
- return _symbolic_function(x)
185
+ def factorial(x: SymbolicTypes) -> QParamScalar:
186
+ return symbolic_function(x)
185
187
 
186
188
 
187
- def binomial(x: SymbolicTypes) -> SymbolicExpr:
188
- return _symbolic_function(x)
189
+ def binomial(x: SymbolicTypes) -> QParamScalar:
190
+ return symbolic_function(x)
189
191
 
190
192
 
191
- def subfactorial(x: SymbolicTypes) -> SymbolicExpr:
192
- return _symbolic_function(x)
193
+ def subfactorial(x: SymbolicTypes) -> QParamScalar:
194
+ return symbolic_function(x)
193
195
 
194
196
 
195
- def primorial(x: SymbolicTypes) -> SymbolicExpr:
196
- return _symbolic_function(x)
197
+ def primorial(x: SymbolicTypes) -> QParamScalar:
198
+ return symbolic_function(x)
197
199
 
198
200
 
199
- def bell(x: SymbolicTypes) -> SymbolicExpr:
200
- return _symbolic_function(x)
201
+ def bell(x: SymbolicTypes) -> QParamScalar:
202
+ return symbolic_function(x)
201
203
 
202
204
 
203
- def bernoulli(x: SymbolicTypes) -> SymbolicExpr:
204
- return _symbolic_function(x)
205
+ def bernoulli(x: SymbolicTypes) -> QParamScalar:
206
+ return symbolic_function(x)
205
207
 
206
208
 
207
- def euler(x: SymbolicTypes) -> SymbolicExpr:
208
- return _symbolic_function(x)
209
+ def euler(x: SymbolicTypes) -> QParamScalar:
210
+ return symbolic_function(x)
209
211
 
210
212
 
211
- def catalan(x: SymbolicTypes) -> SymbolicExpr:
212
- return _symbolic_function(x)
213
+ def catalan(x: SymbolicTypes) -> QParamScalar:
214
+ return symbolic_function(x)
213
215
 
214
216
 
215
- def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> SymbolicExpr: # noqa: N802
216
- return _symbolic_function(*args)
217
+ def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> QParamScalar: # noqa: N802
218
+ return symbolic_function(*args)
217
219
 
218
220
 
219
- def max(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
220
- return _symbolic_function(x, y)
221
+ def max(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
222
+ return symbolic_function(x, y)
221
223
 
222
224
 
223
- def min(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
224
- return _symbolic_function(x, y)
225
+ def min(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
226
+ return symbolic_function(x, y)
225
227
 
226
228
 
227
229
  def logical_and(x: SymbolicTypes, y: SymbolicTypes) -> SymbolicExpr:
classiq/qmod/symbolic_expr.py CHANGED
@@ -1,6 +1,6 @@
1
1
  from __future__ import annotations
2
2
 
3
- from typing import Any, Tuple, Union
3
+ from typing import Any
4
4
 
5
5
 
6
6
  class Symbolic:
@@ -147,6 +147,3 @@ class SymbolicEquality(SymbolicExpr):
147
147
  super().__init__(expr)
148
148
  self.lhs = lhs
149
149
  self.rhs = rhs
150
-
151
-
152
- SymbolicTypes = Union[SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]]
classiq/qmod/symbolic_type.py ADDED
@@ -0,0 +1,8 @@
1
+ from typing import Tuple, Union
2
+
3
+ from classiq.qmod.qmod_parameter import QParam
4
+ from classiq.qmod.symbolic_expr import SymbolicExpr
5
+
6
+ SymbolicTypes = Union[
7
+ QParam, SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]
8
+ ]
classiq/quantum_functions/decorators.py CHANGED
@@ -4,13 +4,11 @@ from classiq.quantum_functions.quantum_function import QuantumFunction
4
4
 
5
5
 
6
6
  @overload
7
- def quantum_function(func: None = None, name: Optional[str] = None) -> Callable:
8
- ...
7
+ def quantum_function(func: None = None, name: Optional[str] = None) -> Callable: ...
9
8
 
10
9
 
11
10
  @overload
12
- def quantum_function(func: Callable, name: Optional[str] = None) -> QuantumFunction:
13
- ...
11
+ def quantum_function(func: Callable, name: Optional[str] = None) -> QuantumFunction: ...
14
12
 
15
13
 
16
14
  def quantum_function(
classiq/quantum_functions/function_library.py CHANGED
@@ -1,4 +1,5 @@
1
1
  """Function library module, implementing facilities for adding user defined functions to the Classiq platform."""
2
+
2
3
  from typing import Any, Dict, List, Tuple, Type, Union
3
4
 
4
5
  from more_itertools import locate
{classiq-0.36.1.dist-info → classiq-0.37.1.dist-info}/METADATA RENAMED
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.1
2
2
  Name: classiq
3
- Version: 0.36.1
3
+ Version: 0.37.1
4
4
  Summary: Classiq's Python SDK for quantum computing
5
5
  Home-page: https://classiq.io
6
6
  License: Proprietary