Creating relationships using the backref
Good question, no I hadn't thought about a corollary to the many-to-many add, but that seems useful. I will add it.
 Well, I forgot that the reverse fk descriptor exposes a plain old select query. It seems smelly to me to special case the select query returned by the fk descriptor. Similarly, I don't know that I like the idea to expose a wrapper / subclass with an `add()` method.

So, at the moment, I will say that there is no such method, but that you can do something like:

``` python
def add_child(parent, child):
    child.parent = parent.id
    child.save()
```

Or, generically:

``` python
def add_general(source, reverse_rel, child_inst):
    # source = "father", reverse_rel = "father.children"
    # reverse_rel.field.to_field.name = "id"
    target_val = getattr(source, reverse_rel.field.to_field.name)
    setattr(inst, reverse_field.field.name, target_val)
    inst.save()
```
 Thanks for the response. I ended up with something like this to determine the complimentary relation name.

```
father._meta.reverse_rel['children'].name
```

Which correctly returns `parent` in this context. But your response has me questioning the use of reverse_rel for this purpose. Any issues there?
 That's totally fine as well.

First off, I'd just like to say that peewee is awesome. I'm currently working on a peewee backend for potion, a  REST API library for flask. Here's what I have so far:

https://github.com/biosustain/potion/pull/28

But I'm running into an issue (or possible limitation) of peewee when creating relationships between models. I'm hoping there's an obvious way to do this...

Say I have a self-referencing model such as:

```
class User(Model):
    parent = ForeignKeyField('self', null=True, related_name='children')
    name = CharField()
```

And I'm working with the following instances:

```
father = User.create(name='foo')
son = User.create(name='bar')
```

Potion provides me with the `father` and `son` instances, as well as the
`children` attribute.

The way that the SQLAlchemy backend handles this is to:

```
getattr(father, 'children').append(son)
```

But there doesn't appear to be a way to create a one-to-many relationship
using the backref with peewee. At least I haven't found a way using
`father.children`.

Is there a simple way to do something like what ManyToManyField has like:

```
father.children.add(son)
```

Or is there a way to determine the matching foreign key field on the `son`
instance using only the `father` instance and the `children` attribute?

I would just as well do:

```
son.parent = father
```

But I don't know about the `parent` attribute or that it compliments the
`childlren` attribute. I need a way to determine this.
