The goal is to compare the power of Python metaclasses with metaprogramming systems of other languages such as Groovy, Xtend, Nemerle, CLOS, OpenJava, BSJ (BackStage Java), Iguana/J, compiler plugins for Scala, Cyan, etc.
Assume class MyMeta is the metaclass of class MyClass. 
Can MyMeta generate code in MyClass that intercepts get and set of MyClass instance attributes?
Can a method of MyMeta be called when MyClass is inherited, even if the subclass metaclass is not MyMeta?
Can a method of MyMeta be called when a MyClass method is overridden in a subclass, even if the subclass metaclass is not MyMeta?
Can a method of MyMeta be called when a method of MyClass uses an attribute that has not been declared?
Can MyMeta handle the AST of MyClass or another equivalent representation?
For example, can MyMeta check if each class method has at most 20 statements? Or add a statement after the second method statement? Or rename a method?
Can MyMeta generate code in MyClass that intercepts get and set of
  MyClass instance attributes?

Yes. That can be done by injecting a __getattribute__ and a __setattr__ methods in the class. But if the attributes are declared in some other form (like, with annotations), it can also create descriptors for each attribute to handle only changes to those attributes. However, it can't trivially guess what are individual  "instance attributes" if those are just defined in the classic way, of being set in code, inside the class' __init__ (but the first approach covers all attributes anyway); 

Can a method of MyMeta be called when MyClass is inherited, even if
  the subclass metaclass is not MyMeta?

A subclass will automatically inherit the MyMeta as their metaclasses. If there is a conflict due to other bases, when using multiple inheritance, having other metaclasses, the subclass can't be created at all. (Unless one creates a suitable metaclass that inherits from both metaclasses, that is). _TL;DR: yes. and no,there is no subclass with a different metaclass than its parents'.

Can a method of MyMeta be called when a MyClass method is overridden
  in a subclass, even if the subclass metaclass is not MyMeta?

There is no such a thing as "subclass's metaclass not being MyMeta". And then, 
the metaclass acts on the subclass creation and can detect method overrides. And, it can even be made to detect method overrides by monkey-patching after the class is created (by having the metaclass implement __setattr__)

Can a method of MyMeta be called when a method of MyClass uses an
  attribute that has not been declared?

Yes, by setting suitable __getattribute__ and __setattr__ methods as given earlier. There is no ready-made functionality for this (and no need for a metaclass as well, just a mixin implementing both methods would work)

Can MyMeta handle the AST of MyClass or another equivalent
  representation? For example, can MyMeta check if each class method has
  at most 20 statements? Or add a statement after the second method
  statement? Or rename a method?

The metaclass is called way after the AST has been created and baked into bytecode. But it can introspect into the methods bytecode to check anything it wants, and it can fetch their source code (if available), and re-generate the AST, and it can recreate other methods to replace the original ones - the substitutes having all-new bytecode. 
That kind of thing, however is rarely, if ever used and sounds like overkill.
A more pythonic approach would be to use decorators, and use the metaclass to auto-apply decorators on methods. These decorators can provide wrapper functions to run preamble and post-call code for each of the methods if needed.
If MyMeta is the MyClass metaclass in Python 3.x, what types of manipulation can MyMeta do with MyClass?