I don't think the string representations should have leading and trailing newlines. Was this ever discussed? Other large pretty prints like pandas.DataFrame or numpy.ndarray don't use them either.

No, it wasn't discussed. These implementations were my independent design choices. Have corrected them as per your suggestions.

What is the reason for referencing self through object_dict instead?

Oh, this was a silly mistake wherein I was using the object_dict to study which attributes can be printed for the objects. Continued using that for the rest of the function instead of referencing through self. Sorry about that.

There are some magic numbers going on here, such as the length of the left column (i.e. number of trailing periods). I suspect it has to do with however long the longest line is. There is also a lot of repetition. Let me suggest some refactoring, for e.g. dataset:

    def __str__(self):
        header = "OpenML Dataset"
        header = '{}\n{}\n'.format(header, '=' * len(header))

        openml_url = "{}d/{}".format(openml.config.server[:-len('api/v1/xml')], self.dataset_id)
        fields = [("Name", self.name),
                  ("Version", self.version),
                  ("Format", self.format),
                  ("Upload Date", self.upload_date.replace('T', ' ')),
                  ("Licence", self.licence),
                  ("Download URL", self.url),
                  ("OpenML URL", openml_url),
                  ("Data file", self.data_file),
                  ("Pickle file", self.data_pickle_file),
                  ("# of features", len(self.features))]

        if self.qualities['NumberOfInstances'] is not None:
            fields.append(("# of instances", self.qualities['NumberOfInstances']))

        longest_field_name_length = max(len(name) for name, value in fields)
        field_line_format = "{{:.<{}}}: {{}}".format(longest_field_name_length)
        body = '\n'.join(field_line_format.format(name, value) for name, value in fields)
        return header + body

Note that this refactor incorporates the advice to look at openml.config.server to determine the base_url , discards leading/trailing newlines and directly uses self.

This looks really good. I wanted to do something about the character padding. Wasn't aware of the escape formatting with {{. This is what I was looking for. Thanks a lot!

Use list.insert instead of list.append for optional fields that might be inserted in the middle of a body.
Other than that, it gives identical output (as long as the magic number was indeed determined by the longest field name).

I understood the reasoning behind insert and not append. However, with insert the index number needed to be specified again, which would again be ghost numbers that might become incomprehensible later.
I am therefore now using Pandas Series to create the fields to be printed. Along with a list of strings which independently determines the order in which the field appears and is able to handle a missing value for a (for optional fields).
Just felt that the slightly redundant list of strings is a worthy trade-off for explicit insert indexes. Also, this seems more customizable, in terms of addition/deletion of fields, or reordering. Kindly advise.

I understand where you're coming from. I perhaps should have been more explicit. I would have something like this for flow, where possibly a binary url would come before upload date:

if self.binary_url is not None:
    before_idx = [name for name, value in fields].index("Upload Date")
    fields.insert(before_idx , ("Binary URL": self.binary_url))

that said, it does introduce some work for the developer if they want to find out the full order. Additionally they also have to be careful about ordering if multiple such optional elements should be printed one after another. I think that's where your solution is better.

But can I ask why use pd.Series and not a regular dict?
It adds a lot of additional verbosity (pd.Series({...}) everywhere), and the only use for the series object itself seems to be (unless I missed it) in
fields = list(fields.reindex(order).dropna().iteritems())
Which, if fields was a dict instead, would be replaced by:

fields = [(name, fields[name]) for name in order if fields.get(name) is not None]

if you don't want to print any None values, or

fields = [(name, fields[name]) for name in order if name in fields]

if you want to print None values if they have been explicitly added to the fields dict.

I haven't tested it myself, but I think this small change should keep equivalent behavior while using standard python over pd.Series.

Well, this is completely down to my history with R :/ Ordering by 'rownames' is quite common there and I just rabbit-holed into this particular solution. You're right, I can do the same with a dict representation and use a list comprehension to create the equivalent field variable. Rest remaining the same.
And I think with the current design I don't need to check for a None since I am adding the optional attributes if available and just checking if the relevant key is present or not should suffice.
I'll make this change.

No worries :) I'm still learning to write cleaner Python myself. But whenever I spot easy improvements I really would like them to be done, it just helps so much down the line (easier for maintenance, extending, newcomers, etc.). Sorry for being a hard-ass 😅

Haha! Absolutely understandable and much needed, to be honest. I am learning well ;)

Everything looks good. As these changes are not invasive I would like to hold off a merge until we fix the dev branch. I'll look at that sooner rather than later.