A new SessionTransaction is started when Session.close() is called: (orm/session.py:595)

        if self._parent is None:
            if not self.session.autocommit:
                self.session.begin()

Although the old SessionTransaction.session = None (orm/session.py:598), a new cycle is created again.

If we are not fixing this, do we have a way to avoid this cycle in application code?

I see that you mentioned the issue of weakref.refs being cleaned previously but I'm not understanding the problem right now. are you suggesting that WeakValueDictionary simply should not be used because the simple fact that weakrefs point to things that are removed is a performance issue ? can you show the reproduction case ?

trying the test now.

I see that you mentioned the issue of weakref.refs being cleaned previously but I'm not understanding the problem right now. are you suggesting that WeakValueDictionary simply should not be used because the simple fact that weakrefs point to things that are removed is a performance issue ? can you show the reproduction case ?

They are designed to be cleaned. There is no performance problem. The problem I am facing is that they are not being cleaned when Session is closed, but only during gc because Session has a ref cycle. And due to the fact that gc may happen any time (especially when many objects are allocated), it messes up the call stack, showing random WeakValueDictionary.remove at the top of any call stacks.

here's the fix:

diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py
index 3c58b4260..b23fca57a 100644
--- a/lib/sqlalchemy/orm/session.py
+++ b/lib/sqlalchemy/orm/session.py
@@ -1317,6 +1317,8 @@ class Session(_SessionClassMethods):
             for transaction in self.transaction._iterate_self_and_parents():
                 transaction.close(invalidate)
 
+        self.transaction = None  # remove cycles
+
     def expunge_all(self):
         """Remove all object instances from this ``Session``.
 

and here's the test:

    def test_session_transaction(self):
        @assert_cycles()
        def go():
            s = Session()
            s.close()

        go()

is there a reason s.close() would not be called on a Session before it is to be discarded?

here's the fix:

diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py
index 3c58b4260..b23fca57a 100644
--- a/lib/sqlalchemy/orm/session.py
+++ b/lib/sqlalchemy/orm/session.py
@@ -1317,6 +1317,8 @@ class Session(_SessionClassMethods):
             for transaction in self.transaction._iterate_self_and_parents():
                 transaction.close(invalidate)
 
+        self.transaction = None  # remove cycles
+
     def expunge_all(self):
         """Remove all object instances from this ``Session``.
 

and here's the test:

    def test_session_transaction(self):
        @assert_cycles()
        def go():
            s = Session()
            s.close()

        go()

is there a reason s.close() would not be called on a Session before it is to be discarded?

I do call s.close() in finally, so there is no problem. But I have tried to do self.transaction = None. It fails some tests in the sqlalchemy test suite.

oh ok, if the new transaction replaced itself then that would happen, let's see

self.transaction = None would fix this issue and I feel like it is the right fix. But I just don't have enough understanding to fix the tests. :(
Not sure if there are better fixes.

Ok right there's the "autobegin" thing that has to be adjusted here.

I can adjust this but I don't think it's appropriate for 1.3 because it is a change in documented behavior. "If this session were created with autocommit=False, a new transaction is immediately begun." that has to change

so in your application, make your own:

def close_session(sess):
   sess.close()
   sess.transaction = None

in 1.4 you won't need the above but it will also be harmless