guppy | WYSIWYG mathematics editor | Editor library

I have a tibble, df:

Recently I started having some problems with Django (3.1) tests, which I finally tracked down to some kind of memory leak. I normally run my suite (roughly 4000 tests at the moment) with --parallel=4 which results in a high memory watermark of roughly 3GB (starting from 500MB or so). For auditing purposes, though, I occasionally run it with --parallel=1 - when I do this, the memory usage keeps increasing, ending up over the VM's allocated 6GB.

I spent some time looking at the data and it became clear that the culprit is, somehow, Webtest - more specifically, its response.html and response.forms: each call during the test case might allocate a few MBs (two or three, generally) which don't get released at the end of the test method and, more importantly, not even at the end of the TestCase.

I've tried everything I could think of - gc.collect() with gc.DEBUG_LEAK shows me a whole lot of collectable items, but it frees no memory at all; using delattr() on various TestCase and TestResponse attributes and so on resulted in no change at all, etc.

I'm quite literally at my wits' end, so any pointer to solve this (beside editing the thousand or so tests which use WebTest responses, which is really not feasible) would be very much appreciated.

(please note that I also tried using guppy and tracemalloc and memory_profiler but neither gave me any kind of actionable information.)

I found that one of our EC2 testing instances isn't affected by the problem, so I spent some more time trying to figure this out. Initially, I tried to find the "sensible" potential causes - for instance, the cached template loader, which was enabled on my local VM and disabled on the EC2 instance - without success. Then I went all in: I replicated the EC2 virtualenv (with pip freeze) and the settings (copying the dotenv), and checked out the same commit where the tests were running normally on the EC2.

Et voilà! THE MEMORY LEAK IS STILL THERE!

Now, I'm officially giving up and will use --parallel=2 for future tests until some absolute guru can point me in the right directions.

And now the memory leak is there even with --parallel=2. I guess that's somehow better, since it looks increasingly like it's a system problem rather than an application problem. Doesn't solve it but at least I know it's not my fault.

Thanks to Tim Boddy's reply to this question I tried using chap to figure out what's making memory grow. Unfortunately I can't "read" the results properly but it looks like some non-python library is actually causing the problem. So, this is what I've seen analyzing the core after a few minutes running the tests that I know cause the leak:

I have a guppy strategy which should enter either long (when guppy becomes green under certain conditions) or short (when guppy becomes red under certain conditions). To determine the colour in pine script I used if/else. What the problem is? I'm getting the third type of colour when none of two conditions are met (let's say grey colour) and in the situation where, for example, i get red1=>grey=>red2 My strategy sends signal to close previous trade when red2 occurs and open new one with the same direction. In my strategy grey is not a signal for entering/exiting the position, so i want to make the current 'grey' to be coloured the same way the previous segment was colored until fully opposite condition was met. I tried else na, but those intermediate condition still gives me wrong signals, i also tried to put plotcolor=plotcolor[1] in 'else' but this type of command cannot be placed in pine script. Can please anyone help me to solve this?

I have an array of 100 ints (from 0 to 99) and I implement a Comparable interface. My task now is to confirm that sorting works (even though I know it does). My code is:

I have a large python code base.

At one point I find out (using guppy but that doesn't really matter) that I have an existing instance of my class BigClass.

At this point of the code I do not expect to have any living instances of BigClass since all of them were supposed to be released. I tried calling gc.collect()

How can I trace down where is this instance, why is it still alive, its properties and so on?

I need to iterate over a vector of mutable references; here is a simplified reproduction:

I have a list like this and I want it to change the font-weight to bold of the list item which I was hovering but instead of that it applies the changes for the whole list of all lists of my document (depends on my attempts)

I'm attempting transition my base docker image from centos 7 to alpine, however I receive gcc errors when trying to install pip packages.

This is a snippet of the error received:

This is NOT a duplicate of this. I'm not interested in finding out my memory consumption or the matter, as I'm already doing that below. The question is WHY the memory consumption is like this.

Also, even if I did need a way to profile my memory do note that guppy (the suggested Python memory profiler in the aforementioned link does not support Python 3 and the alternative guppy3 does not give accurate results whatsoever yielding in results such as (see actual sizes below):