rename make_float/make_duration

Author: PhilReinhold

oqpy/base.py

@@ -384,10 +384,10 @@ def __init__(
             ast.BinaryOperator["-"],
         ]:
             # Late import to avoid circular imports.
-            from oqpy.timing import make_duration
+            from oqpy.timing import convert_float_to_duration
 
-            self.lhs = make_duration(self.lhs)
-            self.rhs = make_duration(self.rhs)
+            self.lhs = convert_float_to_duration(self.lhs)
+            self.rhs = convert_float_to_duration(self.rhs)
 
     def to_ast(self, program: Program) -> ast.BinaryExpression:
         """Converts the OQpy expression into an ast node."""

oqpy/classical_types.py

@@ -42,7 +42,7 @@
     optional_ast,
     to_ast,
 )
-from oqpy.timing import make_duration
+from oqpy.timing import convert_float_to_duration
 
 if TYPE_CHECKING:
     from oqpy.program import Program
@@ -321,7 +321,7 @@ def __init__(
         **type_kwargs: Any,
     ) -> None:
         if init_expression is not None:
-            init_expression = make_duration(init_expression)
+            init_expression = convert_float_to_duration(init_expression)
         super().__init__(init_expression, name, *args, **type_kwargs)
 
 
@@ -375,7 +375,9 @@ def __init__(
 
         # Automatically handle Duration array.
         if base_type is DurationVar and kwargs["init_expression"] is not None:
-            kwargs["init_expression"] = (make_duration(i) for i in kwargs["init_expression"])
+            kwargs["init_expression"] = (
+                convert_float_to_duration(i) for i in kwargs["init_expression"]
+            )
 
         super().__init__(
             *args,

oqpy/control_flow.py

@@ -30,7 +30,7 @@
     _ClassicalVar,
     convert_range,
 )
-from oqpy.timing import make_duration
+from oqpy.timing import convert_float_to_duration
 
 ClassicalVarT = TypeVar("ClassicalVarT", bound=_ClassicalVar)
 
@@ -126,7 +126,7 @@ def ForIn(
         set_declaration = convert_range(program, iterator)
     elif isinstance(iterator, Iterable):
         if identifier_type is DurationVar:
-            iterator = (make_duration(i) for i in iterator)
+            iterator = (convert_float_to_duration(i) for i in iterator)
 
         set_declaration = ast.DiscreteSet([to_ast(program, i) for i in iterator])
     else:

oqpy/program.py

@@ -41,7 +41,7 @@
     to_ast,
 )
 from oqpy.pulse import FrameVar, PortVar, WaveformVar
-from oqpy.timing import make_duration, make_float
+from oqpy.timing import convert_float_to_duration, convert_duration_to_float
 
 __all__ = ["Program"]
 
@@ -366,7 +366,7 @@ def delay(
         """Apply a delay to a set of qubits or frames."""
         if not isinstance(qubits_or_frames, Iterable):
             qubits_or_frames = [qubits_or_frames]
-        ast_duration = to_ast(self, make_duration(time))
+        ast_duration = to_ast(self, convert_float_to_duration(time))
         ast_qubits_or_frames = map_to_ast(self, qubits_or_frames)
         self._add_statement(ast.DelayInstruction(ast_duration, ast_qubits_or_frames))
         return self
@@ -400,32 +400,32 @@ def set_phase(self, frame: AstConvertible, phase: AstConvertible) -> Program:
         # such as s^{-1}. For instance, in 2 * oqpy.pi * tppi * DurationVar(1e-8),
         # tppi is a float but has a frequency unit. This will coerce the result type
         # to a float by assuming the duration should be represented in seconds."
-        self.function_call("set_phase", [frame, make_float(phase)])
+        self.function_call("set_phase", [frame, convert_duration_to_float(phase)])
         return self
 
     def shift_phase(self, frame: AstConvertible, phase: AstConvertible) -> Program:
         """Shift the phase of a particular frame."""
-        self.function_call("shift_phase", [frame, make_float(phase)])
+        self.function_call("shift_phase", [frame, convert_duration_to_float(phase)])
         return self
 
     def set_frequency(self, frame: AstConvertible, freq: AstConvertible) -> Program:
         """Set the frequency of a particular frame."""
-        self.function_call("set_frequency", [frame, make_float(freq)])
+        self.function_call("set_frequency", [frame, convert_duration_to_float(freq)])
         return self
 
     def shift_frequency(self, frame: AstConvertible, freq: AstConvertible) -> Program:
         """Shift the frequency of a particular frame."""
-        self.function_call("shift_frequency", [frame, make_float(freq)])
+        self.function_call("shift_frequency", [frame, convert_duration_to_float(freq)])
         return self
 
     def set_scale(self, frame: AstConvertible, scale: AstConvertible) -> Program:
         """Set the amplitude scaling of a particular frame."""
-        self.function_call("set_scale", [frame, make_float(scale)])
+        self.function_call("set_scale", [frame, convert_duration_to_float(scale)])
         return self
 
     def shift_scale(self, frame: AstConvertible, scale: AstConvertible) -> Program:
         """Shift the amplitude scaling of a particular frame."""
-        self.function_call("shift_scale", [frame, make_float(scale)])
+        self.function_call("shift_scale", [frame, convert_duration_to_float(scale)])
         return self
 
     def returns(self, expression: AstConvertible) -> Program:
@@ -480,7 +480,7 @@ def pragma(self, command: str) -> Program:
     def _do_assignment(self, var: AstConvertible, op: str, value: AstConvertible) -> None:
         """Helper function for variable assignment operations."""
         if isinstance(var, classical_types.DurationVar):
-            value = make_duration(value)
+            value = convert_float_to_duration(value)
         var_ast = to_ast(self, var)
         if isinstance(var_ast, ast.IndexExpression):
             assert isinstance(var_ast.collection, ast.Identifier)

oqpy/subroutines.py

@@ -28,7 +28,7 @@
 from oqpy.base import AstConvertible, OQPyExpression, make_annotations, to_ast
 from oqpy.classical_types import OQFunctionCall, _ClassicalVar
 from oqpy.quantum_types import Qubit
-from oqpy.timing import make_duration
+from oqpy.timing import convert_float_to_duration
 
 __all__ = ["subroutine", "annotate_subroutine", "declare_extern", "declare_waveform_generator"]
 
@@ -200,14 +200,14 @@ def call_extern(*call_args: AstConvertible, **call_kwargs: AstConvertible) -> OQ
                 raise TypeError(f"{name}() got multiple values for argument '{k}'.")
 
             if type(arg_types[k_idx]) == ast.DurationType:
-                new_args[k_idx] = make_duration(call_kwargs[k])
+                new_args[k_idx] = convert_float_to_duration(call_kwargs[k])
             else:
                 new_args[k_idx] = call_kwargs[k]
 
         # Casting floats into durations for the non-keyword arguments
         for i, a in enumerate(call_args):
             if type(arg_types[i]) == ast.DurationType:
-                new_args[i] = make_duration(a)
+                new_args[i] = convert_float_to_duration(a)
         return OQFunctionCall(name, new_args, return_type, extern_decl=extern_decl)
 
     return call_extern

oqpy/timing.py

@@ -19,6 +19,7 @@
 
 import contextlib
 from typing import TYPE_CHECKING, Iterator, cast
+import warnings
 
 from openpulse import ast
 
@@ -29,21 +30,30 @@
     from oqpy.program import Program
 
 
-__all__ = ["Box", "make_duration"]
+__all__ = ["Box", "convert_float_to_duration", "convert_float_to_duration", "make_duration"]
 
 
 @contextlib.contextmanager
 def Box(program: Program, duration: AstConvertible | None = None) -> Iterator[None]:
     """Creates a section of the program with a specified duration."""
     if duration is not None:
-        duration = make_duration(duration)
+        duration = convert_float_to_duration(duration)
     program._push()
     yield
     state = program._pop()
     program._add_statement(ast.Box(optional_ast(program, duration), state.body))
 
 
 def make_duration(time: AstConvertible) -> HasToAst:
+    warnings.warn(
+        "make_duration name is deprecated in favor of convert_float_to_duration",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return convert_duration_to_float(time)
+
+
+def convert_float_to_duration(time: AstConvertible) -> HasToAst:
     """Make value into an expression representing a duration."""
     if isinstance(time, (float, int)):
         return OQDurationLiteral(time)
@@ -62,7 +72,7 @@ def make_duration(time: AstConvertible) -> HasToAst:
     )
 
 
-def make_float(value: AstConvertible) -> AstConvertible:
+def convert_duration_to_float(value: AstConvertible) -> AstConvertible:
     if isinstance(value, OQPyExpression) and isinstance(value.type, ast.DurationType):
         value = value / OQDurationLiteral(1)
     return value

tests/test_directives.py

@@ -402,8 +402,8 @@ def test_binary_expressions():
     prog.set(d, d / 5)
     prog.set(d, d + 5e-9)
     prog.set(d, 5e-9 - d)
-    prog.set(d, d + make_duration(10e-9))
-    prog.set(f, d / make_duration(1))
+    prog.set(d, d + convert_float_to_duration(10e-9))
+    prog.set(f, d / convert_float_to_duration(1))
 
     expected = textwrap.dedent(
         """
@@ -840,7 +840,7 @@ def test_box_and_timings():
 
     with pytest.raises(TypeError):
         f = FloatVar(200e-9, "f", needs_declaration=False)
-        make_duration(f.to_ast(prog))
+        convert_float_to_duration(f.to_ast(prog))
 
     expected = textwrap.dedent(
         """
@@ -1567,7 +1567,7 @@ def f(prog: Program, x: IntVar) -> IntVar:
         prog.gate(q1, "x")
     with oqpy.Else(prog):
         prog.annotate(("annotation-in-else"))
-        prog.delay(make_duration(1e-8), q1)
+        prog.delay(convert_float_to_duration(1e-8), q1)
     prog.annotate("annotation-after-if")
 
     prog.annotate("annotation-no-else-before-if")
@@ -1717,8 +1717,8 @@ def test_duration_literal_arithmetic():
     # Test that duration literals can be used as a part of expression.
     port = oqpy.PortVar("myport")
     frame = oqpy.FrameVar(port, 1e9, name="myframe")
-    delay_time = oqpy.make_duration(50e-9)  # 50 ns
-    one_second = oqpy.make_duration(1)  # 1 second
+    delay_time = oqpy.convert_float_to_duration(50e-9)  # 50 ns
+    one_second = oqpy.convert_float_to_duration(1)  # 1 second
     delay_repetition = 10
 
     program = oqpy.Program()
@@ -1744,24 +1744,24 @@ def test_duration_literal_arithmetic():
 
 
 def test_make_duration():
-    assert expr_matches(make_duration(1e-3), OQDurationLiteral(1e-3))
-    assert expr_matches(make_duration(OQDurationLiteral(1e-4)), OQDurationLiteral(1e-4))
+    assert expr_matches(convert_float_to_duration(1e-3), OQDurationLiteral(1e-3))
+    assert expr_matches(convert_float_to_duration(OQDurationLiteral(1e-4)), OQDurationLiteral(1e-4))
 
     class MyExprConvertible:
         def _to_oqpy_expression(self):
             return OQDurationLiteral(1e-5)
 
-    assert expr_matches(make_duration(MyExprConvertible()), OQDurationLiteral(1e-5))
+    assert expr_matches(convert_float_to_duration(MyExprConvertible()), OQDurationLiteral(1e-5))
 
     class MyToAst:
         def to_ast(self):
             return OQDurationLiteral(1e-6)
 
     obj = MyToAst()
-    assert make_duration(obj) is obj
+    assert convert_float_to_duration(obj) is obj
 
     with pytest.raises(TypeError):
-        make_duration("asdf")
+        convert_float_to_duration("asdf")
 
 
 def test_autoencal():