Remove pretty_name part 1 (#1340)

* Remove pretty_name part 1

* Fix tests

* test changes

* rotation strings

* flaky test

Author: mpharrigan

qualtran/_infra/adjoint_test.py

@@ -135,13 +135,12 @@ def test_call_graph():
 
 def test_names():
     atom = TestAtom()
-    assert atom.pretty_name() == "TestAtom"
+    assert str(atom) == "TestAtom"
     assert cast(Text, atom.wire_symbol(reg=None)).text == "TestAtom"
 
     adj_atom = Adjoint(atom)
-    assert adj_atom.pretty_name() == "TestAtom†"
+    assert str(adj_atom) == "Adjoint(subbloq=TestAtom)"
     assert cast(Text, adj_atom.wire_symbol(reg=None)).text == "TestAtom†"
-    assert str(adj_atom) == "Adjoint(subbloq=TestAtom())"
 
 
 def test_wire_symbol():

qualtran/_infra/bloq.py

@@ -111,7 +111,7 @@ def signature(self) -> 'Signature':
         """
 
     def pretty_name(self) -> str:
-        return self.__class__.__name__
+        return str(self)
 
     def build_composite_bloq(self, bb: 'BloqBuilder', **soqs: 'SoquetT') -> Dict[str, 'SoquetT']:
         """Override this method to define a Bloq in terms of its constituent parts.

qualtran/_infra/composite_bloq_test.py

@@ -446,24 +446,24 @@ def test_add_from(call_decompose):
 --------------------
 Split<1>
   TestParallelCombo<0>.reg -> reg
-  reg[0] -> TestAtom()<2>.q
-  reg[1] -> TestAtom()<3>.q
-  reg[2] -> TestAtom()<4>.q
+  reg[0] -> TestAtom<2>.q
+  reg[1] -> TestAtom<3>.q
+  reg[2] -> TestAtom<4>.q
 --------------------
-TestAtom()<2>
+TestAtom<2>
   Split<1>.reg[0] -> q
   q -> Join<5>.reg[0]
-TestAtom()<3>
+TestAtom<3>
   Split<1>.reg[1] -> q
   q -> Join<5>.reg[1]
-TestAtom()<4>
+TestAtom<4>
   Split<1>.reg[2] -> q
   q -> Join<5>.reg[2]
 --------------------
 Join<5>
-  TestAtom()<2>.q -> reg[0]
-  TestAtom()<3>.q -> reg[1]
-  TestAtom()<4>.q -> reg[2]
+  TestAtom<2>.q -> reg[0]
+  TestAtom<3>.q -> reg[1]
+  TestAtom<4>.q -> reg[2]
   reg -> RightDangle.stuff"""
     )
 

qualtran/_infra/controlled.py

@@ -478,11 +478,6 @@ def wire_symbol(self, reg: Optional[Register], idx: Tuple[int, ...] = tuple()) -
     def adjoint(self) -> 'Bloq':
         return self.subbloq.adjoint().controlled(ctrl_spec=self.ctrl_spec)
 
-    def pretty_name(self) -> str:
-        num_ctrls = self.ctrl_spec.num_qubits
-        ctrl_string = 'C' if num_ctrls == 1 else f'C[{num_ctrls}]'
-        return f'{ctrl_string}[{self.subbloq.pretty_name()}]'
-
     def __str__(self) -> str:
         num_ctrls = self.ctrl_spec.num_qubits
         ctrl_string = 'C' if num_ctrls == 1 else f'C[{num_ctrls}]'

qualtran/_infra/controlled_test.py

@@ -212,32 +212,32 @@ def test_controlled_parallel():
         == """\
 Split<0>
   LeftDangle.reg -> reg
-  reg[0] -> C[TestAtom()]<1>.q
-  reg[1] -> C[TestAtom()]<2>.q
-  reg[2] -> C[TestAtom()]<3>.q
+  reg[0] -> C[TestAtom]<1>.q
+  reg[1] -> C[TestAtom]<2>.q
+  reg[2] -> C[TestAtom]<3>.q
 --------------------
-C[TestAtom()]<1>
+C[TestAtom]<1>
   LeftDangle.ctrl -> ctrl
   Split<0>.reg[0] -> q
-  ctrl -> C[TestAtom()]<2>.ctrl
+  ctrl -> C[TestAtom]<2>.ctrl
   q -> Join<4>.reg[0]
 --------------------
-C[TestAtom()]<2>
-  C[TestAtom()]<1>.ctrl -> ctrl
+C[TestAtom]<2>
+  C[TestAtom]<1>.ctrl -> ctrl
   Split<0>.reg[1] -> q
-  ctrl -> C[TestAtom()]<3>.ctrl
+  ctrl -> C[TestAtom]<3>.ctrl
   q -> Join<4>.reg[1]
 --------------------
-C[TestAtom()]<3>
-  C[TestAtom()]<2>.ctrl -> ctrl
+C[TestAtom]<3>
+  C[TestAtom]<2>.ctrl -> ctrl
   Split<0>.reg[2] -> q
   q -> Join<4>.reg[2]
   ctrl -> RightDangle.ctrl
 --------------------
 Join<4>
-  C[TestAtom()]<1>.q -> reg[0]
-  C[TestAtom()]<2>.q -> reg[1]
-  C[TestAtom()]<3>.q -> reg[2]
+  C[TestAtom]<1>.q -> reg[0]
+  C[TestAtom]<2>.q -> reg[1]
+  C[TestAtom]<3>.q -> reg[2]
   reg -> RightDangle.reg"""
     )
 
@@ -247,7 +247,7 @@ def test_doubly_controlled():
     assert (
         bloq.as_composite_bloq().debug_text()
         == """\
-C[C[TestAtom()]]<0>
+C[C[TestAtom]]<0>
   LeftDangle.ctrl2 -> ctrl2
   LeftDangle.ctrl -> ctrl
   LeftDangle.q -> q

qualtran/_infra/quantum_graph_test.py

@@ -70,4 +70,4 @@ def test_bloq_instance():
     binst_a = BloqInstance(TestAtom(), i=1)
     binst_b = BloqInstance(TestAtom(), i=1)
     assert binst_a == binst_b
-    assert str(binst_a) == 'TestAtom()<1>'
+    assert str(binst_a) == 'TestAtom<1>'

qualtran/bloqs/arithmetic/addition.py

@@ -308,9 +308,6 @@ def on_classical_vals(
     def with_registers(self, *new_registers: Union[int, Sequence[int]]):
         raise NotImplementedError("no need to implement with_registers.")
 
-    def pretty_name(self) -> str:
-        return "c = a + b"
-
     def decompose_from_registers(
         self, *, context: cirq.DecompositionContext, **quregs: NDArray[cirq.Qid]
     ) -> cirq.OP_TREE:
@@ -340,6 +337,11 @@ def __pow__(self, power: int):
             return OutOfPlaceAdder(self.bitsize, is_adjoint=not self.is_adjoint)
         raise NotImplementedError("OutOfPlaceAdder.__pow__ defined only for +1/-1.")
 
+    def wire_symbol(self, reg: Optional[Register], idx: Tuple[int, ...] = tuple()) -> 'WireSymbol':
+        if reg is None:
+            return Text('c=a+b')
+        return super().wire_symbol(reg, idx)
+
 
 @bloq_example(generalizer=ignore_split_join)
 def _add_oop_symb() -> OutOfPlaceAdder:

qualtran/bloqs/arithmetic/hamming_weight.py

@@ -79,9 +79,6 @@ def bit_count_of_bitsize(self) -> SymbolicInt:
             return 1  # worst case
         return self.bitsize.bit_count()
 
-    def pretty_name(self) -> str:
-        return "out = x.bit_count()"
-
     def _three_to_two_adder(self, a, b, c, out) -> cirq.OP_TREE:
         return [
             [cirq.CX(a, b), cirq.CX(a, c)],

qualtran/bloqs/arithmetic/sorting.py

@@ -73,9 +73,6 @@ def signature(self):
             ]
         )
 
-    def pretty_name(self) -> str:
-        return "Cmprtr"
-
     def build_composite_bloq(
         self, bb: 'BloqBuilder', a: 'Soquet', b: 'Soquet'
     ) -> dict[str, 'SoquetT']:
@@ -357,9 +354,6 @@ def num_comparisons(self) -> SymbolicInt:
         logk = bit_length(self.k - 1)
         return (self.k // 2) * ((logk * (logk + 1)) // 2)
 
-    def pretty_name(self) -> str:
-        return "BSort"
-
     def is_symbolic(self):
         return is_symbolic(self.bitsize, self.k)
 

qualtran/bloqs/arithmetic/trigonometric/arcsin.py

@@ -72,9 +72,6 @@ def signature(self):
             ]
         )
 
-    def pretty_name(self) -> str:
-        return "arcsin(x)"
-
     def on_classical_vals(
         self, x: ClassicalValT, result: ClassicalValT
     ) -> Dict[str, ClassicalValT]: