Inspect python class attributes

Question

I need a way to inspect a class so I can safely identify which attributes are user-defined class attributes. The problem is that functions like dir(), inspect.getmembers() and friends return all class attributes including the pre-defined ones like: __class__, __doc__, __dict__, __hash__. This is of course understandable, and one could argue that I could just make a list of named members to ignore, but unfortunately these pre-defined attributes are bound to change with different versions of Python therefore making my project volnerable to changed in the python project - and I don't like that.

example:

>>> class A: ...   a=10 ...   b=20 ...   def __init__(self): ...     self.c=30 >>> dir(A) ['__doc__', '__init__', '__module__', 'a', 'b'] >>> get_user_attributes(A) ['a','b'] 

In the example above I want a safe way to retrieve only the user-defined class attributes ['a','b'] not 'c' as it is an instance attribute. So my question is... Can anyone help me with the above fictive function get_user_attributes(cls)?

I have spent some time trying to solve the problem by parsing the class in AST level which would be very easy. But I can't find a way to convert already parsed objects to an AST node tree. I guess all AST info is discarded once a class has been compiled into bytecode.

Answer 1

Below is the hard way. Here's the easy way. Don't know why it didn't occur to me sooner.

import inspect  def get_user_attributes(cls):     boring = dir(type('dummy', (object,), {}))     return [item             for item in inspect.getmembers(cls)             if item[0] not in boring] 

---

Here's a start

def get_user_attributes(cls):     boring = dir(type('dummy', (object,), {}))     attrs = {}     bases = reversed(inspect.getmro(cls))        for base in bases:         if hasattr(base, '__dict__'):             attrs.update(base.__dict__)         elif hasattr(base, '__slots__'):             if hasattr(base, base.__slots__[0]):                  # We're dealing with a non-string sequence or one char string                 for item in base.__slots__:                     attrs[item] = getattr(base, item)             else:                  # We're dealing with a single identifier as a string                 attrs[base.__slots__] = getattr(base, base.__slots__)     for key in boring:         del attrs['key']  # we can be sure it will be present so no need to guard this     return attrs 

This should be fairly robust. Essentially, it works by getting the attributes that are on a default subclass of object to ignore. It then gets the mro of the class that's passed to it and traverses it in reverse order so that subclass keys can overwrite superclass keys. It returns a dictionary of key-value pairs. If you want a list of key, value tuples like in inspect.getmembers then just return either attrs.items() or list(attrs.items()) in Python 3.

If you don't actually want to traverse the mro and just want attributes defined directly on the subclass then it's easier:

def get_user_attributes(cls):     boring = dir(type('dummy', (object,), {}))     if hasattr(cls, '__dict__'):         attrs = cls.__dict__.copy()     elif hasattr(cls, '__slots__'):         if hasattr(base, base.__slots__[0]):              # We're dealing with a non-string sequence or one char string             for item in base.__slots__:                 attrs[item] = getattr(base, item)             else:                  # We're dealing with a single identifier as a string                 attrs[base.__slots__] = getattr(base, base.__slots__)     for key in boring:         del attrs['key']  # we can be sure it will be present so no need to guard this     return attrs 

Answer 2

Double underscores on both ends of 'special attributes' have been a part of python before 2.0. It would be very unlikely that they would change that any time in the near future.

class Foo(object):   a = 1   b = 2  def get_attrs(klass):   return [k for k in klass.__dict__.keys()             if not k.startswith('__')             and not k.endswith('__')]  print get_attrs(Foo) 

['a', 'b']