Boost::Python - Question about object ownership and lifetime

[Stodge]

Hi folks, new to Boost Python and struggling to build a prototype at
work. I thought I'd start with a conceptual question to help clarify
my understanding. I already have a basic prototype working nicely but
I'm having a few issues, which I may post about later.

A brief functional rundown of what I'm trying to prototype. Hopefully
my explanation doesn't get too confusing!

I'm embedding a python module into an application; Python will provide
application logic, responding to events such as timers expiring or the
user clicking widgets.

I have the following classes I'm exporting to Python:

Entity, DerivedEntity, EntityList (contains pointers to Entity).

They all have varying types of copy/constructors, e.g. some are
private, some have non-const copy constructors etc. It's inherited
code that I can't mess with so I'm stuck with it.

So the typical logic flow I'm looking at is:

C++ Application:

- Create an instance of EntityList called entity_list, populate with
many instances of DerivedEntity.
- Create an instance of EntityList called change_list
- Invoke python function passing entity_list and change_list as
parameters

Python:

- For each entity in entity_list:
- Invoke C++ function clone_entity, pass entity as parameter

C++ Application:

- Create clone of entity like this --DerivedEntity* entity_copy
= new DerivedEntity(entity)
- return entity_copy to Python

Back in Python again:

- Apply logic to entity_copy returned from clone_entity C++
function
- If entity_copy updated add to change_list

Back in C++ Application:

- For each new_entity in change_list
- Apply further logic to new_entity
- Delete new_entity pointer
- Clear the change_list

I'm having problems in my prototype - it looks like I have a memory
leak but I'm not sure where. So my question is, what should I be aware
of in this logic flow with regards to object ownership and lifetime?

When I receive entity_copy in Python, returned from clone_entity, what
happens to this object when I insert it into change_list and
subsequently delete the C++ pointer? I don't know how to prove that
the Python object is being deleted and isn't hanging around due to a
lifetime issue,

I guess my main problem is that I'm entirely sure I understand object
ownership - who owns what object when it's created in C++, passed to
Python and then returned back to C++ to be deleted.

So if any of this makes sense, I would greatly appreciated any
suggestions or help. I'm very impressed with Boost Python so far but
my own lack of understanding is holding me back I think.

Thanks again
Mike