Remove [De]SerializingArg, GateOp[De]Serializer

Author: verult

cirq-google/cirq_google/__init__.py

@@ -111,12 +111,8 @@
     CIRCUIT_SERIALIZER,
     CircuitSerializer,
     CircuitOpDeserializer,
-    DeserializingArg,
-    GateOpDeserializer,
     CircuitOpSerializer,
-    GateOpSerializer,
     Serializer,
-    SerializingArg,
 )
 
 from cirq_google.workflow import (

cirq-google/cirq_google/json_test_data/spec.py

@@ -26,21 +26,17 @@
         'ConvertToSqrtIswapGates',
         'ConvertToSycamoreGates',
         'ConvertToXmonGates',
-        'DeserializingArg',
         'Engine',
         'EngineJob',
         'EngineProcessor',
         'EngineProgram',
         'FSimPhaseCorrections',
         'NoiseModelFromGoogleNoiseProperties',
         'ProtoVersion',
-        'GateOpSerializer',
-        'GateOpDeserializer',
         'GreedySequenceSearchStrategy',
         'PhasedFSimCalibrationError',
         'PhasedFSimEngineSimulator',
         'PerQubitDepolarizingWithDampedReadoutNoiseModel',
-        'SerializingArg',
         'THETA_ZETA_GAMMA_FLOQUET_PHASED_FSIM_CHARACTERIZATION',
         'ProcessorSampler',
         'ValidatingSampler',

cirq-google/cirq_google/serialization/__init__.py

@@ -16,19 +16,10 @@
 
 from cirq_google.serialization.arg_func_langs import arg_from_proto
 
-
 from cirq_google.serialization.circuit_serializer import CircuitSerializer, CIRCUIT_SERIALIZER
 
-from cirq_google.serialization.op_deserializer import (
-    CircuitOpDeserializer,
-    DeserializingArg,
-    GateOpDeserializer,
-)
+from cirq_google.serialization.op_deserializer import CircuitOpDeserializer
 
-from cirq_google.serialization.op_serializer import (
-    CircuitOpSerializer,
-    GateOpSerializer,
-    SerializingArg,
-)
+from cirq_google.serialization.op_serializer import CircuitOpSerializer
 
 from cirq_google.serialization.serializer import Serializer

cirq-google/cirq_google/serialization/op_deserializer.py

@@ -12,15 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Callable, Dict, List, Optional, Sequence
-from dataclasses import dataclass
+from typing import Any, List
 
 import abc
 import sympy
 
 import cirq
 from cirq_google.api import v2
-from cirq_google.ops.calibration_tag import CalibrationTag
 from cirq_google.serialization import arg_func_langs
 
 
@@ -65,218 +63,6 @@ def from_proto(
         """
 
 
-@dataclass(frozen=True)
-class _DeserializingArg:
-    """HACK: non-deprecated version of DeserializingArg.
-
-    This is used by global gatesets to bypass the behavior that deprecation warnings thrown
-    during module loading fail unit tests.
-    """
-
-    serialized_name: str
-    constructor_arg_name: str
-    value_func: Optional[Callable[[arg_func_langs.ARG_LIKE], Any]] = None
-    required: bool = True
-    default: Any = None
-
-
-@cirq._compat.deprecated_class(
-    deadline='v0.16',
-    fix='Will no longer be used because GateOpDeserializer is deprecated.'
-    ' CircuitSerializer will be the only supported circuit serializer going forward.',
-)
-@dataclass(frozen=True)
-class DeserializingArg(_DeserializingArg):
-    """Specification of the arguments to deserialize an argument to a gate.
-
-    Args:
-        serialized_name: The serialized name of the gate that is being
-            deserialized.
-        constructor_arg_name: The name of the argument in the constructor of
-            the gate corresponding to this serialized argument.
-        value_func: Sometimes a value from the serialized proto needs to
-            converted to an appropriate type or form. This function takes the
-            serialized value and returns the appropriate type. Defaults to
-            None.
-        required: Whether a value must be specified when constructing the
-            deserialized gate. Defaults to True.
-        default: default value to set if the value is not present in the
-            arg.  If set, required is ignored.
-    """
-
-
-class _GateOpDeserializer(OpDeserializer):
-    """HACK: non-deprecated version of GateOpDeserializer.
-
-    This is used by global gatesets to bypass the behavior that deprecation warnings thrown
-    during module loading fail unit tests.
-    """
-
-    def __init__(
-        self,
-        serialized_gate_id: str,
-        gate_constructor: Callable,
-        args: Sequence[DeserializingArg],
-        num_qubits_param: Optional[str] = None,
-        op_wrapper: Callable[
-            [cirq.Operation, v2.program_pb2.Operation], cirq.Operation
-        ] = lambda x, y: x,
-        deserialize_tokens: Optional[bool] = True,
-    ):
-        self._serialized_gate_id = serialized_gate_id
-        self._gate_constructor = gate_constructor
-        self._args = args
-        self._num_qubits_param = num_qubits_param
-        self._op_wrapper = op_wrapper
-        self._deserialize_tokens = deserialize_tokens
-
-    @property
-    def serialized_id(self):
-        return self._serialized_gate_id
-
-    def from_proto(
-        self,
-        proto: v2.program_pb2.Operation,
-        *,
-        arg_function_language: str = '',
-        constants: List[v2.program_pb2.Constant] = None,
-        deserialized_constants: List[Any] = None,  # unused
-    ) -> cirq.Operation:
-        qubits = [v2.qubit_from_proto_id(q.id) for q in proto.qubits]
-        args = self._args_from_proto(proto, arg_function_language=arg_function_language)
-        if self._num_qubits_param is not None:
-            args[self._num_qubits_param] = len(qubits)
-        gate = self._gate_constructor(**args)
-        op = self._op_wrapper(gate.on(*qubits), proto)
-        if self._deserialize_tokens:
-            which = proto.WhichOneof('token')
-            if which == 'token_constant_index':
-                if not constants:
-                    raise ValueError(
-                        'Proto has references to constants table '
-                        'but none was passed in, value ='
-                        f'{proto}'
-                    )
-                op = op.with_tags(
-                    CalibrationTag(constants[proto.token_constant_index].string_value)
-                )
-            elif which == 'token_value':
-                op = op.with_tags(CalibrationTag(proto.token_value))
-        return op
-
-    def _args_from_proto(
-        self, proto: v2.program_pb2.Operation, *, arg_function_language: str
-    ) -> Dict[str, arg_func_langs.ARG_LIKE]:
-        return_args = {}
-        for arg in self._args:
-            if arg.serialized_name not in proto.args:
-                if arg.default:
-                    return_args[arg.constructor_arg_name] = arg.default
-                    continue
-                elif arg.required:
-                    raise ValueError(
-                        f'Argument {arg.serialized_name} '
-                        'not in deserializing args, but is required.'
-                    )
-
-            value = arg_func_langs.arg_from_proto(
-                proto.args[arg.serialized_name],
-                arg_function_language=arg_function_language,
-                required_arg_name=None if not arg.required else arg.serialized_name,
-            )
-
-            if arg.value_func is not None and value is not None:
-                value = arg.value_func(value)
-
-            if value is not None:
-                return_args[arg.constructor_arg_name] = value
-        return return_args
-
-
-@cirq._compat.deprecated_class(
-    deadline='v0.16',
-    fix='Will no longer be supported.'
-    ' CircuitSerializer will be the only supported circuit serializer going forward.',
-)
-class GateOpDeserializer(_GateOpDeserializer):
-    """Describes how to deserialize a proto to a given Gate type.
-
-    Attributes:
-        serialized_gate_id: The id used when serializing the gate.
-    """
-
-    def __init__(
-        self,
-        serialized_gate_id: str,
-        gate_constructor: Callable,
-        args: Sequence[DeserializingArg],
-        num_qubits_param: Optional[str] = None,
-        op_wrapper: Callable[
-            [cirq.Operation, v2.program_pb2.Operation], cirq.Operation
-        ] = lambda x, y: x,
-        deserialize_tokens: Optional[bool] = True,
-    ):
-        """Constructs a deserializer.
-
-        Args:
-            serialized_gate_id: The serialized id of the gate that is being
-                deserialized.
-            gate_constructor: A function that produces the deserialized gate
-                given arguments from args.
-            args: A list of the arguments to be read from the serialized
-                gate and the information required to use this to construct
-                the gate using the gate_constructor above.
-            num_qubits_param: Some gate constructors require that the number
-                of qubits be passed to their constructor. This is the name
-                of the parameter in the constructor for this value. If None,
-                no number of qubits is passed to the constructor.
-            op_wrapper: An optional Callable to modify the resulting
-                GateOperation, for instance, to add tags
-            deserialize_tokens: Whether to convert tokens to
-                CalibrationTags. Defaults to True.
-        """
-        super().__init__(
-            serialized_gate_id,
-            gate_constructor,
-            args,
-            num_qubits_param,
-            op_wrapper,
-            deserialize_tokens,
-        )
-
-    def from_proto(
-        self,
-        proto: v2.program_pb2.Operation,
-        *,
-        arg_function_language: str = '',
-        constants: List[v2.program_pb2.Constant] = None,
-        deserialized_constants: List[Any] = None,  # unused
-    ) -> cirq.Operation:
-        """Turns a cirq_google.api.v2.Operation proto into a GateOperation.
-
-        Args:
-            proto: The proto object to be deserialized.
-            arg_function_language: The `arg_function_language` field from
-                `Program.Language`.
-            constants: The list of Constant protos referenced by constant
-                table indices in `proto`.
-            deserialized_constants: Unused in this method.
-
-        Returns:
-            The deserialized GateOperation represented by `proto`.
-
-        Raises:
-            ValueError: If the proto references a missing constants table, or a required arg is
-                missing.
-        """
-        return super().from_proto(
-            proto,
-            arg_function_language=arg_function_language,
-            constants=constants,
-            deserialized_constants=deserialized_constants,
-        )
-
-
 class CircuitOpDeserializer(OpDeserializer):
     """Describes how to serialize CircuitOperations."""