refactor!: Rename tk2 encoder names to tket

tket-py/src/circuit.rs

@@ -46,7 +46,7 @@ pub fn module(py: Python<'_>) -> PyResult<Bound<'_, PyModule>> {
         "HUGRSerializationError",
         py.get_type::<PyHUGRSerializationError>(),
     )?;
-    m.add("TK1ConvertError", py.get_type::<PyTK1ConvertError>())?;
+    m.add("TK1EncodeError", py.get_type::<PyTk1EncodeError>())?;
 
     Ok(m)
 }
@@ -76,8 +76,8 @@ create_py_exception!(
 );
 
 create_py_exception!(
-    tket::serialize::pytket::Tk1ConvertError,
-    PyTK1ConvertError,
+    tket::serialize::pytket::PytketEncodeError,
+    PyTk1EncodeError,
     "Error type for the conversion between tket and tket1 operations."
 );
 

tket-py/tket/_tket/circuit.pyi

@@ -181,4 +181,4 @@ class HugrError(Exception): ...
 class BuildError(Exception): ...
 class ValidationError(Exception): ...
 class HUGRSerializationError(Exception): ...
-class TK1ConvertError(Exception): ...
+class TK1EncodeError(Exception): ...

tket-py/tket/circuit/__init__.py

@@ -12,7 +12,7 @@
     BuildError,
     ValidationError,
     HUGRSerializationError,
-    TK1ConvertError,
+    TK1EncodeError,
 )
 
 from .build import CircBuild, Command
@@ -33,5 +33,5 @@
     "BuildError",
     "ValidationError",
     "HUGRSerializationError",
-    "TK1ConvertError",
+    "TK1EncodeError",
 ]

tket/src/serialize/pytket.rs

@@ -5,8 +5,8 @@ mod decoder;
 pub mod encoder;
 pub mod extension;
 
-pub use config::{default_encoder_config, Tk1EncoderConfig};
-pub use encoder::Tk1EncoderContext;
+pub use config::{default_encoder_config, PytketEncoderConfig};
+pub use encoder::PytketEncoderContext;
 pub use extension::PytketEmitter;
 
 use hugr::core::HugrNode;
