Runtimewarning enable tracemalloc to get the object allocation traceback ошибка

Работаю с PyQt5. Делаю приложение для логирования. Возникает проблема с потоком и asyncio.

При нажатии на кнопку должна запуститься асинхронная функция, которая получает через условия в постоянном цикле файлы на проверку и выводит полученные данные.

Асинхронная функция, которую я вызываю через поток:

async def deathcount():
    PLAYER_DEATH = '.*?Got character ZDOID from (w+) : 0:0'
    log = "c:/.../files/log.txt"
    while True:     
        with open(log, encoding='utf-8', mode='r') as f:
            f.seek(0,2)
            while True:
                line = f.readline()
                if(re.search(PLAYER_DEATH, line)):
                    pname = re.search(PLAYER_DEATH, line).group(1)
                    with open(file, 'a', newline='', encoding='utf-8') as dl:
                        ... ...
                        log(f"{gettime}{pname} умер!")
                await asyncio.sleep(0.2)

PLAYER_DEATH — переменная, хранящая в себе строчку с регулярным выражением.
В постоянном цикле проверяется log.txt, на наличие строки из PLAYER_DEATH.

При нажатии на кнопку должна сработать функция deathcount(), которая в итоге, при положительном ответе, должна вывести результат — log(f"{gettime}{pname} умер!")

Результат выводится с помощью потока, там же и вызываем функцию (deathcount()):
basic.py:

class QTextEditLogger(logging.Handler):

    def __init__(self, parent):
        super().__init__()

        self.PVELogs = QtWidgets.QPlainTextEdit(parent.centralwidget)
        self.PVELogs.setGeometry(QtCore.QRect(40, 50, 801, 491))
        font = QtGui.QFont()
        font.setFamily("Consolas")
        font.setPointSize(10)
        self.PVELogs.setFont(font)
        self.PVELogs.setStyleSheet("background-color: rgb(30, 30, 30); color: rgb(255, 255, 255);")
        self.PVELogs.setReadOnly(True)
        self.PVELogs.setPlainText("")
        self.PVELogs.setObjectName("PVELogs")

    def emit(self, record):
        msg = self.format(record)
        self.PVELogs.appendPlainText(msg)

class PVP(QtWidgets.QMainWindow, QWidget, MainInterface):
    def __init__(self):
        super().__init__()

        self.setupUi(self) #init gui

        # logging
        logTextBox = QTextEditLogger(self)
        #logTextBox.setFormatter(logging.Formatter(f'{gettime}%(message)s'))
        logging.getLogger().addHandler(logTextBox)
        logging.getLogger().setLevel(logging.DEBUG)

        root_logger= logging.getLogger()
        root_logger.setLevel(logging.DEBUG)
        handler = logging.FileHandler('PVPLog.log', 'w', 'utf-8') 
        handler.setFormatter(logging.Formatter('%(name)s, %(asctime)s, [%(levelname)s], %(message)s'))
        root_logger.addHandler(handler)

        self.PVELogs.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse) 

        self.thread = WorkThread()
        self.thread.threadSignal.connect(self.func2)           
        self.onPVE.clicked.connect(self.func1)      

    def func1(self):
        self.thread.start()

    def func2(self, value):
        deathcount() # Вызываем функцию ! ! !

class WorkThread(QtCore.QThread):
    threadSignal = QtCore.pyqtSignal(int)

    def __init__(self):
        super().__init__()

    def run(self):     
        for i in range(10):
            self.msleep(200)
            self.threadSignal.emit(i)

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    mw = PVP()
    mw.show()

    sys.exit(app.exec())
    
loop = asyncio.new_event_loop()
loop.create_task(deathcount())
asyncio.set_event_loop(loop)

В конце файла создал новый цикл событий, советуясь данной темы

В конце асинхронной функции стоит ожидание (await asyncio.sleep(0.2)).
Но в итоге всё равно что-то не так.

c:......programmabasic.py:132: RuntimeWarning: coroutine 'deathcount' was never awaited
  deathcount()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

Попробовал вызвать цикл в самой функции func2:

def func2(self, value):
    loop = asyncio.new_event_loop()
    loop.create_task(deathcount())
    asyncio.set_event_loop(loop)

Уже другой результат, так ещё в приложение появились интересные строчки:

C:UsersStepanAppDataLocalProgramsPythonPython39libasynciobase_events.py:667: RuntimeWarning: coroutine 'deathcount' was never awaited
  self._ready.clear()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

Весь код

This article discusses the error ‘RuntimeWarning: Enable tracemalloc to get the object allocation traceback‘ in Python. If you are facing the same problem, check out the information below to find out the cause of this error and how to fix it by using the keyword ‘await‘. 

The cause of this error

First, we need to know that ‘asyncio‘ is a library for writing concurrent code using the async/await syntax. The sleep() method of this module is used to delay the currently executing task and allow another task to be executed.

Syntax:

asyncio.sleep(delay, result=None)

The reason why we received the error is that we forgot to use the “await” keyword before the sleep() method.

To illustrate, let me reproduce the error:

import asyncio

async def main():
    print('Loading…')
    
    asyncio.sleep(3)    
    print('Welcome to our site. We are LearnShareIT!')

asyncio.run(main())

Output:

RuntimeWarning: Enable tracemalloc to get the object allocation traceback

To fix this problem, you just need to add the keyword ‘await‘ before calling the sleep() method.

The ‘await‘ keyword is used as the signal to mark the breakpoint. It allows a coroutine to temporarily suspend execution and allow the program to return to it later.

Continuing with the example above, let’s see how we fix this problem:

import asyncio

async def main():
  
    print('Loading…')
    # Add the 'await' keyword in front of the asyncio.sleep() method
    await asyncio.sleep(3)
 
    print('Welcome to our site. We are LearnShareIT!')

asyncio.run(main())

Output:

At this point the error seems to have been solved with just a small change in the code. 

We set the block time to three seconds in the sleep() method. As you can see, the message ‘Loading…‘ appears first, then after ‘3‘ seconds message ‘Welcome to our site. We are LearnShareIT!‘ is printed.

Summary

To sum up, that’s all we want to talk about the error ‘RuntimeWarning: Enable tracemalloc to get the object allocation traceback‘ in Python. To solve this problem, you have to use the ‘await‘ keyword before calling the asyncio.sleep() method. Try it out in your project and see the results. Hopefully, the information we provide in this post will be helpful to you.

Maybe you are interested:

• RuntimeError: dictionary changed size during iteration
• Statements must be separated by newlines or semicolons

Have you ever encountered a warning message in your Python code that reads “Runtime Warning: Enable tracemalloc to get the object allocation traceback”? If so, you’re not alone. This warning can be confusing for many Python developers, but it’s actually a helpful tool to use in your code.

What is tracemalloc?

Tracemalloc is a module in Python that allows you to trace memory usage in your code. It tracks memory allocation and deallocation of objects in your code. It also provides information about where the memory was allocated, the size of the allocation, and the traceback of the allocation.

Tracemalloc is particularly useful when you’re trying to diagnose memory leaks or performance issues in your code. By tracking memory allocation, you can see where object creation happens and what is using up the most memory. This information can help you identify the source of a memory leak or performance issue and allow you to make changes to your code to improve memory usage.

Enabling tracemalloc is easy. You simply need to import the tracemalloc module and call the tracemalloc.start() function. For example:

import tracemalloc
tracemalloc.start()

After calling tracemalloc.start(), tracemalloc will begin tracking memory allocation in your code. You can stop tracemalloc by calling tracemalloc.stop().

Getting the object allocation traceback

Once tracemalloc is enabled, you can use the tracemalloc.get_traced_memory() function to get information about memory usage in your code. This function returns a tuple with two values: the current size of allocated memory, and a list of traceback objects. Each traceback object contains information about an allocation, including the filename, line number, and function name of the allocation.

Here’s an example of how to use tracemalloc.get_traced_memory():

import tracemalloc

tracemalloc.start()

# Your code here

current, peak = tracemalloc.get_traced_memory()
print("Current memory usage is", current / 10**6, "MB")
print("Peak was", peak / 10**6, "MB")

