Boxes to as to (#1687)

This PR changes the name of these methods to something more precise and
concise. All methods are kept for backward compatibility, but showing a
deprecation error message.

Author: mmatera

mathics/builtin/atomic/strings.py

@@ -398,7 +398,7 @@ def eval(self, boxes, evaluation: Evaluation):
         # handle these expressions.
         # In the first place, this should handle different kind
         # of boxes in different ways.
-        reinput = boxes.boxes_to_text()
+        reinput = boxes.to_text()
         return Expression(SymbolToExpression, String(reinput)).evaluate(evaluation)
 
 

mathics/builtin/box/compilation.py

@@ -23,20 +23,17 @@ def init(self, *args, **kwargs):
         self._elements = args
         self.box_options = kwargs
 
-    # FIXME "boxes_to..." should be renamed "box_to..."
-    # since there is only one box element
-
-    def boxes_to_text(self, elements=None, **options):
+    def to_text(self, elements=None, **options) -> str:
         if elements is None:
             elements = self.elements
         return elements[0].value
 
-    def boxes_to_mathml(self, elements=None, **options):
+    def to_mathml(self, elements=None, **options) -> str:
         if elements is None:
             elements = self.elements
         return elements[0].value
 
-    def boxes_to_tex(self, elements=None, **options):
+    def to_tex(self, elements=None, **options) -> str:
         if elements is None:
             elements = self.elements
         return elements[0].value

mathics/builtin/box/graphics.py

@@ -496,7 +496,7 @@ def elements(self, value):
         self._elements = value
         return self._elements
 
-    def boxes_to_svg(self, elements=None, **options) -> str:
+    def to_svg(self, elements=None, **options) -> str:
         """This is the top-level function that converts a Mathics Expression
         in to something suitable for SVG rendering.
         """
@@ -645,9 +645,7 @@ def init(
         #    self.content = self.content.atom_to_boxes(
         #        SymbolStandardForm, evaluation=self.graphics.evaluation
         #    )
-        self.content_text = self.content.boxes_to_text(
-            evaluation=self.graphics.evaluation
-        )
+        self.content_text = self.content.to_text(evaluation=self.graphics.evaluation)
 
     def extent(self):
         p = self.pos.pos()

mathics/builtin/box/graphics3d.py

@@ -44,7 +44,7 @@ def _prepare_elements(self, elements, options, max_width=None):
 
         return prepare_elements(self, elements, options, max_width)
 
-    def boxes_to_js(self, elements=None, **options):
+    def to_js(self, elements=None, **options):
         """Turn the Graphics3DBox to into a something javascript-ish
         We include enclosing script tagging.
         """

mathics/builtin/box/image.py

@@ -39,19 +39,19 @@ def init(self, image, **kwargs):
     def elements(self):
         return self.image.elements
 
-    def boxes_to_b64text(
+    def to_b64text(
         self, elements: Tuple[BaseElement] = None, **options
     ) -> Tuple[bytes, Tuple[int, int]]:
         """
         Produces a base64 png representation and a tuple with the size of the pillow image
         associated to the object.
         """
-        contents, size = self.boxes_to_png(elements, **options)
+        contents, size = self.to_png(elements, **options)
         encoded = base64.b64encode(contents)
         encoded = b"data:image/png;base64," + encoded
         return (encoded, size)
 
-    def boxes_to_png(self, elements=None, **options) -> Tuple[bytes, Tuple[int, int]]:
+    def to_png(self, elements=None, **options) -> Tuple[bytes, Tuple[int, int]]:
         """
         returns a tuple with the set of bytes with a png representation of the image
         and the scaled size.
@@ -97,24 +97,21 @@ def boxes_to_png(self, elements=None, **options) -> Tuple[bytes, Tuple[int, int]
 
         return (contents, (scaled_width, scaled_height))
 
-    # FIXME "boxes_to..." should be renamed "box_to..."
-    # since there is only one box element
-
-    def boxes_to_text(self, elements=None, **options) -> str:
+    def to_text(self, elements=None, **options) -> str:
         return "-Image-"
 
-    def boxes_to_mathml(self, elements=None, **options) -> str:
-        encoded, size = self.boxes_to_b64text(elements, **options)
+    def to_mathml(self, elements=None, **options) -> str:
+        encoded, size = self.to_b64text(elements, **options)
         decoded = encoded.decode("utf8")
         # see https://tools.ietf.org/html/rfc2397
         return f'<mglyph src="{decoded}" width="{size[0]}px" height="{size[1]}px" />'
 
-    def boxes_to_tex(self, elements=None, **options) -> str:
+    def to_tex(self, elements=None, **options) -> str:
         """
         Store the associated image as a png file and return
         a LaTeX command for including it.
         """
-        data, size = self.boxes_to_png(elements, **options)
+        data, size = self.to_png(elements, **options)
         res = 100  # pixels/cm
         width_str, height_str = (str(n / res).strip() for n in size)
         head = rf"\includegraphics[width={width_str}cm,height={height_str}cm]"

mathics/builtin/colors/color_directives.py

@@ -192,15 +192,15 @@ def create(expr):
     def create_as_style(klass, graphics, item):
         return klass(item)
 
-    def to_css(self):
+    def to_css(self) -> str:
         rgba = self.to_rgba()
         alpha = rgba[3] if len(rgba) > 3 else None
         return (
             r"rgb(%f%%, %f%%, %f%%)" % (rgba[0] * 100, rgba[1] * 100, rgba[2] * 100),
             alpha,
         )
 
-    def to_js(self):
+    def to_js(self) -> str:
         return self.to_rgba()
 
     def to_expr(self):
@@ -635,7 +635,7 @@ def init(self, item=None, *args, **kwargs):
             super(Opacity, self).init(None, item)
         self.opacity = item.elements[0].to_python()
 
-    def to_css(self):
+    def to_css(self) -> str:
         try:
             if 0.0 <= self.opacity <= 1.0:
                 return self.opacity

mathics/builtin/compilation.py

@@ -135,7 +135,7 @@ def __str__(self):
             return "-PythonizedCode-"
         return "-CompiledCode-"
 
-    def boxes_to_text(self, elements=None, **options):
+    def to_text(self, elements=None, **options) -> str:
         if not elements:
             elements = self._elements
         return "-CompiledCode-"

mathics/builtin/compress.py

@@ -38,9 +38,7 @@ def eval(self, expr, evaluation: Evaluation, options: dict):
             string = '"' + expr.value + '"'
         else:
             string = expr.format(evaluation, "System`FullForm")
-            string = string.boxes_to_text(
-                evaluation=evaluation, show_string_characters=True
-            )
+            string = string.to_text(evaluation=evaluation, show_string_characters=True)
         string = string.encode("utf-8")
 
         # TODO Implement other Methods

mathics/builtin/files_io/files.py

@@ -600,7 +600,7 @@ def do_format_output(expr, evaluation):
                 return render_input_form(expr, evaluation)
             except BoxError:
                 boxed_expr = format_element(expr, evaluation, SymbolFullForm)
-                return boxed_expr.boxes_to_text()
+                return boxed_expr.to_text()
 
         text = [do_format_output(expr, evaluation) for expr in exprs.get_sequence()]
         text = "\n".join(text) + "\n"
@@ -1635,7 +1635,7 @@ def eval(self, channel, expr, evaluation: Evaluation):
         for expri in expr.get_sequence():
             result = format_element(expri, evaluation, SymbolOutputForm)
             try:
-                result = result.boxes_to_text(evaluation=evaluation)
+                result = result.to_text(evaluation=evaluation)
             except BoxError:
                 evaluation.message(
                     "General",

mathics/builtin/string/operations.py

@@ -220,7 +220,7 @@ def do_format_output(expr, evaluation):
                         boxed_expr = format_element(expr, evaluation, SymbolOutputForm)
                     except BoxError:
                         boxed_expr = format_element(expr, evaluation, SymbolFullForm)
-                    return boxed_expr.boxes_to_text()
+                    return boxed_expr.to_text()
 
                 return do_format_output(
                     Expression(
@@ -688,7 +688,7 @@ def eval(self, liststr, seps, evaluation):
         for i in range(len(liststr.elements)):
             text = format_element(
                 liststr.elements[i], evaluation, SymbolOutputForm
-            ).boxes_to_text(evaluation=evaluation)
+            ).to_text(evaluation=evaluation)
             if i == len(liststr.elements) - 1:
                 result += text + right
             else: