ByteArray enhancements

Author: mmatera

mathics/autoload/formats/Base64/Export.m

@@ -11,7 +11,7 @@
     strm = OpenWrite[filename];
     If[strm === $Failed, Return[$Failed]];
     data = B64Encode[expr];
-    WriteString[strm, data];    
+    WriteString[strm, data];
     Close[strm];
   ]
 
@@ -21,7 +21,7 @@
 	FunctionChannels -> {"FileNames"},
 	Options -> {"CharacterEncoding", "ByteOrderMark"},
 	DefaultElement -> "Plaintext",
-	BinaryFormat -> True
+	BinaryFormat -> False
 ]
 
 

mathics/builtin/lists.py

@@ -187,21 +187,41 @@ class ByteArray(Builtin):
        <dd> Constructs a byte array where bytes comes from decode a b64 encoded String
     </dl>
 
-    >> A=ByteArray[{1,25,3}]
+    >> A=ByteArray[{1, 25, 3}]
      = ByteArray["ARkD"]
     >> A[[2]]
      = 25
+    >> System`Normal[A]
+     = {1, 25, 3}
+    >> ToString[A]
+     = ByteArray["ARkD"]
+    >> ByteArray["ARkD"]
+     = ByteArray["ARkD"]
     >> B=ByteArray["asy"]
-     = ByteArray["WVhONQ=="]
+     : The first argument in Bytearray[asy] should be a B64 enconded string or a vector of integers.
+     = $Failed
     """
 
     messages = {'aotd': 'Elements in `1` are inconsistent with type Byte',
                 'lend': 'The first argument in Bytearray[`1`] should ' + \
-                         'be a B64 enconded string or a vector of integers',}
+                         'be a B64 enconded string or a vector of integers.',}
 
     def apply_str(self, string, evaluation):
         'ByteArray[string_String]'
-        return Expression("ByteArray", ByteArrayAtom(string.value))
+        try:
+            atom = ByteArrayAtom(string.value)
+        except Exception as e:
+            evaluation.message("ByteArray", 'lend', string)
+            return SymbolFailed
+        return Expression("ByteArray", atom)
+
+    def apply_to_str(self, baa, evaluation):
+        'ToString[ByteArray[baa_ByteArrayAtom]]'
+        return String('ByteArray["' + baa.__str__() + '"]')
+
+    def apply_normal(self, baa, evaluation):
+        'System`Normal[ByteArray[baa_ByteArrayAtom]]'
+        return Expression("List", *[Integer(x) for x in baa.value])
 
     def apply_list(self, values, evaluation):
         'ByteArray[values_List]'
@@ -1067,6 +1087,7 @@ def apply(self, list, i, evaluation):
         indices = i.get_sequence()
         # How to deal with ByteArrays
         if list.get_head_name() == "System`ByteArray":
+            list = list.evaluate(evaluation)
             if len(indices) > 1:
                 print("Part::partd1: Depth of object ByteArray[<3>] " +
                       "is not sufficient for the given part specification.")

mathics/core/expression.py

@@ -2697,33 +2697,33 @@ def __new__(cls, value):
         elif type(value) is list:
             self.value = bytearray(list)
         elif type(value) is str:
-            self.value = base64.b64encode(bytearray(value, 'utf8'))
+            self.value = base64.b64decode(value)
         else:
             raise Exception("value does not belongs to a valid type")
         return self
 
     def __str__(self) -> str:
-        return '"' + base64.b64encode(self.value).decode('utf8') + '"'
+        return base64.b64encode(self.value).decode('utf8')
 
     def boxes_to_text(self, **options) -> str:
-        return '"' + base64.b64encode(self.value).decode('utf8') + '"'
+        return '"' + self.__str__() + '"'
 
     def boxes_to_xml(self, **options) -> str:
-        return encode_mathml(String(base64.b64encode(self.value).decode('utf8')))
+        return encode_mathml(String('"'+self.__str__()+'"'))
 
     def boxes_to_tex(self, **options) -> str:
-        from mathics.builtin import builtins
-        return encode_tex(String(base64.b64encode(self.value).decode('utf8')))
+        return encode_tex(String('"'+self.__str__()+'"'))
 
     def atom_to_boxes(self, f, evaluation):
-        return String('"' + self.__str__() + '"')
+        res = String('""' + self.__str__() + '""')
+        return res
 
     def do_copy(self) -> 'ByteArray':
         return ByteArrayAtom(self.value)
 
     def default_format(self, evaluation, form) -> str:
         value = self.value
-        return value.__str__()
+        return '"' +  value.__str__() + '"'
 
     def get_sort_key(self, pattern_sort=False):
         if pattern_sort:
@@ -2760,6 +2760,7 @@ def user_hash(self, update):
     def __getnewargs__(self):
         return (self.value,)
 
+
 class StringFromPython(String):
     def __new__(cls, value):
         self = super(StringFromPython, cls).__new__(cls, value)