traces = tracemalloc.get_traced_memory()[1]
for trace in traces[:3]:
    print("File:", trace.filename)
    print("Line:", trace.lineno)
    print("Function:", trace.name)
    print()

tracemalloc.stop()

In this example, we start tracemalloc and run our code. Then, we use tracemalloc.get_traced_memory() to get information about memory usage, including the current size of allocated memory and the peak memory usage. We then print out the filename, line number, and function name of the three largest allocations.

When do we encounter “Runtime Warning: Enable tracemalloc to get the object allocation traceback”

You will encounter the “Runtime Warning: Enable tracemalloc to get the object allocation traceback” message in Python when the interpreter is unable to track the memory allocation of an object, due to the absence of enabling of tracemalloc.

Tracemalloc is used to trace memory allocation in your Python code and provides information about where the memory was allocated, the size of the allocation, and the traceback of the allocation. When tracemalloc is not enabled, the interpreter can’t provide this information and generates the warning message.

Here’s an example of when you might encounter this warning:

import sys

x = [1, 2, 3, 4, 5]
print(sys.getobjects(0))

In this example, the sys.getobjects(0) function returns information about the memory allocation of all objects in the program. When you run this code, you’ll see the “Runtime Warning: Enable tracemalloc to get the object allocation traceback” message, indicating that tracemalloc is not enabled, and the memory allocation information is not available.

To avoid this warning, you need to enable tracemalloc before using sys.getobjects(0) or any other function that requires memory allocation information:

import sys
import tracemalloc

tracemalloc.start()

x = [1, 2, 3, 4, 5]
print(sys.getobjects(0))

tracemalloc.stop()

In this example, by calling tracemalloc.start() before using sys.getobjects(0), we enable tracemalloc, and the memory allocation information is now available. The warning message is no longer generated, and we can successfully access the memory allocation information of all objects in the program.

“Runtime Warning: Enable tracemalloc to get the object allocation traceback” asyncio

The RuntimeWarning you’re encountering is related to tracemalloc, a built-in Python module for tracing memory usage in Python programs. The warning message is suggesting that you enable tracemalloc to get more information about the allocation of objects in your asyncio program.

Enabling tracemalloc will provide you with a traceback of the allocation of memory for the objects in your code. This can be useful for identifying memory leaks, understanding the performance of your code, and optimizing memory usage.

To enable tracemalloc, you can add the following line of code at the beginning of your program:

import tracemalloc
tracemalloc.start()

Once tracemalloc is enabled, you can use the tracemalloc.get_traced_memory() function to retrieve the current memory usage, and the tracemalloc.get_traced_allocators() function to get a list of all the objects that have been allocated since tracemalloc was started.

It’s important to note that enabling tracemalloc can affect the performance of your program, as it adds overhead to the memory allocation process. You should only enable tracemalloc when you need to debug memory usage, and turn it off when you’re done to avoid performance issues.

FAQs

Conclusion

Tracemalloc is a powerful tool for understanding memory usage in Python. By tracking memory allocation and deallocation, tracemalloc can help you cure memory leaks and performance issues in your code. Enabling tracemalloc is easy, and once enabled, you can

get information about memory usage and the allocation traceback to help you identify and resolve memory-related problems.

It’s important to note that tracemalloc can have a performance impact on your code, as it adds overhead to memory allocation operations. However, this impact is usually very less, especially if you’re only using tracemalloc temporarily while debugging a specific issue.

При запуске проги те бота выходит следующая ошибка:

<coroutine object main at 0x107465310>
sys:1: RuntimeWarning: coroutine 'main' was never awaited
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

Main функция:

async def main(**kwargs):
    bot = Bot(os.environ.get("TOKEN"))
    dp = Dispatcher(bot)

    await register_handlers(dp)

    update = types.Update.to_object(kwargs)
    await process_event(update, dp)

    return 'ok'

Файл запуска setup.py

from os import path

here = path.abspath(path.dirname(__file__))

setup(
    name="bot",
    packages=["bot"],
    entry_points={
        "console_scripts": [
            "bot = bot.bot:main",
            ],
        },
    )

Пробовал разные методны решения, ничего не помогло, может быть кто сталкивался с подобной проблемой?