Georg Brandl wrote:
What I do not know if it is feasible to give an immutable instance of a builtin class a mutable attribute slot.
As soon as you can mutate an instance, it is not an immutable type anymore. Calling it "immutable" despite will cause trouble. (The same bytes instance could be used somewhere else transparently, e.g. as a function default argument, or cached as a constant local.)
OK, scratch that implementation of my idea.
As for the usefulness, I often have to work with proprietary communication protocols between computer and devices, and there the bytes have no encoding whatsoever
Random bits? It seems to me that protocol means some sort of encoding, formatting, or structuring, some sort of agreed on interpretation, even if private.
(though I agree that most bytes do have a meaningful encoding). However, a class as fundamental as "bytes" should not be burdened with an attribute that may not even apply -- it's easy to make a custom class to represent a (bytes, encoding) pair.
The fundamental problem I am interested in is the separation of raw data from how to use it info. Text encoding of bytes in only one instance, though the most common that pops up on Python list. I had also thought of something like (imcomplete):
class Textbytes: def __init__(self, text, code): if type(text) is str: text = text.encode(code) if type(text) is bytes: self.text = text self.code = code else: raise ValueError() def __str__(self): return self.text.decode(self.code)
b = Textbytes('abc', 'utf8') print(b)
One problem is that it is a lot bulkier than a raw bytes. Leaving that aside, a custom class is just that: custom. Stdlib modules will neither accept nor produce such a wrapper rathar than bytes.
My underlying idea is that maybe the standard Python distribution should promote encapsulation of encoding info with raw bytes to make bug-free usage easier. Adding an attribute was one implementation idea. Adding a standardized wrapper class (at least in a module) would be another.
Terry Jan Reedy