1

I have to port a legacy code ( ~60K LOC) from Python 2 to 3 which has a couple of thousand of structures like below:

class Sample(object):
    __slots__ = ('both', 'advertise')
    class __metaclass__(type):
        __instancecheck__ = classmethod(
                lambda cls, inst: inst in ('both', 'advertise'))
    both = 'both'
    advertise = 'advertise'

This code works fine with Python 2 but doesn't compile with Python 3 and to resolve it I need to change it to 

class Sample(object):
    __slots__ = ('both', 'advertise')
    class __metaclass__(type):
        __instancecheck__ = classmethod(
                lambda cls, inst: inst in ('both', 'advertise'))
    def __init__(self):
        both = 'both'
        advertise = 'advertise'

What would be an efficient way to handle this change given that it has to be done over such a large file multiple times?

We have to consider that there may or may not be a __init__ function definition already for the class and there can be nested class definitions as well.

This is what I have tried so far.

  • 2to3 doesn't recognize this as an issue and hence doesn't change it.
  • One possible way could be to use ast module to modify the parse tree in memory and then use unparse to write back the modified code. But it is not straightforward.
  • If nothing else works, I will consider writing a simple Shell/Python script which will read the source file, make changes and write it back.

Can there be another quick and simple way to handle this change.

ViFI
  • 971
  • 1
  • 11
  • 27
  • 1
    [Metaclasses have changed in Python 3](https://docs.python.org/3/reference/datamodel.html), `__metaclass__` doesn't work anymore. You could also replace the metaclasses (one for each class here) with one common metaclass and use `lambda cls, inst: inst in cls.__slots__)` which should work for all classes. – Georg Schölly Feb 01 '17 at 11:31
  • 1
    And you could also replace the code in `__init__` with `for slot in __slots__: setattr(self, slot, slot)` – Georg Schölly Feb 01 '17 at 11:34

1 Answers1

2

I don't know of any better way than to write a small script. I think the changes are small enough that you can get away with some nice heuristics and don't need the full power of ast.

However, if you have this much repetition of code, I would remove the classes from your code altogether. You can replace them with either a code generator or write a factory function for these classes. This is going to future-proof your code for any changes.

Such a factory could look like this:

class HasStringInstances(type):
    def __instancecheck__(cls, instance):
        return instance in cls.__slots__

def create_special_class(*slots):
    class SpecialClass(object, metaclass=HasStringInstances):
        __slots__ = slots

        def __init__(self):
            for slot in self.__slots__:
                 # assign name as value
                 setattr(self, slot, slot)

    return SpecialClass

Sample = create_special_class('both', 'advertise')
Georg Schölly
  • 124,188
  • 49
  • 220
  • 267
  • Thanks. That sounds like a good feedback. Yes, `ast` seemed too heavyweight for this. Moreover , nodes in the `ast.NodeVisitor` class doesn't have pointer / link to parent, so it seemed difficult to move nodes in the parse tree. – ViFI Feb 01 '17 at 12:13