@@ -72,13 +72,13 @@ pub trait TKETDecode: Sized {
     /// non-std operations or types.
     fn encode_with_config(
         circuit: &Circuit,
-        config: Tk1EncoderConfig<Hugr>,
+        config: PytketEncoderConfig<Hugr>,
     ) -> Result<Self, Self::EncodeError>;
 }
 
 impl TKETDecode for SerialCircuit {
-    type DecodeError = Tk1ConvertError;
-    type EncodeError = Tk1ConvertError;
+    type DecodeError = PytketEncodeError;
+    type EncodeError = PytketEncodeError;
 
     fn decode(self) -> Result<Circuit, Self::DecodeError> {
         let mut decoder = Tk1DecoderContext::try_new(&self)?;
@@ -102,31 +102,31 @@ impl TKETDecode for SerialCircuit {
 
     fn encode_with_config(
         circuit: &Circuit,
-        config: Tk1EncoderConfig<Hugr>,
+        config: PytketEncoderConfig<Hugr>,
     ) -> Result<Self, Self::EncodeError> {
-        let mut encoder = Tk1EncoderContext::new(circuit, circuit.parent(), config)?;
+        let mut encoder = PytketEncoderContext::new(circuit, circuit.parent(), config)?;
         encoder.run_encoder(circuit, circuit.parent())?;
         let (serial, _) = encoder.finish(circuit, circuit.parent())?;
         Ok(serial)
     }
 }
 
 /// Load a TKET1 circuit from a JSON file.
-pub fn load_tk1_json_file(path: impl AsRef<Path>) -> Result<Circuit, Tk1ConvertError> {
+pub fn load_tk1_json_file(path: impl AsRef<Path>) -> Result<Circuit, PytketEncodeError> {
     let file = fs::File::open(path)?;
     let reader = io::BufReader::new(file);
     load_tk1_json_reader(reader)
 }
 
 /// Load a TKET1 circuit from a JSON reader.
-pub fn load_tk1_json_reader(json: impl io::Read) -> Result<Circuit, Tk1ConvertError> {
+pub fn load_tk1_json_reader(json: impl io::Read) -> Result<Circuit, PytketEncodeError> {
     let ser: SerialCircuit = serde_json::from_reader(json)?;
     let circ: Circuit = ser.decode()?;
     Ok(circ)
 }
 
 /// Load a TKET1 circuit from a JSON string.
-pub fn load_tk1_json_str(json: &str) -> Result<Circuit, Tk1ConvertError> {
+pub fn load_tk1_json_str(json: &str) -> Result<Circuit, PytketEncodeError> {
     let reader = json.as_bytes();
     load_tk1_json_reader(reader)
 }
@@ -139,7 +139,7 @@ pub fn load_tk1_json_str(json: &str) -> Result<Circuit, Tk1ConvertError> {
 ///
 /// Returns an error if the circuit is not flat or if it contains operations not
 /// supported by pytket.
-pub fn save_tk1_json_file(circ: &Circuit, path: impl AsRef<Path>) -> Result<(), Tk1ConvertError> {
+pub fn save_tk1_json_file(circ: &Circuit, path: impl AsRef<Path>) -> Result<(), PytketEncodeError> {
     let file = fs::File::create(path)?;
     let writer = io::BufWriter::new(file);
     save_tk1_json_writer(circ, writer)
@@ -153,7 +153,7 @@ pub fn save_tk1_json_file(circ: &Circuit, path: impl AsRef<Path>) -> Result<(),
 ///
 /// Returns an error if the circuit is not flat or if it contains operations not
 /// supported by pytket.
-pub fn save_tk1_json_writer(circ: &Circuit, w: impl io::Write) -> Result<(), Tk1ConvertError> {
+pub fn save_tk1_json_writer(circ: &Circuit, w: impl io::Write) -> Result<(), PytketEncodeError> {
     let serial_circ = SerialCircuit::encode(circ)?;
     serde_json::to_writer(w, &serial_circ)?;
     Ok(())
@@ -167,7 +167,7 @@ pub fn save_tk1_json_writer(circ: &Circuit, w: impl io::Write) -> Result<(), Tk1
 ///
 /// Returns an error if the circuit is not flat or if it contains operations not
 /// supported by pytket.
-pub fn save_tk1_json_str(circ: &Circuit) -> Result<String, Tk1ConvertError> {
+pub fn save_tk1_json_str(circ: &Circuit) -> Result<String, PytketEncodeError> {
     let mut buf = io::BufWriter::new(Vec::new());
     save_tk1_json_writer(circ, &mut buf)?;
     let bytes = buf.into_inner().unwrap();
@@ -230,7 +230,7 @@ pub enum OpConvertError<N = hugr::Node> {
 #[derive(derive_more::Debug, Display, Error, From)]
 #[non_exhaustive]
 #[debug(bounds(N: HugrNode))]
-pub enum Tk1ConvertError<N = hugr::Node> {
+pub enum PytketEncodeError<N = hugr::Node> {
     /// Tried to encode a non-dataflow region.
     #[display("Cannot encode non-dataflow region at {region} with type {optype}.")]
     NonDataflowRegion {
@@ -270,7 +270,7 @@ pub enum Tk1ConvertError<N = hugr::Node> {
     },
 }
 
-impl<N> Tk1ConvertError<N> {
+impl<N> PytketEncodeError<N> {
     /// Create a new error with a custom message.
     pub fn custom(msg: impl ToString) -> Self {
         Self::CustomError {

tket/src/serialize/pytket/config.rs

@@ -3,25 +3,25 @@
 mod encoder_config;
 mod type_translators;
 
-pub use encoder_config::Tk1EncoderConfig;
+pub use encoder_config::PytketEncoderConfig;
 pub use type_translators::TypeTranslatorSet;
 
 use crate::serialize::pytket::extension::{
-    BoolEmitter, FloatEmitter, PreludeEmitter, RotationEmitter, Tk1Emitter, Tk2Emitter,
+    BoolEmitter, FloatEmitter, PreludeEmitter, RotationEmitter, Tk1Emitter, TketOpEmitter,
 };
 use hugr::HugrView;
 
 /// Default encoder configuration for [`Circuit`][crate::Circuit]s.
 ///
 /// Contains emitters for std and tket operations.
-pub fn default_encoder_config<H: HugrView>() -> Tk1EncoderConfig<H> {
-    let mut config = Tk1EncoderConfig::new();
+pub fn default_encoder_config<H: HugrView>() -> PytketEncoderConfig<H> {
+    let mut config = PytketEncoderConfig::new();
     config.add_emitter(PreludeEmitter);
     config.add_emitter(BoolEmitter);
     config.add_emitter(FloatEmitter);
     config.add_emitter(RotationEmitter);
     config.add_emitter(Tk1Emitter);
-    config.add_emitter(Tk2Emitter);
+    config.add_emitter(TketOpEmitter);
 
     config.add_type_translator(PreludeEmitter);
     config.add_type_translator(BoolEmitter);

tket/src/serialize/pytket/config/encoder_config.rs

@@ -12,10 +12,10 @@ use hugr::types::{SumType, Type};
 
 use crate::serialize::pytket::encoder::EncodeStatus;
 use crate::serialize::pytket::extension::{set_bits_op, PytketTypeTranslator, RegisterCount};
-use crate::serialize::pytket::{PytketEmitter, Tk1ConvertError};
+use crate::serialize::pytket::{PytketEmitter, PytketEncodeError};
 use crate::Circuit;
 
-use super::super::encoder::{Tk1EncoderContext, TrackedValues};
+use super::super::encoder::{PytketEncoderContext, TrackedValues};
 use super::TypeTranslatorSet;
 use hugr::HugrView;
 use itertools::Itertools;
@@ -27,7 +27,7 @@ use itertools::Itertools;
 /// types, and consts into pytket primitives.
 #[derive(derive_more::Debug)]
 #[debug(bounds(H: HugrView))]
-pub struct Tk1EncoderConfig<H: HugrView> {
+pub struct PytketEncoderConfig<H: HugrView> {
     /// Operation emitters
     #[debug(skip)]
     pub(super) emitters: Vec<Box<dyn PytketEmitter<H>>>,
@@ -41,8 +41,8 @@ pub struct Tk1EncoderConfig<H: HugrView> {
     type_translators: TypeTranslatorSet,
 }
 
-impl<H: HugrView> Tk1EncoderConfig<H> {
-    /// Create a new [`Tk1EncoderConfig`] with no encoders.
+impl<H: HugrView> PytketEncoderConfig<H> {
+    /// Create a new [`PytketEncoderConfig`] with no encoders.
     pub fn new() -> Self {
         Self::default()
     }
@@ -78,7 +78,7 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
     /// Some encoders may not specify an extension, in which case they will be called
     /// for all operations irrespectively of the list returned here.
     ///
-    /// Use [`Tk1EncoderConfig::add_emitter`] to extend this list.
+    /// Use [`PytketEncoderConfig::add_emitter`] to extend this list.
     pub fn supported_extensions(&self) -> impl Iterator<Item = &ExtensionId> {
         self.extension_emitters.keys()
     }
@@ -92,8 +92,8 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
         node: H::Node,
         op: &ExtensionOp,
         circ: &Circuit<H>,
-        encoder: &mut Tk1EncoderContext<H>,
-    ) -> Result<EncodeStatus, Tk1ConvertError<H::Node>> {
+        encoder: &mut PytketEncoderContext<H>,
+    ) -> Result<EncodeStatus, PytketEncodeError<H::Node>> {
         let mut result = EncodeStatus::Unsupported;
         let extension = op.def().extension_id();
         for enc in self.emitters_for_extension(extension) {
@@ -113,8 +113,8 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
     pub fn const_to_pytket(
         &self,
         value: &Value,
-        encoder: &mut Tk1EncoderContext<H>,
-    ) -> Result<Option<TrackedValues>, Tk1ConvertError<H::Node>> {
+        encoder: &mut PytketEncoderContext<H>,
+    ) -> Result<Option<TrackedValues>, PytketEncodeError<H::Node>> {
         let mut values = TrackedValues::default();
         let mut queue = VecDeque::from([value]);
         while let Some(value) = queue.pop_front() {
@@ -197,7 +197,7 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
     }
 }
 
-impl<H: HugrView> Default for Tk1EncoderConfig<H> {
+impl<H: HugrView> Default for PytketEncoderConfig<H> {
     fn default() -> Self {
         Self {
             emitters: Default::default(),

tket/src/serialize/pytket/decoder.rs

@@ -28,7 +28,7 @@ use tket_json_rs::circuit_json::SerialCircuit;
 use tket_json_rs::register;
 
 use super::{
-    OpConvertError, RegisterHash, Tk1ConvertError, METADATA_B_OUTPUT_REGISTERS,
+    OpConvertError, PytketEncodeError, RegisterHash, METADATA_B_OUTPUT_REGISTERS,
     METADATA_B_REGISTERS, METADATA_OPGROUP, METADATA_PHASE, METADATA_Q_OUTPUT_REGISTERS,
     METADATA_Q_REGISTERS,
 };
@@ -57,7 +57,7 @@ pub(super) struct Tk1DecoderContext {
 
 impl Tk1DecoderContext {
     /// Initialize a new [`Tk1Decoder`], using the metadata from a [`SerialCircuit`].
-    pub fn try_new(serialcirc: &SerialCircuit) -> Result<Self, Tk1ConvertError> {
+    pub fn try_new(serialcirc: &SerialCircuit) -> Result<Self, PytketEncodeError> {
         let num_qubits = serialcirc.qubits.len();
         let num_bits = serialcirc.bits.len();
         let sig =
@@ -115,7 +115,7 @@ impl Tk1DecoderContext {
                 check_register(reg)?;
                 Ok(RegisterHash::from(reg))
             })
-            .collect::<Result<Vec<RegisterHash>, Tk1ConvertError>>()?;
+            .collect::<Result<Vec<RegisterHash>, PytketEncodeError>>()?;
 
         // Map each register element to their starting wire.
         let register_wires: HashMap<RegisterHash, Wire> = ordered_registers
@@ -350,9 +350,9 @@ impl Tk1DecoderContext {
 }
 
 /// Only single-indexed registers are supported.
-fn check_register(register: &register::ElementId) -> Result<(), Tk1ConvertError> {
+fn check_register(register: &register::ElementId) -> Result<(), PytketEncodeError> {
     if register.1.len() != 1 {
-        Err(Tk1ConvertError::MultiIndexedRegister {
+        Err(PytketEncodeError::MultiIndexedRegister {
             register: register.0.clone(),
         })
     } else {