How to use "primaryjoin" without a ForeignKey?

I'm trying to establish a relationship without using an actual ForeignKey. The reason is that a Child instance may or may not have an associated Parent. If it doesn't I want the parent_id property to be able to be something that isn't an actual parent's ID.

When running the following example I get an Exception:

sqlalchemy.exc.NoForeignKeysError: Could not determine join condition between parent/child
tables on relationship Parent.children - there are no foreign keys linking these tables.
Ensure that referencing columns are associated with a ForeignKey or ForeignKeyConstraint,
or specify a 'primaryjoin' expression.

Well, I did specify a primaryjoin expression, but it doesn't seem to help. I believe I followed the documentation precisely.

from sqlalchemy import Column, Integer, create_engine
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    children = relationship('Child', back_populates='parent')

class Child(Base):
    __tablename__ = 'child'
    parent_id = Column(Integer, primary_key=True, default=0)
    other_id = Column(Integer, primary_key=True, default=0)

    parent = relationship('Parent', back_populates='children',
                          primaryjoin='Parent.id == Child.parent_id',
                          foreign_keys=parent_id,
                          remote_side=Parent.id)

engine = create_engine('sqlite://')
Base.metadata.create_all(engine)
db = sessionmaker(engine)()

parent = Parent()
child = Child()
other = Child(other_id=1)
parent.children.append(child)
db.add(parent)
db.add(other)
db.commit()

I think setting the foreign key is only needed, not remote. It is confusing though. Seems you have to configure both sides.

parent_child_conds = dict(primaryjoin="Parent.id == Child.parent_id", foreign_keys="Child.parent_id")


class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    children = relationship('Child', back_populates='parent', **parent_child_conds)

class Child(Base):
    __tablename__ = 'child'
    parent_id = Column(Integer, primary_key=True, default=0)
    other_id = Column(Integer, primary_key=True, default=0)

    parent = relationship('Parent', back_populates='children', **parent_child_conds)

Besides the interesting answer given by Ian, I considered two more options that both use "proper" ForeignKey constructs:

1. Create a dummy parent with id=0 so that a parentless child's ForeignKey has something to point to

2. Give Child an autoincrement integer as PK so that parent_id may be NULL.

I ended up going with option 2. In my example it doesn't make much of a difference, but in the real app the Child had a PK comprised of two FKs into other tables (possibly pointing at nothing) and some other value which became just too messy. Almost always when I come up a multi-column PK I find myself eventually replacing it with an integer autoincrement one, and an additional UniqueConstraint. And some extra mechanics dealing with merges, if necessary.