From 0e43590ab5c4639eef1bfb8005a134671c41e058 Mon Sep 17 00:00:00 2001 From: Your Name Date: Tue, 3 Mar 2026 09:11:41 +0900 Subject: [PATCH] =?UTF-8?q?feat:=20=EC=83=88=EB=A1=9C=EC=9A=B4=20LLM=20?= =?UTF-8?q?=ED=81=B4=EB=9D=BC=EC=9D=B4=EC=96=B8=ED=8A=B8=EC=99=80=20?= =?UTF-8?q?=EC=99=B8=EB=B6=80=20=EC=9D=B8=ED=8E=98=EC=9D=B8=ED=8C=85=20?= =?UTF-8?q?=EC=9A=94=EC=B2=AD=20=EA=B8=B0=EB=8A=A5=EC=9D=84=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80=ED=95=98=EA=B3=A0,=20=EC=9D=B4=EB=AF=B8=EC=A7=80=20?= =?UTF-8?q?=EC=B2=98=EB=A6=AC=20=EB=A1=9C=EC=A7=81=EC=9D=84=20=EA=B0=9C?= =?UTF-8?q?=EC=84=A0=ED=95=98=EB=A9=B0=20=EB=A1=9C=EA=B1=B0=20C=20?= =?UTF-8?q?=ED=99=95=EC=9E=A5=EC=9D=84=20=EB=8F=84=EC=9E=85=ED=95=98?= =?UTF-8?q?=EA=B3=A0=20=EC=9D=98=EC=A1=B4=EC=84=B1=EC=9D=84=20=EC=97=85?= =?UTF-8?q?=EB=8D=B0=EC=9D=B4=ED=8A=B8=ED=96=88=EC=8A=B5=EB=8B=88=EB=8B=A4?= =?UTF-8?q?.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Edit_PartTimer_log_11276.log | 2 + Edit_PartTimer_log_34628.log | 1 + __pycache__/loggerModule.cpython-311.pyc | Bin 20034 -> 29082 bytes build_log.txt | Bin 0 -> 23272 bytes build_log2.txt | Bin 0 -> 15730 bytes build_log3.txt | Bin 0 -> 13868 bytes build_log4.txt | Bin 0 -> 16166 bytes loggerModule.c | 28367 ++++++++++++++++ loggerModule.cp311-win_amd64.pyd | Bin 0 -> 227840 bytes loggerModule.py | 182 +- .../__pycache__/gemma_client.cpython-311.pyc | Bin 10430 -> 15773 bytes .../image_processor3.cpython-311.pyc | Bin 139351 -> 153810 bytes .../__pycache__/image_worker.cpython-311.pyc | Bin 25477 -> 28490 bytes .../openrouter_client.cpython-311.pyc | Bin 0 -> 28972 bytes .../request_inpaint.cpython-311.pyc | Bin 59843 -> 59755 bytes modules/__pycache__/tray_app.cpython-311.pyc | Bin 14607 -> 15213 bytes modules/gemma_client.py | 180 +- modules/image_processor3.py | 415 +- modules/image_worker.py | 254 +- modules/openrouter_client.py | 709 + modules/request_inpaint.py | 12 +- modules/test/Edit_PartTimer_log_15124.log | 184 + modules/test/Edit_PartTimer_log_17176.log | 183 + modules/test/Edit_PartTimer_log_21308.log | 36 + modules/test/Edit_PartTimer_log_22272.log | 111 + modules/test/Edit_PartTimer_log_24188.log | 111 + modules/test/Edit_PartTimer_log_28972.log | 111 + modules/test/Edit_PartTimer_log_6996.log | 111 + modules/test/Edit_PartTimer_log_9948.log | 186 + modules/test/create_font_preview.py | 3 +- .../inpaint_result_class_test.webp | Bin 0 -> 466228 bytes .../outputs_test/inpaint_result_migan.webp | Bin 0 -> 466228 bytes .../inpaint_result_simple-lama.webp | Bin 0 -> 466228 bytes .../temp/translated_llm_test_result_img_1.jpg | Bin 0 -> 166957 bytes modules/test/test_external_inpaint.py | 169 + modules/test/test_llm_translation.py | 135 + ...lated_preview_Pretendard-Regular_img_1.jpg | Bin 178724 -> 162760 bytes modules/test_groq.py | 92 + modules/test_openrouter_client.py | 542 + modules/test_openrouter_dual_model.py | 433 + setup_ob2.py | 649 + tests/__pycache__/setup_clean.cpython-311.pyc | Bin 0 -> 7121 bytes tests/setup_clean.py | 148 + tests/setup_ob.py | 704 + updater/__pycache__/__init__.cpython-311.pyc | Bin 0 -> 145 bytes .../__pycache__/__version__.cpython-311.pyc | Bin 0 -> 432 bytes updater/__version__.py | 13 +- updater/update_Log.MD | 14 + user_logs/1.log | 1220 + 49 files changed, 35073 insertions(+), 204 deletions(-) create mode 100644 Edit_PartTimer_log_11276.log create mode 100644 Edit_PartTimer_log_34628.log create mode 100644 build_log.txt create mode 100644 build_log2.txt create mode 100644 build_log3.txt create mode 100644 build_log4.txt create mode 100644 loggerModule.c create mode 100644 loggerModule.cp311-win_amd64.pyd create mode 100644 modules/__pycache__/openrouter_client.cpython-311.pyc create mode 100644 modules/openrouter_client.py create mode 100644 modules/test/Edit_PartTimer_log_15124.log create mode 100644 modules/test/Edit_PartTimer_log_17176.log create mode 100644 modules/test/Edit_PartTimer_log_21308.log create mode 100644 modules/test/Edit_PartTimer_log_22272.log create mode 100644 modules/test/Edit_PartTimer_log_24188.log create mode 100644 modules/test/Edit_PartTimer_log_28972.log create mode 100644 modules/test/Edit_PartTimer_log_6996.log create mode 100644 modules/test/Edit_PartTimer_log_9948.log create mode 100644 modules/test/outputs_test/inpaint_result_class_test.webp create mode 100644 modules/test/outputs_test/inpaint_result_migan.webp create mode 100644 modules/test/outputs_test/inpaint_result_simple-lama.webp create mode 100644 modules/test/temp/translated_llm_test_result_img_1.jpg create mode 100644 modules/test/test_external_inpaint.py create mode 100644 modules/test/test_llm_translation.py create mode 100644 modules/test_groq.py create mode 100644 modules/test_openrouter_client.py create mode 100644 modules/test_openrouter_dual_model.py create mode 100644 setup_ob2.py create mode 100644 tests/__pycache__/setup_clean.cpython-311.pyc create mode 100644 tests/setup_clean.py create mode 100644 tests/setup_ob.py create mode 100644 updater/__pycache__/__init__.cpython-311.pyc create mode 100644 updater/__pycache__/__version__.cpython-311.pyc create mode 100644 user_logs/1.log diff --git a/Edit_PartTimer_log_11276.log b/Edit_PartTimer_log_11276.log new file mode 100644 index 0000000..921e6ed --- /dev/null +++ b/Edit_PartTimer_log_11276.log @@ -0,0 +1,2 @@ +[2025-12-05 21:42:06,155] [MainThread] [DEBUG] [request_inpaint.py:request_external_inpaint:175] 외부 인페인팅 서버 요청: http://192.168.0.146:8008/api/v1/inpaint, model=migan +[2025-12-05 21:42:06,814] [MainThread] [DEBUG] [request_inpaint.py:request_external_inpaint:187] 외부 인페인팅 성공 diff --git a/Edit_PartTimer_log_34628.log b/Edit_PartTimer_log_34628.log new file mode 100644 index 0000000..28e66b4 --- /dev/null +++ b/Edit_PartTimer_log_34628.log @@ -0,0 +1 @@ +[2025-12-05 21:41:45,490] [MainThread] [WARNING] [request_inpaint.py:request_external_inpaint:106] 외부 인페인팅 서버(http://192.168.0.146:8008)가 응답하지 않습니다. diff --git a/__pycache__/loggerModule.cpython-311.pyc b/__pycache__/loggerModule.cpython-311.pyc index 96e5a967655d6b3214970a0a560e381465138cca..c8bd2688916ec082df82991d609ff2f0e7dec2e9 100644 GIT binary patch delta 11179 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 aPj2e{&p&=Vr`E}c literal 0 HcmV?d00001 diff --git a/build_log2.txt b/build_log2.txt new file mode 100644 index 0000000000000000000000000000000000000000..a51b4170ee2093f1f9725ec58fac2885749339b9 GIT binary patch literal 15730 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 literal 0 HcmV?d00001 diff --git a/build_log3.txt b/build_log3.txt new file mode 100644 index 0000000000000000000000000000000000000000..621ef6ed58b8fa77c4a59af5bc4f269dceb16101 GIT binary patch literal 13868 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 literal 0 HcmV?d00001 diff --git a/build_log4.txt b/build_log4.txt new file mode 100644 index 0000000000000000000000000000000000000000..e2088d844a0a6cf7b1ad2a9978f56cc53dbbd679 GIT binary patch literal 16166 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 literal 0 HcmV?d00001 diff --git a/loggerModule.c b/loggerModule.c new file mode 100644 index 0000000..1088bac --- /dev/null +++ b/loggerModule.c @@ -0,0 +1,28367 @@ +/* Generated by Cython 3.1.2 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "name": "loggerModule", + "sources": [ + "loggerModule.py" + ] + }, + "module_name": "loggerModule" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 +#endif + +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. +#else +#define __PYX_ABI_VERSION "3_1_2" +#define CYTHON_HEX_VERSION 0x030102F0 +#define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #define HAVE_LONG_LONG +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(CYTHON_USE_TYPE_SLOTS) + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) +#if CYTHON_USE_PYLONG_INTERNALS + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; + #endif + #endif +#else + #include + typedef uintptr_t __pyx_uintptr_t; +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) + +/* CInitCode */ +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +/* PythonCompatibility */ +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#ifndef METH_FASTCALL + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x03090000 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#endif +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#endif +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 +#else +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation +#endif +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__loggerModule +#define __PYX_HAVE_API__loggerModule +/* Early includes */ +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * const __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* #### Code section: filename_table ### */ + +static const char* const __pyx_f[] = { + "loggerModule.py", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* IncludeStructmemberH.proto */ +#include + +/* CriticalSections.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs +#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs +#define __Pyx_PyCriticalSection_End1(cs) +#define __Pyx_PyCriticalSection_End2(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin +#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin +#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End +#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_defaults; +struct __pyx_defaults1; +struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread; +struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr; + +/* "loggerModule.py":198 + * class Logger: + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", # <<<<<<<<<<<<<< + * file_log_level=logging.DEBUG, gui_log_level=logging.INFO, + * max_days=3, cleanup_interval=3600): +*/ +struct __pyx_defaults { + PyObject_HEAD + PyObject *arg0; + PyObject *arg1; +}; + + +/* "loggerModule.py":361 + * pass + * + * def log(self, message, level=logging.INFO, exc_info=False): # <<<<<<<<<<<<<< + * """ """ + * if exc_info: +*/ +struct __pyx_defaults1 { + PyObject_HEAD + PyObject *arg0; +}; + + +/* "loggerModule.py":307 + * self.file_handler = file_handler + * + * def _start_cleanup_thread(self): # <<<<<<<<<<<<<< + * """ """ + * def cleanup_worker(): +*/ +struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread { + PyObject_HEAD + PyObject *__pyx_v_self; +}; + + +/* "loggerModule.py":428 + * try: + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) + * total_size = sum(f.stat().st_size for f in log_files) # <<<<<<<<<<<<<< + * + * return { +*/ +struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_f; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallCFunction.proto */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* dict_getitem_default.proto */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* CallUnboundCMethod1.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#else +#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#endif + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif + +/* PyObjectDelAttr.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +#define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL) +#else +#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n) +#endif + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); +#else +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportDottedModule.proto */ +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PyObjectLookupSpecial.proto */ +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) +#define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); +#else +#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) +#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* LimitedApiGetTypeDict.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* dict_setdefault.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CommonTypesMetaclass.proto */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + +/* PyMethodNew.proto */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL ||\ + (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* PyObjectVectorCallMethodKwBuilder.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_VectorcallMethod_CallFromBuilder PyObject_VectorcallMethod +#else +static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#endif + +/* SliceTupleAndList.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); +#else +#define __Pyx_PyList_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) +#define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) +#endif + +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObject_Unicode.proto */ +#define __Pyx_PyObject_Unicode(obj)\ + (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + +/* RaiseClosureNameError.proto */ +static void __Pyx_RaiseClosureNameError(const char *varname); + +/* UnicodeConcatInPlace.proto */ +# if CYTHON_COMPILING_IN_CPYTHON + #if CYTHON_REFNANNY + #define __Pyx_PyUnicode_ConcatInPlace(left, right) __Pyx_PyUnicode_ConcatInPlaceImpl(&left, right, __pyx_refnanny) + #else + #define __Pyx_PyUnicode_ConcatInPlace(left, right) __Pyx_PyUnicode_ConcatInPlaceImpl(&left, right) + #endif + static CYTHON_INLINE PyObject *__Pyx_PyUnicode_ConcatInPlaceImpl(PyObject **p_left, PyObject *right + #if CYTHON_REFNANNY + , void* __pyx_refnanny + #endif + ); +#else +#define __Pyx_PyUnicode_ConcatInPlace __Pyx_PyUnicode_Concat +#endif +#define __Pyx_PyUnicode_ConcatInPlaceSafe(left, right) ((unlikely((left) == Py_None) || unlikely((right) == Py_None)) ?\ + PyNumber_InPlaceAdd(left, right) : __Pyx_PyUnicode_ConcatInPlace(left, right)) + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* append.proto */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* UnpackTupleError.proto */ +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); + +/* UnpackTuple2.proto */ +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); +static int __Pyx_unpack_tuple2_generic( + PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); + +/* dict_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_TrueDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyLong_TrueDivideObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceTrueDivide(op1, op2) : PyNumber_TrueDivide(op1, op2)) +#endif + +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* RaiseMappingExpected.proto */ +static void __Pyx_RaiseMappingExpectedError(PyObject* arg); + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyLong_MultiplyObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceMultiply(op1, op2) : PyNumber_Multiply(op1, op2)) +#endif + +/* MergeKeywords.proto */ +static int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* ListPack.proto */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...); + +/* Py3UpdateBases.proto */ +static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* SetNameInClass.proto */ +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 +#define __Pyx_SetNameInClass(ns, name, value)\ + (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) +#elif CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_SetNameInClass(ns, name, value)\ + (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) +#else +#define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) +#endif + +/* Py3ClassCreate.proto */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +/* CyFunctionClassCell.proto */ +static int __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj); + +/* CLineInTraceback.proto */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#endif + +/* CodeObjectCache.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif +typedef struct { + __Pyx_CachedCodeObjectType* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif +}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* IterNextPlain.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); +#endif + +/* ReturnWithStopIteration.proto */ +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); + +/* CoroutineBase.proto */ +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_ExcInfoStruct _PyErr_StackItem +#else +typedef struct { + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; +} __Pyx_ExcInfoStruct; +#endif +typedef struct __pyx_CoroutineObject { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + __Pyx_ExcInfoStruct gi_exc_state; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + __Pyx_pyiter_sendfunc yieldfrom_am_send; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + PyObject *gi_code; + PyObject *gi_frame; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; + uint64_t __pyx_pymonitoring_version; +#endif + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); +static int __Pyx_Coroutine_clear(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_Coroutine_SwapException(self) +#define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) +#else +#define __Pyx_Coroutine_SwapException(self) {\ + __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ + __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ + } +#define __Pyx_Coroutine_ResetAndClearException(self) {\ + __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ + (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ + } +#endif +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) +#endif +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); + +/* Generator.proto */ +#define __Pyx_Generator_USED +#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_GeneratorType) +#define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_GeneratorType, body, code, closure, name, qualname, module_name) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(PyObject *module); +static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); + +/* GetRuntimeVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + + +/* Module declarations from "loggerModule" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "loggerModule" +extern int __pyx_module_is_main_loggerModule; +int __pyx_module_is_main_loggerModule = 0; + +/* Implementation of "loggerModule" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_super; +static PyObject *__pyx_builtin_open; +static PyObject *__pyx_builtin_print; +static PyObject *__pyx_builtin_OSError; +static PyObject *__pyx_builtin_sum; +static PyObject *__pyx_builtin_round; +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = ", \354\230\244\353\245\230: "; +static const char __pyx_k_N[] = "\320\004)\250\021\360\n\000\t\r\210N\230!\340\010\013\210>\230\027\240\001\330\014\020\320\020!\240\021"; +static const char __pyx_k_Q[] = "\240Q"; +static const char __pyx_k_a[] = "a"; +static const char __pyx_k_b[] = "\200\001\340\004\026\220b\230\t\240\021\240&\250\010\260\001"; +static const char __pyx_k_e[] = "e"; +static const char __pyx_k_f[] = "f"; +static const char __pyx_k_w[] = "w"; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k__2[] = "_"; +static const char __pyx_k__3[] = "\n"; +static const char __pyx_k__4[] = "."; +static const char __pyx_k__5[] = "\354\275\234\353\260\261 \353\241\234\352\267\270 \353\240\210\353\262\250\354\235\264 "; +static const char __pyx_k__6[] = "\353\241\234 \353\263\200\352\262\275\353\220\230\354\227\210\354\212\265\353\213\210\353\213\244"; +static const char __pyx_k__7[] = "\355\214\214\354\235\274 \353\241\234\352\267\270 \353\240\210\353\262\250\354\235\264 "; +static const char __pyx_k__8[] = "\353\241\234\352\267\270 \354\240\225\353\263\264 \354\241\260\355\232\214 \354\213\244\355\214\250"; +static const char __pyx_k__9[] = ","; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_os[] = "os"; +static const char __pyx_k_re[] = "re"; +static const char __pyx_k_AQa[] = "\240*\250A\250Q\250a"; +static const char __pyx_k_A_a[] = "\200A\340\010\014\320\014\036\230a"; +static const char __pyx_k_Qaq[] = "\230:\240Q\240a\240q"; +static const char __pyx_k__10[] = ":"; +static const char __pyx_k__11[] = "?"; +static const char __pyx_k_a_2[] = "\200\001\340\004\005\330\004\026\220a"; +static const char __pyx_k_b_6[] = "\200\001\340\004\026\220b\230\n\240!\2406\250\030\260\021"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_ext[] = "ext"; +static const char __pyx_k_fmt[] = "fmt"; +static const char __pyx_k_get[] = "get"; +static const char __pyx_k_key[] = "key"; +static const char __pyx_k_log[] = ".log"; +static const char __pyx_k_msg[] = "msg"; +static const char __pyx_k_now[] = "now"; +static const char __pyx_k_pid[] = "pid"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_s_1[] = "\200\001\340\004\005\330\004\007\320\007\027\220s\230!\330\010\032\230&\240\001\240\031\250!\330\004\013\2101"; +static const char __pyx_k_sum[] = "sum"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_A_Ry[] = "\200A\330\010\r\210R\210y\230\002\230(\240!"; +static const char __pyx_k_INFO[] = "INFO"; +static const char __pyx_k_JSON[] = "JSON \355\230\225\355\203\234\354\235\230 \352\265\254\354\241\260\355\231\224\353\220\234 \353\241\234\352\271\205\354\235\204 \354\247\200\354\233\220\355\225\230\353\212\224 \353\241\234\352\261\260"; +static const char __pyx_k_Lock[] = "Lock"; +static const char __pyx_k_Path[] = "Path"; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_b_xq[] = "\200\001\340\004\026\220b\230\010\240\001\240\026\240x\250q"; +static const char __pyx_k_base[] = "base"; +static const char __pyx_k_days[] = "days"; +static const char __pyx_k_emit[] = "emit"; +static const char __pyx_k_exit[] = "__exit__"; +static const char __pyx_k_file[] = "file"; +static const char __pyx_k_func[] = "__func__"; +static const char __pyx_k_glob[] = "glob"; +static const char __pyx_k_info[] = "info"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_join[] = "join"; +static const char __pyx_k_json[] = "json"; +static const char __pyx_k_lock[] = "_lock"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_next[] = "next"; +static const char __pyx_k_open[] = "open"; +static const char __pyx_k_path[] = "path"; +static const char __pyx_k_seek[] = "seek"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_send[] = "send"; +static const char __pyx_k_size[] = "size"; +static const char __pyx_k_sort[] = "sort"; +static const char __pyx_k_spec[] = "__spec__"; +static const char __pyx_k_stat[] = "stat"; +static const char __pyx_k_stem[] = "stem"; +static const char __pyx_k_tell[] = "tell"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_time[] = "time"; +static const char __pyx_k_DEBUG[] = "DEBUG"; +static const char __pyx_k_ERROR[] = "ERROR"; +static const char __pyx_k_H_M_S[] = "%H:%M:%S"; +static const char __pyx_k_Level[] = "Level "; +static const char __pyx_k_Y_m_d[] = "%Y-%m-%d"; +static const char __pyx_k_at1_A[] = "\210\001\330\014\r\330\020\021\330\024\030\320\030*\250!\330\024\030\230\006\230a\230t\2401\330\020\027\220}\240A"; +static const char __pyx_k_close[] = "close"; +static const char __pyx_k_copy2[] = "copy2"; +static const char __pyx_k_debug[] = "debug"; +static const char __pyx_k_dumps[] = "dumps"; +static const char __pyx_k_enter[] = "__enter__"; +static const char __pyx_k_error[] = "error"; +static const char __pyx_k_event[] = "event"; +static const char __pyx_k_files[] = "files"; +static const char __pyx_k_flush[] = "flush"; +static const char __pyx_k_items[] = "items"; +static const char __pyx_k_level[] = "level"; +static const char __pyx_k_log_2[] = "*.log*"; +static const char __pyx_k_log_3[] = "*.log"; +static const char __pyx_k_log_4[] = "log"; +static const char __pyx_k_mkdir[] = "mkdir"; +static const char __pyx_k_mtime[] = "mtime"; +static const char __pyx_k_print[] = "print"; +static const char __pyx_k_round[] = "round"; +static const char __pyx_k_sleep[] = "sleep"; +static const char __pyx_k_start[] = "start"; +static const char __pyx_k_super[] = "super"; +static const char __pyx_k_throw[] = "throw"; +static const char __pyx_k_utf_8[] = "utf-8"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_write[] = "write"; +static const char __pyx_k_Logger[] = "[Logger] \355\214\214\354\235\274 \354\227\264\352\270\260 \354\213\244\355\214\250: "; +static const char __pyx_k_NOTSET[] = "NOTSET"; +static const char __pyx_k_Thread[] = "Thread"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_b_QfHA[] = "\200\001\340\004\026\220b\230\005\230Q\230f\240H\250A"; +static const char __pyx_k_b_avXQ[] = "\200\001\340\004\026\220b\230\006\230a\230v\240X\250Q"; +static const char __pyx_k_by_day[] = "by_day"; +static const char __pyx_k_daemon[] = "daemon"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_exists[] = "exists"; +static const char __pyx_k_f_back[] = "f_back"; +static const char __pyx_k_f_code[] = "f_code"; +static const char __pyx_k_format[] = "format"; +static const char __pyx_k_getpid[] = "getpid"; +static const char __pyx_k_handle[] = "handle"; +static const char __pyx_k_kwargs[] = "kwargs"; +static const char __pyx_k_lambda[] = ""; +static const char __pyx_k_logger[] = "logger"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_name_2[] = "__name__"; +static const char __pyx_k_parent[] = "parent"; +static const char __pyx_k_record[] = "record"; +static const char __pyx_k_remove[] = "remove"; +static const char __pyx_k_rename[] = "rename"; +static const char __pyx_k_shutil[] = "shutil"; +static const char __pyx_k_stderr[] = "stderr"; +static const char __pyx_k_stream[] = "stream"; +static const char __pyx_k_target[] = "target"; +static const char __pyx_k_unlink[] = "unlink"; +static const char __pyx_k_A_1A_fA[] = "\200A\340\010\t\360\022\000\t\032\230\031\240'\250\021\250'\3201A\300\027\310\001\330\010\026\220f\230A"; +static const char __pyx_k_A_A_RvQ[] = "\200A\340\r\021\220\021\330\014\020\220\014\230A\330\010\r\210R\210v\220Q"; +static const char __pyx_k_Handler[] = "Handler"; +static const char __pyx_k_OSError[] = "OSError"; +static const char __pyx_k_WARNING[] = "WARNING"; +static const char __pyx_k_abspath[] = "abspath"; +static const char __pyx_k_co_name[] = "co_name"; +static const char __pyx_k_context[] = "context"; +static const char __pyx_k_datefmt[] = "datefmt"; +static const char __pyx_k_day_key[] = "day_key"; +static const char __pyx_k_dirname[] = "dirname"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_genexpr[] = "genexpr"; +static const char __pyx_k_handler[] = "handler"; +static const char __pyx_k_listdir[] = "listdir"; +static const char __pyx_k_log_dir[] = "log_dir"; +static const char __pyx_k_logging[] = "logging"; +static const char __pyx_k_message[] = "message"; +static const char __pyx_k_mtime_2[] = "_mtime"; +static const char __pyx_k_parents[] = "parents"; +static const char __pyx_k_pathlib[] = "pathlib"; +static const char __pyx_k_prepare[] = "__prepare__"; +static const char __pyx_k_reverse[] = "reverse"; +static const char __pyx_k_st_size[] = "st_size"; +static const char __pyx_k_warning[] = "warning"; +static const char __pyx_k_CRITICAL[] = "CRITICAL"; +static const char __pyx_k_Logger_2[] = "[Logger] \353\241\244\354\230\244\353\262\204 \354\213\244\355\214\250: "; +static const char __pyx_k_Logger_3[] = "Logger"; +static const char __pyx_k_base_dir[] = "base_dir"; +static const char __pyx_k_basename[] = "basename"; +static const char __pyx_k_critical[] = "critical"; +static const char __pyx_k_datetime[] = "datetime"; +static const char __pyx_k_duration[] = "duration"; +static const char __pyx_k_encoding[] = "encoding"; +static const char __pyx_k_endswith[] = "endswith"; +static const char __pyx_k_exc_info[] = "exc_info"; +static const char __pyx_k_exist_ok[] = "exist_ok"; +static const char __pyx_k_f_lineno[] = "f_lineno"; +static const char __pyx_k_filename[] = "filename"; +static const char __pyx_k_getmtime[] = "getmtime"; +static const char __pyx_k_handlers[] = "handlers"; +static const char __pyx_k_log_data[] = "log_data"; +static const char __pyx_k_log_file[] = "log_file"; +static const char __pyx_k_makedirs[] = "makedirs"; +static const char __pyx_k_maxBytes[] = "maxBytes"; +static const char __pyx_k_max_days[] = "max_days"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_setLevel[] = "setLevel"; +static const char __pyx_k_set_name[] = "__set_name__"; +static const char __pyx_k_splitext[] = "splitext"; +static const char __pyx_k_st_mtime[] = "st_mtime"; +static const char __pyx_k_strftime[] = "strftime"; +static const char __pyx_k_A_Q_1A_G5[] = "\200A\340\010\014\320\014\035\230Q\330\010\025\220^\2401\240A\330\010\014\210G\2205\230\001\230\022\230>\250\021"; +static const char __pyx_k_Formatter[] = "Formatter"; +static const char __pyx_k_base_name[] = "base_name"; +static const char __pyx_k_exception[] = "exception"; +static const char __pyx_k_file_path[] = "file_path"; +static const char __pyx_k_formatter[] = "formatter"; +static const char __pyx_k_full_path[] = "full_path"; +static const char __pyx_k_getLogger[] = "getLogger"; +static const char __pyx_k_gui_level[] = "gui_level"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_isoformat[] = "isoformat"; +static const char __pyx_k_log_files[] = "log_files"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_open_file[] = "_open_file"; +static const char __pyx_k_operation[] = "operation"; +static const char __pyx_k_propagate[] = "propagate"; +static const char __pyx_k_threading[] = "threading"; +static const char __pyx_k_timedelta[] = "timedelta"; +static const char __pyx_k_timestamp[] = "timestamp"; +static const char __pyx_k_traceback[] = "traceback"; +static const char __pyx_k_A_4q_G6_G6[] = "\200A\340\010\013\2104\210q\330\014\r\330\020\024\220G\2306\240\021\330\020\024\220G\2306\240\021\330\023\024\340\014\020\220\n\230!"; +static const char __pyx_k_Logger_log[] = "Logger.log"; +static const char __pyx_k_addHandler[] = "addHandler"; +static const char __pyx_k_close_file[] = "_close_file"; +static const char __pyx_k_error_type[] = "error_type"; +static const char __pyx_k_file_level[] = "file_level"; +static const char __pyx_k_file_mtime[] = "file_mtime"; +static const char __pyx_k_format_exc[] = "format_exc"; +static const char __pyx_k_gui_logger[] = "gui_logger"; +static const char __pyx_k_level_name[] = "level_name"; +static const char __pyx_k_makeRecord[] = "makeRecord"; +static const char __pyx_k_separators[] = "separators"; +static const char __pyx_k_startswith[] = "startswith"; +static const char __pyx_k_total_size[] = "total_size"; +static const char __pyx_k_A_1_hb_D_xy[] = "\200A\340\010\013\2101\330\014\026\220h\230b\240\001\330\010\014\210D\220\001\220\031\230&\240\007\240x\250y\270\001"; +static const char __pyx_k_A_O1_t1F_Qa[] = "\200A\340\010\014\210O\2301\330\014\r\330\014\022\220'\230\021\330\014\027\220t\2301\230F\240!\330\014\032\230#\230Q\230a\330\016\017"; +static const char __pyx_k_FileHandler[] = "FileHandler"; +static const char __pyx_k_Logger_info[] = "Logger.info"; +static const char __pyx_k_backupCount[] = "backupCount"; +static const char __pyx_k_backup_name[] = "backup_name"; +static const char __pyx_k_co_filename[] = "co_filename"; +static const char __pyx_k_collections[] = "collections"; +static const char __pyx_k_cutoff_date[] = "cutoff_date"; +static const char __pyx_k_defaultdict[] = "defaultdict"; +static const char __pyx_k_do_rollover[] = "_do_rollover"; +static const char __pyx_k_duration_ms[] = "duration_ms"; +static const char __pyx_k_handleError[] = "handleError"; +static const char __pyx_k_level_names[] = "level_names"; +static const char __pyx_k_log_pattern[] = "log_pattern"; +static const char __pyx_k_logger_name[] = "logger_name"; +static const char __pyx_k_mro_entries[] = "__mro_entries__"; +static const char __pyx_k_performance[] = "performance"; +static const char __pyx_k_total_files[] = "total_files"; +static const char __pyx_k_A_O1_a_Qir_q[] = "\200A\340\010\014\210O\2301\330\014\r\330\014\022\220'\230\021\330\014\026\220a\330\014\030\230\005\230Q\230i\240r\250\026\250q\330\016\017"; +static const char __pyx_k_Logger_debug[] = "Logger.debug"; +static const char __pyx_k_Logger_error[] = "Logger.error"; +static const char __pyx_k_Y_m_d__H_M_S[] = "%Y%m%d_%H%M%S"; +static const char __pyx_k_backup_files[] = "backup_files"; +static const char __pyx_k_baseFilename[] = "baseFilename"; +static const char __pyx_k_caller_frame[] = "caller_frame"; +static const char __pyx_k_currentframe[] = "currentframe"; +static const char __pyx_k_ensure_ascii[] = "ensure_ascii"; +static const char __pyx_k_file_handler[] = "file_handler"; +static const char __pyx_k_get_log_info[] = "get_log_info"; +static const char __pyx_k_initializing[] = "_initializing"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_loggerModule[] = "loggerModule"; +static const char __pyx_k_logger_level[] = "logger_level"; +static const char __pyx_k_setFormatter[] = "setFormatter"; +static const char __pyx_k_A_Q_q_A_N_4wa[] = "\200A\340\010\t\330\014\032\230.\250\001\250\024\250Q\330\014\031\230\036\240q\250\004\250A\330\014\034\230N\250!\2504\250w\260a"; +static const char __pyx_k_Logger___init[] = "Logger.__init__"; +static const char __pyx_k_StreamHandler[] = "StreamHandler"; +static const char __pyx_k_class_getitem[] = "__class_getitem__"; +static const char __pyx_k_error_message[] = "error_message"; +static const char __pyx_k_force_cleanup[] = "force_cleanup"; +static const char __pyx_k_fromtimestamp[] = "fromtimestamp"; +static const char __pyx_k_gui_formatter[] = "gui_formatter"; +static const char __pyx_k_gui_log_level[] = "gui_log_level"; +static const char __pyx_k_log_base_name[] = "log_base_name"; +static const char __pyx_k_removeHandler[] = "removeHandler"; +static const char __pyx_k_simple_format[] = "simple_format"; +static const char __pyx_k_total_size_mb[] = "total_size_mb"; +static const char __pyx_k_Logger_warning[] = "Logger.warning"; +static const char __pyx_k_cleanup_thread[] = "cleanup_thread"; +static const char __pyx_k_cleanup_worker[] = "cleanup_worker"; +static const char __pyx_k_default_logger[] = "_default_logger"; +static const char __pyx_k_file_log_level[] = "file_log_level"; +static const char __pyx_k_get_level_name[] = "get_level_name"; +static const char __pyx_k_get_log_levels[] = "get_log_levels"; +static const char __pyx_k_log_structured[] = "log_structured"; +static const char __pyx_k_set_gui_logger[] = "set_gui_logger"; +static const char __pyx_k_A_1_hb_D_6_QlRS[] = "\200A\340\010\013\2101\330\014\026\220h\230b\240\001\330\010\014\210D\220\001\220\031\230&\240\007\240{\260)\2706\300\024\300Q\300l\320RS"; +static const char __pyx_k_A_1_hb_D_wivT_a[] = "\200A\340\010\013\2101\330\014\026\220h\230b\240\001\330\010\014\210D\220\001\220\031\230&\240\007\240w\250i\260v\270T\300\021\300,\310a"; +static const char __pyx_k_A_1_hb_D_xy_d_q[] = "\200A\340\010\013\2101\330\014\026\220h\230b\240\001\330\010\014\210D\220\001\220\031\230&\240\007\240x\250y\270\006\270d\300!\300<\310q"; +static const char __pyx_k_A_1_hb_D_z_A_QR[] = "\200A\340\010\013\2101\330\014\026\220h\230b\240\001\330\010\014\210D\220\001\220\031\230&\240\007\240z\260\031\270&\300\004\300A\300\\\320QR"; +static const char __pyx_k_Logger_critical[] = "Logger.critical"; +static const char __pyx_k_actual_log_file[] = "actual_log_file"; +static const char __pyx_k_console_handler[] = "console_handler"; +static const char __pyx_k_detailed_format[] = "detailed_format"; +static const char __pyx_k_log_performance[] = "log_performance"; +static const char __pyx_k_loggerModule_py[] = "loggerModule.py"; +static const char __pyx_k_should_rollover[] = "_should_rollover"; +static const char __pyx_k_Logger_exception[] = "Logger.exception"; +static const char __pyx_k_StructuredLogger[] = "StructuredLogger"; +static const char __pyx_k_add_file_handler[] = "_add_file_handler"; +static const char __pyx_k_cleanup_interval[] = "cleanup_interval"; +static const char __pyx_k_cleanup_old_logs[] = "_cleanup_old_logs"; +static const char __pyx_k_logging_handlers[] = "logging.handlers"; +static const char __pyx_k_logs_default_log[] = "logs/default.log"; +static const char __pyx_k_name_without_ext[] = "name_without_ext"; +static const char __pyx_k_formatted_message[] = "formatted_message"; +static const char __pyx_k_set_gui_log_level[] = "set_gui_log_level"; +static const char __pyx_k_Edit_PartTimer_log[] = "Edit_PartTimer_log"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_get_default_logger[] = "get_default_logger"; +static const char __pyx_k_set_default_logger[] = "set_default_logger"; +static const char __pyx_k_set_file_log_level[] = "set_file_log_level"; +static const char __pyx_k_Logger_get_log_info[] = "Logger.get_log_info"; +static const char __pyx_k_add_console_handler[] = "_add_console_handler"; +static const char __pyx_k_asctime_s_message_s[] = "[%(asctime)s] %(message)s"; +static const char __pyx_k_cleanup_old_backups[] = "_cleanup_old_backups"; +static const char __pyx_k_y_xq_wa_z_xq_d_7_Ja[] = "\200\001\340\004\005\330\010\017\210y\230\001\330\010\017\210x\220q\330\010\017\210w\220a\330\010\017\210z\230\021\330\010\017\210x\220q\330\010\017\210{\230!\340\004\013\210;\220d\230!\2307\240\"\240J\250a"; +static const char __pyx_k_1_Rz_Q_1A_fAZ_G_uA_D[] = "\320\004*\250'\260\021\340\017\020\340\010\023\2201\330\014\031\230\030\240\024\240R\240z\260\021\330\014\025\220Q\330\014\025\220^\2401\240A\330\016\017\360\006\000\t\023\220$\220f\230A\230Z\240}\260G\270<\300u\310A\330\010\014\210D\220\001\220\031\230!"; +static const char __pyx_k_Logger_force_cleanup[] = "Logger.force_cleanup"; +static const char __pyx_k_start_cleanup_thread[] = "_start_cleanup_thread"; +static const char __pyx_k_Logger_get_log_levels[] = "Logger.get_log_levels"; +static const char __pyx_k_Logger_set_gui_logger[] = "Logger.set_gui_logger"; +static const char __pyx_k_Edit_PartTimer_log_log[] = "Edit_PartTimer_log.log"; +static const char __pyx_k_log_error_with_context[] = "log_error_with_context"; +static const char __pyx_k_A_4xs_1_uAS_4we1_5_4q_1[] = "\200A\340\010\013\2104\210x\220s\230!\330\014\023\2201\330\010\t\340\014\020\220\007\220u\230A\230S\240\001\330\014\023\2204\220w\230e\2401\330\014\023\2205\230\003\2304\230q\330\017\020\330\014\023\2201"; +static const char __pyx_k_StructuredLogger___init[] = "StructuredLogger.__init__"; +static const char __pyx_k_A_a_G9AQ_Kt7_z_G_y_1A_G5[] = "\200A\340\010\014\320\014\036\230a\330\010\014\210G\2209\230A\230Q\330\010\014\210K\220t\2307\240!\330\014\017\210z\230\021\230*\240G\250>\270\021\330\020\027\220y\240\001\240\021\330\010\025\220^\2401\240A\330\010\014\210G\2205\230\001\230\022\230>\250\021"; +static const char __pyx_k_A_q_y_G_Q_F_WL_A_AQ_G_aq[] = "\200A\340\010\032\230'\240\036\250q\330\010\027\220y\240\001\240\021\330\010\024\220G\230:\240Q\330\014\020\320\020$\240F\250#\250W\260L\300\004\300A\340\010\027\220}\240A\240Q\330\010\014\210G\220;\230a\230q"; +static const char __pyx_k_Logger__add_file_handler[] = "Logger._add_file_handler"; +static const char __pyx_k_Logger__cleanup_old_logs[] = "Logger._cleanup_old_logs"; +static const char __pyx_k_Logger_set_gui_log_level[] = "Logger.set_gui_log_level"; +static const char __pyx_k_TimedRotatingFileHandler[] = "TimedRotatingFileHandler"; +static const char __pyx_k_Logger_set_file_log_level[] = "Logger.set_file_log_level"; +static const char __pyx_k_A_iq_xq_IQ_at_y_A_A_4_DBe3a[] = "\200A\340\010\t\340\014\016\210i\220q\230\002\230%\230x\240q\250\004\320,<\270I\300Q\330\014\020\220\n\230$\230a\230t\240?\260%\260y\300\004\300A\330\010\017\210}\230A\340\023\024\330\014\021\220\021\220\"\320\024+\2504\320/D\300B\300e\3103\310a\330\014\020\220\n\230!"; +static const char __pyx_k_Logger__add_console_handler[] = "Logger._add_console_handler"; +static const char __pyx_k_Logger__start_cleanup_thread[] = "Logger._start_cleanup_thread"; +static const char __pyx_k_A_4_Q_4xs_1_4q_gQa_vQd_A_vQ_L[] = "\200A\340\r\021\220\021\330\014\r\340\020\023\2204\320\027(\250\001\330\024\030\230\r\240Q\360\006\000\021\024\2204\220x\230s\240!\330\024\030\230\013\2401\340\020\023\2204\220q\330\024\032\230$\230g\240Q\240a\330\024\030\230\007\230v\240Q\240d\250\"\250A\330\024\030\230\007\230v\240Q\330\023\024\330\020\024\220L\240\001\240\021"; +static const char __pyx_k_88H_Ry_Be81A_L_O1_L_Ja_IYe1_Kq[] = "\320\004!\320!8\3208H\310\001\330\010\r\210R\210y\230\001\330\010\014\320\014\034\230B\230e\2408\2501\250A\330\010\014\210L\230\001\330\010\014\210O\2301\330\010\014\210L\230\001\330\010\014\210J\220a\330\010\014\210I\220Y\230e\2401\330\010\014\210K\220q"; +static const char __pyx_k_WindowsSafeRotatingFileHandler[] = "WindowsSafeRotatingFileHandler._cleanup_old_backups.."; +static const char __pyx_k_q_1_b_Ky_1_wm2Q_WKq_wg_9F_G1_6[] = "\320\004!\240\027\250\007\250q\340\010\013\2101\330\014\026\220b\230\004\230K\240y\260\013\2701\360\006\000\t\030\220w\230m\2502\250Q\330\010\021\220\024\220W\230K\240q\330\014\020\220\007\220w\230g\240\\\260\027\270\001\330\014\030\230\013\2409\250F\260&\270\014\300G\3101\360\010\000\t\014\2106\220\023\220D\230\001\330\014\020\220\007\220w\230a\230q\360\006\000\t\014\2104\210|\2304\230v\240S\250\004\250A\330\014\034\230G\240:\250Q\330\020\024\220A\330\020\030\230\001\340\014 \240\r\250W\260A\260Q\330\014\r\330\020\024\220K\230q\240\001\330\023\024"; +static const char __pyx_k_A_4xy_t2U_1A_z_1_5Q_q_Q_IQa_G_Q[] = "\200A\360\006\000\t\014\2104\210x\220y\240\001\240\021\330\014\027\220t\2302\230U\240)\2501\250A\330\014\027\220z\240\022\2401\360\010\000\t\030\320\0275\260Q\330\014\r\330\014\037\230q\330\014\030\230\001\330\014\025\220Q\360\006\000\t\025\220I\230Q\230a\330\010\024\220G\230:\240Q\330\014\020\320\020$\240F\250#\250W\260L\300\004\300A\340\010\024\220M\240\021\240!\330\010\014\210G\220;\230a\230q\360\006\000\t\r\320\014\034\230A"; +static const char __pyx_k_A_r_hat1_y_Q_fBe9AQ_1_Rxq_1Kq_1[] = "\200A\340\010\t\330\014\027\220r\230\025\230h\240a\240t\2501\330\014\030\230\002\230%\230y\250\001\250\024\250Q\330\014\036\230f\240B\240e\2509\260A\260Q\360\006\000\r\034\2301\330\014\020\220\005\220R\220x\230q\240\001\330\020\023\2201\220K\230q\320 1\260\022\2605\270\004\270A\270Y\300a\300q\330\024 \240\002\240%\240u\250A\250Z\260q\330\024\025\330\030 \240\002\240%\240y\260\001\260\021\330\030$\240G\2502\250[\270\001\330\033\034\360\010\000\r\031\230\005\230Q\230d\320\"2\260(\270!\330\014\020\220\013\2305\240\014\250A\250T\260\021\330\020\021\330\024\026\220g\230Q\230a\330\027\030\340\017\020"; +static const char __pyx_k_CLI_Logger_logging_DEBUG_loggin[] = "\n\354\204\234\353\262\204/CLI \354\271\234\355\231\224 Logger \353\252\250\353\223\210 - \355\214\214\354\235\274/\354\275\230\354\206\224 \353\266\204\353\246\254 \353\241\234\352\271\205\352\263\274 \354\236\220\353\217\231 \354\240\225\353\246\254\n\n\352\266\214\354\236\245 \353\241\234\352\267\270 \353\240\210\353\262\250:\n- \352\260\234\353\260\234: logging.DEBUG\n- \354\232\264\354\230\201: logging.INFO \353\230\220\353\212\224 logging.WARNING\n\n\354\202\254\354\232\251 \354\230\210\354\213\234:\n```python\n# \352\270\260\353\263\270 \354\202\254\354\232\251\nlogger = Logger(\n log_file=\"logs/app.log\",\n file_log_level=logging.DEBUG\n)\n\nlogger.info(\"\354\204\234\353\262\204 \354\213\234\354\236\221\")\n\n# FastAPI\354\227\220\354\204\234 \354\202\254\354\232\251 (\354\230\210)\n# from fastapi import FastAPI\n# app = FastAPI()\n# log = Logger(log_file=\"logs/api.log\")\n# @app.get(\"/\")\n# def root():\n# log.info(\"\354\232\224\354\262\255 \354\210\230\354\213\240\")\n# return {\"ok\": True}\n```\n"; +static const char __pyx_k_K1_WA_Q_N_a_Q_L_Kt1IQ_T_1_HF_86[] = "\320\004\027\320\027(\320(K\3101\330 '\320'=\270W\300A\330\021\035\230Q\360\026\000\t\r\210N\230!\330\010\014\320\014\036\230a\330\010\014\320\014\035\230Q\330\010\014\210L\230\001\330\010\014\320\014 \240\001\330\010\014\210K\220t\2301\230I\240Q\330\010\014\320\014\035\230T\240\021\240)\2501\360\006\000\t\r\210H\220F\230!\2308\2406\250\031\260!\360\n\000\t\017\210b\220\007\220q\360\006\000\t\014\2108\2209\230A\230Q\330\014\030\230\010\240\003\2401\330\014\022\220!\340\014\030\230\001\330\014\022\220!\360\n\000\t\r\320\014\037\230t\2409\250B\250b\260\004\260D\270\001\270\032\3008\3105\320PQ\360\010\000\t\r\320\014\035\230T\240\021\240)\2501\360\006\000\t\r\210J\220g\230Z\240q\250\002\250$\250n\270A\330\010\014\210G\2209\230A\230Q\340\010\014\210G\220=\240\001\360\006\000\t\r\210K\220t\2307\240)\2501\330\014\020\220\007\220~\240Q\240a\360\006\000\t\r\320\014\035\230Q\330\010\014\210A\330\014\r\360\016\000\t\r\320\014!\240\021\240!\340\010\014\320\014\036\230a\230s\240!\2404\320':\270!\360\006\000\t\r\320\014\"\240!"; +static const char __pyx_k_Logger__cleanup_old_logs_locals[] = "Logger._cleanup_old_logs.."; +static const char __pyx_k_StructuredLogger_log_error_with[] = "StructuredLogger.log_error_with_context"; +static const char __pyx_k_StructuredLogger_log_structured[] = "StructuredLogger.log_structured"; +static const char __pyx_k_Windows_RotatingFileHandler_Win[] = "\n Windows \355\230\270\355\231\230 \353\241\234\355\205\214\354\235\264\355\214\205 \355\214\214\354\235\274 \355\225\270\353\223\244\353\237\254\n \n \352\270\260\354\241\264 RotatingFileHandler\354\235\230 \353\254\270\354\240\234\354\240\220:\n - Windows\354\227\220\354\204\234 \355\214\214\354\235\274\354\235\264 \354\227\264\353\240\244\354\236\210\354\234\274\353\251\264 rename \354\213\244\355\214\250 \342\206\222 \353\241\244\353\247\201 \354\213\244\355\214\250 \342\206\222 \353\241\234\352\267\270 \354\234\240\354\213\244\n \n \355\225\264\352\262\260\354\261\205:\n - \355\214\214\354\235\274 \355\201\254\352\270\260 \354\264\210\352\263\274 \354\213\234 \352\270\260\354\241\264 \355\214\214\354\235\274\354\235\204 \353\213\253\352\263\240 \354\203\210 \355\214\214\354\235\274\353\252\205\354\234\274\353\241\234 \354\247\201\354\240\221 \354\203\235\354\204\261\n - \355\203\200\354\236\204\354\212\244\355\203\254\355\224\204 \352\270\260\353\260\230 \355\214\214\354\235\274\353\252\205\354\234\274\353\241\234 \354\266\251\353\217\214 \353\260\251\354\247\200\n "; +static const char __pyx_k_asctime_s_levelname_s_message_s[] = "[%(asctime)s] [%(levelname)s] %(message)s"; +static const char __pyx_k_asctime_s_threadName_s_levelnam[] = "[%(asctime)s] [%(threadName)s] [%(levelname)s] [%(filename)s:%(funcName)s:%(lineno)d] %(message)s"; +static const char __pyx_k_A_AT_ar_T_IQ_3at1_s_1_HA_D_6_U_I[] = "\200A\340\010\t\330\014\030\230\004\230A\230T\240\030\250\025\250a\250r\260\024\260T\270\021\330\014\031\230\023\230I\240Q\340\014\r\330\020\033\2303\230a\230t\2401\330\020\037\230s\240!\2401\330\020!\240\033\250H\260A\330\020\034\230D\240\001\330\020\031\230\021\230!\2306\240\024\240U\250!\340\017\020\330\014\024\220I\230Q"; +static const char __pyx_k_A_L_Biq_y_Q_D_r_gQd_gQd_fAT_oU_4[] = "\200A\340\010\014\210L\230\001\340\010\t\340\014\030\230\010\240\004\240B\240i\250q\260\001\330\014\022\220&\230\002\230%\230y\250\001\250\024\250Q\330\014\032\230\"\230D\240\007\240{\260!\360\006\000\r\020\210r\220\025\220g\230Q\230d\240!\330\020\021\330\024\026\220g\230Q\230d\240/\260\021\330\027\030\340\024\025\330\037 \330\030\036\230f\240A\240T\250\037\270\001\340\035!\240\021\240$\240o\260U\270)\3004\300~\320UV\340\033\034\360\010\000\r\021\320\020%\240Q\340\010\017\210}\230A\330\023\024\330\014\021\220\021\220\"\320\024)\250\022\2505\260\003\2601\360\006\000\t\r\210K\220q"; +static const char __pyx_k_A_hd_Ry_d_b_D_L_HE_86_Bd_a_X_1HE[] = "\200A\340\010\026\220h\230d\240#\240R\240y\260\001\260\025\260d\270!\330\010\026\220b\230\004\230D\240\001\340\010\020\220\001\330\010\014\210L\230\004\230H\240E\250\021\250!\330\014\r\330\020\023\2208\2306\240\023\240B\240d\250$\250a\330\024\025\330\020\035\230X\240^\2601\260H\270E\300\022\3001\330\020\025\220W\230B\230j\250\001\330\023\024\330\020\021\360\006\000\t\r\210J\220i\230q\330\014\017\210v\220R\220q\330\020\021\330\024\034\230G\2401\330\027\030\360\010\000\t\016\320\r \240\001\330\010\021\220\033\230A\230Q\330\010\014\210J\220i\230q\330\014\026\220e\2309\240A\240Q\330\014\022\220!\2208\2307\240\"\240J\250a\340\010\014\210I\220Y\230f\240F\250!\340\014\021\220\025\220a\220t\320\033+\2508\2601\330\014\021\220\032\230;\240e\2501\250A\330\020\021\330\024\027\220x\230w\240a\330\030 \240\007\240q\330\027\030"; +static const char __pyx_k_Logger__start_cleanup_thread_loc[] = "Logger._start_cleanup_thread..cleanup_worker"; +static const char __pyx_k_Logger_get_log_info_locals_genex[] = "Logger.get_log_info..genexpr"; +static const char __pyx_k_StructuredLogger_log_performance[] = "StructuredLogger.log_performance"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_2[] = "WindowsSafeRotatingFileHandler"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_3[] = "WindowsSafeRotatingFileHandler.__init__"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_4[] = "WindowsSafeRotatingFileHandler._open_file"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_5[] = "WindowsSafeRotatingFileHandler._close_file"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_6[] = "WindowsSafeRotatingFileHandler._should_rollover"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_7[] = "WindowsSafeRotatingFileHandler._do_rollover"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_8[] = "WindowsSafeRotatingFileHandler._cleanup_old_backups"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_c[] = "WindowsSafeRotatingFileHandler.close"; +static const char __pyx_k_WindowsSafeRotatingFileHandler_e[] = "WindowsSafeRotatingFileHandler.emit"; +/* #### Code section: decls ### */ +static PyObject *__pyx_pf_12loggerModule_get_level_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_level); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_maxBytes, PyObject *__pyx_v_backupCount, PyObject *__pyx_v_encoding); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_2_open_file(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_4_close_file(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_6_should_rollover(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_8_do_rollover(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_10_cleanup_old_backups(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_12emit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_record); /* proto */ +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_14close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_18__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_gui_logger, PyObject *__pyx_v_log_file, PyObject *__pyx_v_logger_name, PyObject *__pyx_v_file_log_level, PyObject *__pyx_v_gui_log_level, PyObject *__pyx_v_max_days, PyObject *__pyx_v_cleanup_interval); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_2_add_console_handler(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_level); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_4_add_file_handler(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_log_file, PyObject *__pyx_v_level); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_21_start_cleanup_thread_cleanup_worker(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_6_start_cleanup_thread(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_lambda_funcdef_lambda1(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_8_cleanup_old_logs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_20__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_10log(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_level, PyObject *__pyx_v_exc_info); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_12set_gui_logger(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_gui_logger, PyObject *__pyx_v_gui_log_level); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_14set_gui_log_level(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_level); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_16set_file_log_level(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_level); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_18get_log_levels(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_12get_log_info_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_20get_log_info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_22force_cleanup(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_24debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_26info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_28warning(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_30error(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_32critical(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6Logger_34exception(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_2get_default_logger(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_4set_default_logger(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_logger); /* proto */ +static PyObject *__pyx_pf_12loggerModule_6debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_8info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_10warning(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_12error(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_14critical(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_16exception(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_12loggerModule_22__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger_2log_structured(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_event, PyObject *__pyx_v_level, PyObject *__pyx_v_context); /* proto */ +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger_4log_performance(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_operation, PyObject *__pyx_v_duration, PyObject *__pyx_v_context); /* proto */ +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger_6log_error_with_context(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_error, PyObject *__pyx_v_context); /* proto */ +static PyObject *__pyx_tp_new_12loggerModule___pyx_defaults(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_12loggerModule___pyx_defaults1(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_12loggerModule___pyx_scope_struct___start_cleanup_thread(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_12loggerModule___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + PyObject *__pyx_type_12loggerModule___pyx_defaults; + PyObject *__pyx_type_12loggerModule___pyx_defaults1; + PyObject *__pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread; + PyObject *__pyx_type_12loggerModule___pyx_scope_struct_1_genexpr; + PyTypeObject *__pyx_ptype_12loggerModule___pyx_defaults; + PyTypeObject *__pyx_ptype_12loggerModule___pyx_defaults1; + PyTypeObject *__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread; + PyTypeObject *__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_get; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + PyObject *__pyx_slice[3]; + PyObject *__pyx_tuple[5]; + PyObject *__pyx_codeobj_tab[43]; + PyObject *__pyx_string_tab[316]; + PyObject *__pyx_int_0; + PyObject *__pyx_int_2; + PyObject *__pyx_int_3; + PyObject *__pyx_int_5; + PyObject *__pyx_int_50; + PyObject *__pyx_int_1000; + PyObject *__pyx_int_3600; + PyObject *__pyx_int_1048576; + PyObject *__pyx_int_10485760; + PyObject *__pyx_int_neg_4; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *__pyx_freelist_12loggerModule___pyx_scope_struct___start_cleanup_thread[8]; +int __pyx_freecount_12loggerModule___pyx_scope_struct___start_cleanup_thread; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *__pyx_freelist_12loggerModule___pyx_scope_struct_1_genexpr[8]; +int __pyx_freecount_12loggerModule___pyx_scope_struct_1_genexpr; +#endif +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* IterNextPlain.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; +#endif + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_n_u_CRITICAL __pyx_string_tab[1] +#define __pyx_n_u_DEBUG __pyx_string_tab[2] +#define __pyx_n_u_ERROR __pyx_string_tab[3] +#define __pyx_n_u_Edit_PartTimer_log __pyx_string_tab[4] +#define __pyx_kp_u_Edit_PartTimer_log_log __pyx_string_tab[5] +#define __pyx_n_u_FileHandler __pyx_string_tab[6] +#define __pyx_n_u_Formatter __pyx_string_tab[7] +#define __pyx_kp_u_H_M_S __pyx_string_tab[8] +#define __pyx_n_u_Handler __pyx_string_tab[9] +#define __pyx_n_u_INFO __pyx_string_tab[10] +#define __pyx_kp_u_JSON __pyx_string_tab[11] +#define __pyx_kp_u_Level __pyx_string_tab[12] +#define __pyx_n_u_Lock __pyx_string_tab[13] +#define __pyx_kp_u_Logger __pyx_string_tab[14] +#define __pyx_kp_u_Logger_2 __pyx_string_tab[15] +#define __pyx_n_u_Logger_3 __pyx_string_tab[16] +#define __pyx_n_u_Logger___init __pyx_string_tab[17] +#define __pyx_n_u_Logger__add_console_handler __pyx_string_tab[18] +#define __pyx_n_u_Logger__add_file_handler __pyx_string_tab[19] +#define __pyx_n_u_Logger__cleanup_old_logs __pyx_string_tab[20] +#define __pyx_n_u_Logger__cleanup_old_logs_locals __pyx_string_tab[21] +#define __pyx_n_u_Logger__start_cleanup_thread __pyx_string_tab[22] +#define __pyx_n_u_Logger__start_cleanup_thread_loc __pyx_string_tab[23] +#define __pyx_n_u_Logger_critical __pyx_string_tab[24] +#define __pyx_n_u_Logger_debug __pyx_string_tab[25] +#define __pyx_n_u_Logger_error __pyx_string_tab[26] +#define __pyx_n_u_Logger_exception __pyx_string_tab[27] +#define __pyx_n_u_Logger_force_cleanup __pyx_string_tab[28] +#define __pyx_n_u_Logger_get_log_info __pyx_string_tab[29] +#define __pyx_n_u_Logger_get_log_info_locals_genex __pyx_string_tab[30] +#define __pyx_n_u_Logger_get_log_levels __pyx_string_tab[31] +#define __pyx_n_u_Logger_info __pyx_string_tab[32] +#define __pyx_n_u_Logger_log __pyx_string_tab[33] +#define __pyx_n_u_Logger_set_file_log_level __pyx_string_tab[34] +#define __pyx_n_u_Logger_set_gui_log_level __pyx_string_tab[35] +#define __pyx_n_u_Logger_set_gui_logger __pyx_string_tab[36] +#define __pyx_n_u_Logger_warning __pyx_string_tab[37] +#define __pyx_n_u_NOTSET __pyx_string_tab[38] +#define __pyx_n_u_OSError __pyx_string_tab[39] +#define __pyx_n_u_Path __pyx_string_tab[40] +#define __pyx_n_u_StreamHandler __pyx_string_tab[41] +#define __pyx_n_u_StructuredLogger __pyx_string_tab[42] +#define __pyx_n_u_StructuredLogger___init __pyx_string_tab[43] +#define __pyx_n_u_StructuredLogger_log_error_with __pyx_string_tab[44] +#define __pyx_n_u_StructuredLogger_log_performance __pyx_string_tab[45] +#define __pyx_n_u_StructuredLogger_log_structured __pyx_string_tab[46] +#define __pyx_n_u_Thread __pyx_string_tab[47] +#define __pyx_n_u_TimedRotatingFileHandler __pyx_string_tab[48] +#define __pyx_n_u_WARNING __pyx_string_tab[49] +#define __pyx_n_u_WindowsSafeRotatingFileHandler __pyx_string_tab[50] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_2 __pyx_string_tab[51] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_3 __pyx_string_tab[52] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_4 __pyx_string_tab[53] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_5 __pyx_string_tab[54] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_6 __pyx_string_tab[55] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_7 __pyx_string_tab[56] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_8 __pyx_string_tab[57] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_c __pyx_string_tab[58] +#define __pyx_n_u_WindowsSafeRotatingFileHandler_e __pyx_string_tab[59] +#define __pyx_kp_u_Windows_RotatingFileHandler_Win __pyx_string_tab[60] +#define __pyx_kp_u_Y_m_d __pyx_string_tab[61] +#define __pyx_kp_u_Y_m_d__H_M_S __pyx_string_tab[62] +#define __pyx_kp_u__10 __pyx_string_tab[63] +#define __pyx_kp_u__11 __pyx_string_tab[64] +#define __pyx_n_u__2 __pyx_string_tab[65] +#define __pyx_kp_u__3 __pyx_string_tab[66] +#define __pyx_kp_u__4 __pyx_string_tab[67] +#define __pyx_kp_u__5 __pyx_string_tab[68] +#define __pyx_kp_u__6 __pyx_string_tab[69] +#define __pyx_kp_u__7 __pyx_string_tab[70] +#define __pyx_kp_u__8 __pyx_string_tab[71] +#define __pyx_kp_u__9 __pyx_string_tab[72] +#define __pyx_n_u_a __pyx_string_tab[73] +#define __pyx_n_u_abspath __pyx_string_tab[74] +#define __pyx_n_u_actual_log_file __pyx_string_tab[75] +#define __pyx_n_u_addHandler __pyx_string_tab[76] +#define __pyx_n_u_add_console_handler __pyx_string_tab[77] +#define __pyx_n_u_add_file_handler __pyx_string_tab[78] +#define __pyx_n_u_append __pyx_string_tab[79] +#define __pyx_n_u_args __pyx_string_tab[80] +#define __pyx_kp_u_asctime_s_levelname_s_message_s __pyx_string_tab[81] +#define __pyx_kp_u_asctime_s_message_s __pyx_string_tab[82] +#define __pyx_kp_u_asctime_s_threadName_s_levelnam __pyx_string_tab[83] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[84] +#define __pyx_n_u_backupCount __pyx_string_tab[85] +#define __pyx_n_u_backup_files __pyx_string_tab[86] +#define __pyx_n_u_backup_name __pyx_string_tab[87] +#define __pyx_n_u_base __pyx_string_tab[88] +#define __pyx_n_u_baseFilename __pyx_string_tab[89] +#define __pyx_n_u_base_dir __pyx_string_tab[90] +#define __pyx_n_u_base_name __pyx_string_tab[91] +#define __pyx_n_u_basename __pyx_string_tab[92] +#define __pyx_n_u_by_day __pyx_string_tab[93] +#define __pyx_n_u_caller_frame __pyx_string_tab[94] +#define __pyx_n_u_class_getitem __pyx_string_tab[95] +#define __pyx_n_u_cleanup_interval __pyx_string_tab[96] +#define __pyx_n_u_cleanup_old_backups __pyx_string_tab[97] +#define __pyx_n_u_cleanup_old_logs __pyx_string_tab[98] +#define __pyx_n_u_cleanup_thread __pyx_string_tab[99] +#define __pyx_n_u_cleanup_worker __pyx_string_tab[100] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[101] +#define __pyx_n_u_close __pyx_string_tab[102] +#define __pyx_n_u_close_file __pyx_string_tab[103] +#define __pyx_n_u_co_filename __pyx_string_tab[104] +#define __pyx_n_u_co_name __pyx_string_tab[105] +#define __pyx_n_u_collections __pyx_string_tab[106] +#define __pyx_n_u_console_handler __pyx_string_tab[107] +#define __pyx_n_u_context __pyx_string_tab[108] +#define __pyx_n_u_copy2 __pyx_string_tab[109] +#define __pyx_n_u_critical __pyx_string_tab[110] +#define __pyx_n_u_currentframe __pyx_string_tab[111] +#define __pyx_n_u_cutoff_date __pyx_string_tab[112] +#define __pyx_n_u_daemon __pyx_string_tab[113] +#define __pyx_n_u_datefmt __pyx_string_tab[114] +#define __pyx_n_u_datetime __pyx_string_tab[115] +#define __pyx_n_u_day_key __pyx_string_tab[116] +#define __pyx_n_u_days __pyx_string_tab[117] +#define __pyx_n_u_debug __pyx_string_tab[118] +#define __pyx_n_u_default_logger __pyx_string_tab[119] +#define __pyx_n_u_defaultdict __pyx_string_tab[120] +#define __pyx_n_u_detailed_format __pyx_string_tab[121] +#define __pyx_n_u_dirname __pyx_string_tab[122] +#define __pyx_kp_u_disable __pyx_string_tab[123] +#define __pyx_n_u_do_rollover __pyx_string_tab[124] +#define __pyx_n_u_doc __pyx_string_tab[125] +#define __pyx_n_u_dumps __pyx_string_tab[126] +#define __pyx_n_u_duration __pyx_string_tab[127] +#define __pyx_n_u_duration_ms __pyx_string_tab[128] +#define __pyx_n_u_e __pyx_string_tab[129] +#define __pyx_n_u_emit __pyx_string_tab[130] +#define __pyx_kp_u_enable __pyx_string_tab[131] +#define __pyx_n_u_encoding __pyx_string_tab[132] +#define __pyx_n_u_endswith __pyx_string_tab[133] +#define __pyx_n_u_ensure_ascii __pyx_string_tab[134] +#define __pyx_n_u_enter __pyx_string_tab[135] +#define __pyx_n_u_error __pyx_string_tab[136] +#define __pyx_n_u_error_message __pyx_string_tab[137] +#define __pyx_n_u_error_type __pyx_string_tab[138] +#define __pyx_n_u_event __pyx_string_tab[139] +#define __pyx_n_u_exc_info __pyx_string_tab[140] +#define __pyx_n_u_exception __pyx_string_tab[141] +#define __pyx_n_u_exist_ok __pyx_string_tab[142] +#define __pyx_n_u_exists __pyx_string_tab[143] +#define __pyx_n_u_exit __pyx_string_tab[144] +#define __pyx_n_u_ext __pyx_string_tab[145] +#define __pyx_n_u_f __pyx_string_tab[146] +#define __pyx_n_u_f_back __pyx_string_tab[147] +#define __pyx_n_u_f_code __pyx_string_tab[148] +#define __pyx_n_u_f_lineno __pyx_string_tab[149] +#define __pyx_n_u_file __pyx_string_tab[150] +#define __pyx_n_u_file_handler __pyx_string_tab[151] +#define __pyx_n_u_file_level __pyx_string_tab[152] +#define __pyx_n_u_file_log_level __pyx_string_tab[153] +#define __pyx_n_u_file_mtime __pyx_string_tab[154] +#define __pyx_n_u_file_path __pyx_string_tab[155] +#define __pyx_n_u_filename __pyx_string_tab[156] +#define __pyx_n_u_files __pyx_string_tab[157] +#define __pyx_n_u_flush __pyx_string_tab[158] +#define __pyx_n_u_fmt __pyx_string_tab[159] +#define __pyx_n_u_force_cleanup __pyx_string_tab[160] +#define __pyx_n_u_format __pyx_string_tab[161] +#define __pyx_n_u_format_exc __pyx_string_tab[162] +#define __pyx_n_u_formatted_message __pyx_string_tab[163] +#define __pyx_n_u_formatter __pyx_string_tab[164] +#define __pyx_n_u_fromtimestamp __pyx_string_tab[165] +#define __pyx_n_u_full_path __pyx_string_tab[166] +#define __pyx_n_u_func __pyx_string_tab[167] +#define __pyx_kp_u_gc __pyx_string_tab[168] +#define __pyx_n_u_genexpr __pyx_string_tab[169] +#define __pyx_n_u_get __pyx_string_tab[170] +#define __pyx_n_u_getLogger __pyx_string_tab[171] +#define __pyx_n_u_get_default_logger __pyx_string_tab[172] +#define __pyx_n_u_get_level_name __pyx_string_tab[173] +#define __pyx_n_u_get_log_info __pyx_string_tab[174] +#define __pyx_n_u_get_log_levels __pyx_string_tab[175] +#define __pyx_n_u_getmtime __pyx_string_tab[176] +#define __pyx_n_u_getpid __pyx_string_tab[177] +#define __pyx_n_u_glob __pyx_string_tab[178] +#define __pyx_n_u_gui_formatter __pyx_string_tab[179] +#define __pyx_n_u_gui_level __pyx_string_tab[180] +#define __pyx_n_u_gui_log_level __pyx_string_tab[181] +#define __pyx_n_u_gui_logger __pyx_string_tab[182] +#define __pyx_n_u_handle __pyx_string_tab[183] +#define __pyx_n_u_handleError __pyx_string_tab[184] +#define __pyx_n_u_handler __pyx_string_tab[185] +#define __pyx_n_u_handlers __pyx_string_tab[186] +#define __pyx_n_u_info __pyx_string_tab[187] +#define __pyx_n_u_init __pyx_string_tab[188] +#define __pyx_n_u_initializing __pyx_string_tab[189] +#define __pyx_n_u_is_coroutine __pyx_string_tab[190] +#define __pyx_kp_u_isenabled __pyx_string_tab[191] +#define __pyx_n_u_isoformat __pyx_string_tab[192] +#define __pyx_n_u_items __pyx_string_tab[193] +#define __pyx_n_u_join __pyx_string_tab[194] +#define __pyx_n_u_json __pyx_string_tab[195] +#define __pyx_n_u_key __pyx_string_tab[196] +#define __pyx_n_u_kwargs __pyx_string_tab[197] +#define __pyx_n_u_lambda __pyx_string_tab[198] +#define __pyx_n_u_level __pyx_string_tab[199] +#define __pyx_n_u_level_name __pyx_string_tab[200] +#define __pyx_n_u_level_names __pyx_string_tab[201] +#define __pyx_n_u_listdir __pyx_string_tab[202] +#define __pyx_n_u_lock __pyx_string_tab[203] +#define __pyx_kp_u_log __pyx_string_tab[204] +#define __pyx_kp_u_log_2 __pyx_string_tab[205] +#define __pyx_kp_u_log_3 __pyx_string_tab[206] +#define __pyx_n_u_log_4 __pyx_string_tab[207] +#define __pyx_n_u_log_base_name __pyx_string_tab[208] +#define __pyx_n_u_log_data __pyx_string_tab[209] +#define __pyx_n_u_log_dir __pyx_string_tab[210] +#define __pyx_n_u_log_error_with_context __pyx_string_tab[211] +#define __pyx_n_u_log_file __pyx_string_tab[212] +#define __pyx_n_u_log_files __pyx_string_tab[213] +#define __pyx_n_u_log_pattern __pyx_string_tab[214] +#define __pyx_n_u_log_performance __pyx_string_tab[215] +#define __pyx_n_u_log_structured __pyx_string_tab[216] +#define __pyx_n_u_logger __pyx_string_tab[217] +#define __pyx_n_u_loggerModule __pyx_string_tab[218] +#define __pyx_kp_u_loggerModule_py __pyx_string_tab[219] +#define __pyx_n_u_logger_level __pyx_string_tab[220] +#define __pyx_n_u_logger_name __pyx_string_tab[221] +#define __pyx_n_u_logging __pyx_string_tab[222] +#define __pyx_n_u_logging_handlers __pyx_string_tab[223] +#define __pyx_kp_u_logs_default_log __pyx_string_tab[224] +#define __pyx_n_u_main __pyx_string_tab[225] +#define __pyx_n_u_makeRecord __pyx_string_tab[226] +#define __pyx_n_u_makedirs __pyx_string_tab[227] +#define __pyx_n_u_maxBytes __pyx_string_tab[228] +#define __pyx_n_u_max_days __pyx_string_tab[229] +#define __pyx_n_u_message __pyx_string_tab[230] +#define __pyx_n_u_metaclass __pyx_string_tab[231] +#define __pyx_n_u_mkdir __pyx_string_tab[232] +#define __pyx_n_u_module __pyx_string_tab[233] +#define __pyx_n_u_mro_entries __pyx_string_tab[234] +#define __pyx_n_u_msg __pyx_string_tab[235] +#define __pyx_n_u_mtime __pyx_string_tab[236] +#define __pyx_n_u_mtime_2 __pyx_string_tab[237] +#define __pyx_n_u_name __pyx_string_tab[238] +#define __pyx_n_u_name_2 __pyx_string_tab[239] +#define __pyx_n_u_name_without_ext __pyx_string_tab[240] +#define __pyx_n_u_next __pyx_string_tab[241] +#define __pyx_n_u_now __pyx_string_tab[242] +#define __pyx_n_u_open __pyx_string_tab[243] +#define __pyx_n_u_open_file __pyx_string_tab[244] +#define __pyx_n_u_operation __pyx_string_tab[245] +#define __pyx_n_u_os __pyx_string_tab[246] +#define __pyx_n_u_parent __pyx_string_tab[247] +#define __pyx_n_u_parents __pyx_string_tab[248] +#define __pyx_n_u_path __pyx_string_tab[249] +#define __pyx_n_u_pathlib __pyx_string_tab[250] +#define __pyx_n_u_performance __pyx_string_tab[251] +#define __pyx_n_u_pid __pyx_string_tab[252] +#define __pyx_n_u_pop __pyx_string_tab[253] +#define __pyx_n_u_prepare __pyx_string_tab[254] +#define __pyx_n_u_print __pyx_string_tab[255] +#define __pyx_n_u_propagate __pyx_string_tab[256] +#define __pyx_n_u_qualname __pyx_string_tab[257] +#define __pyx_n_u_re __pyx_string_tab[258] +#define __pyx_n_u_record __pyx_string_tab[259] +#define __pyx_n_u_remove __pyx_string_tab[260] +#define __pyx_n_u_removeHandler __pyx_string_tab[261] +#define __pyx_n_u_rename __pyx_string_tab[262] +#define __pyx_n_u_reverse __pyx_string_tab[263] +#define __pyx_n_u_round __pyx_string_tab[264] +#define __pyx_n_u_seek __pyx_string_tab[265] +#define __pyx_n_u_self __pyx_string_tab[266] +#define __pyx_n_u_send __pyx_string_tab[267] +#define __pyx_n_u_separators __pyx_string_tab[268] +#define __pyx_n_u_setFormatter __pyx_string_tab[269] +#define __pyx_n_u_setLevel __pyx_string_tab[270] +#define __pyx_n_u_set_default_logger __pyx_string_tab[271] +#define __pyx_n_u_set_file_log_level __pyx_string_tab[272] +#define __pyx_n_u_set_gui_log_level __pyx_string_tab[273] +#define __pyx_n_u_set_gui_logger __pyx_string_tab[274] +#define __pyx_n_u_set_name __pyx_string_tab[275] +#define __pyx_n_u_should_rollover __pyx_string_tab[276] +#define __pyx_n_u_shutil __pyx_string_tab[277] +#define __pyx_n_u_simple_format __pyx_string_tab[278] +#define __pyx_n_u_size __pyx_string_tab[279] +#define __pyx_n_u_sleep __pyx_string_tab[280] +#define __pyx_n_u_sort __pyx_string_tab[281] +#define __pyx_n_u_spec __pyx_string_tab[282] +#define __pyx_n_u_splitext __pyx_string_tab[283] +#define __pyx_n_u_st_mtime __pyx_string_tab[284] +#define __pyx_n_u_st_size __pyx_string_tab[285] +#define __pyx_n_u_start __pyx_string_tab[286] +#define __pyx_n_u_start_cleanup_thread __pyx_string_tab[287] +#define __pyx_n_u_startswith __pyx_string_tab[288] +#define __pyx_n_u_stat __pyx_string_tab[289] +#define __pyx_n_u_stderr __pyx_string_tab[290] +#define __pyx_n_u_stem __pyx_string_tab[291] +#define __pyx_n_u_stream __pyx_string_tab[292] +#define __pyx_n_u_strftime __pyx_string_tab[293] +#define __pyx_n_u_sum __pyx_string_tab[294] +#define __pyx_n_u_super __pyx_string_tab[295] +#define __pyx_n_u_sys __pyx_string_tab[296] +#define __pyx_n_u_target __pyx_string_tab[297] +#define __pyx_n_u_tell __pyx_string_tab[298] +#define __pyx_n_u_test __pyx_string_tab[299] +#define __pyx_n_u_threading __pyx_string_tab[300] +#define __pyx_n_u_throw __pyx_string_tab[301] +#define __pyx_n_u_time __pyx_string_tab[302] +#define __pyx_n_u_timedelta __pyx_string_tab[303] +#define __pyx_n_u_timestamp __pyx_string_tab[304] +#define __pyx_n_u_total_files __pyx_string_tab[305] +#define __pyx_n_u_total_size __pyx_string_tab[306] +#define __pyx_n_u_total_size_mb __pyx_string_tab[307] +#define __pyx_n_u_traceback __pyx_string_tab[308] +#define __pyx_n_u_unlink __pyx_string_tab[309] +#define __pyx_kp_u_utf_8 __pyx_string_tab[310] +#define __pyx_n_u_value __pyx_string_tab[311] +#define __pyx_n_u_w __pyx_string_tab[312] +#define __pyx_n_u_warning __pyx_string_tab[313] +#define __pyx_n_u_write __pyx_string_tab[314] +#define __pyx_n_u_x __pyx_string_tab[315] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_12loggerModule___pyx_defaults); + Py_CLEAR(clear_module_state->__pyx_type_12loggerModule___pyx_defaults); + Py_CLEAR(clear_module_state->__pyx_ptype_12loggerModule___pyx_defaults1); + Py_CLEAR(clear_module_state->__pyx_type_12loggerModule___pyx_defaults1); + Py_CLEAR(clear_module_state->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread); + Py_CLEAR(clear_module_state->__pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread); + Py_CLEAR(clear_module_state->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_12loggerModule___pyx_scope_struct_1_genexpr); + for (int i=0; i<3; ++i) { Py_CLEAR(clear_module_state->__pyx_slice[i]); } + for (int i=0; i<5; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<43; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<316; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_2); + Py_CLEAR(clear_module_state->__pyx_int_3); + Py_CLEAR(clear_module_state->__pyx_int_5); + Py_CLEAR(clear_module_state->__pyx_int_50); + Py_CLEAR(clear_module_state->__pyx_int_1000); + Py_CLEAR(clear_module_state->__pyx_int_3600); + Py_CLEAR(clear_module_state->__pyx_int_1048576); + Py_CLEAR(clear_module_state->__pyx_int_10485760); + Py_CLEAR(clear_module_state->__pyx_int_neg_4); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_12loggerModule___pyx_defaults); + Py_VISIT(traverse_module_state->__pyx_type_12loggerModule___pyx_defaults); + Py_VISIT(traverse_module_state->__pyx_ptype_12loggerModule___pyx_defaults1); + Py_VISIT(traverse_module_state->__pyx_type_12loggerModule___pyx_defaults1); + Py_VISIT(traverse_module_state->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread); + Py_VISIT(traverse_module_state->__pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread); + Py_VISIT(traverse_module_state->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_12loggerModule___pyx_scope_struct_1_genexpr); + for (int i=0; i<3; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_slice[i]); } + for (int i=0; i<5; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<43; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<316; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_2); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_3); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_5); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_50); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1000); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_3600); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1048576); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_10485760); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_neg_4); + return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "loggerModule.py":39 + * + * # ( ) + * def get_level_name(level): # <<<<<<<<<<<<<< + * """ ( )""" + * level_names = { +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_1get_level_name(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_get_level_name, "\353\241\234\352\267\270 \353\240\210\353\262\250\354\235\204 \354\235\264\353\246\204\354\234\274\353\241\234 \353\263\200\355\231\230 (\355\230\270\355\231\230\354\204\261 \353\263\264\354\236\245)"); +static PyMethodDef __pyx_mdef_12loggerModule_1get_level_name = {"get_level_name", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_1get_level_name, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_get_level_name}; +static PyObject *__pyx_pw_12loggerModule_1get_level_name(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_level = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_level_name (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_level,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 39, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 39, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_level_name", 0) < 0) __PYX_ERR(0, 39, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_level_name", 1, 1, 1, i); __PYX_ERR(0, 39, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 39, __pyx_L3_error) + } + __pyx_v_level = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_level_name", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 39, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.get_level_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_get_level_name(__pyx_self, __pyx_v_level); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_get_level_name(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_level) { + PyObject *__pyx_v_level_names = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_level_name", 0); + + /* "loggerModule.py":42 + * """ ( )""" + * level_names = { + * logging.NOTSET: "NOTSET", # <<<<<<<<<<<<<< + * logging.DEBUG: "DEBUG", + * logging.INFO: "INFO", +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NOTSET); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_NOTSET) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":43 + * level_names = { + * logging.NOTSET: "NOTSET", + * logging.DEBUG: "DEBUG", # <<<<<<<<<<<<<< + * logging.INFO: "INFO", + * logging.WARNING: "WARNING", +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DEBUG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_DEBUG) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":44 + * logging.NOTSET: "NOTSET", + * logging.DEBUG: "DEBUG", + * logging.INFO: "INFO", # <<<<<<<<<<<<<< + * logging.WARNING: "WARNING", + * logging.ERROR: "ERROR", +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_INFO); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_INFO) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":45 + * logging.DEBUG: "DEBUG", + * logging.INFO: "INFO", + * logging.WARNING: "WARNING", # <<<<<<<<<<<<<< + * logging.ERROR: "ERROR", + * logging.CRITICAL: "CRITICAL" +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WARNING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_WARNING) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":46 + * logging.INFO: "INFO", + * logging.WARNING: "WARNING", + * logging.ERROR: "ERROR", # <<<<<<<<<<<<<< + * logging.CRITICAL: "CRITICAL" + * } +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ERROR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_n_u_ERROR) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":47 + * logging.WARNING: "WARNING", + * logging.ERROR: "ERROR", + * logging.CRITICAL: "CRITICAL" # <<<<<<<<<<<<<< + * } + * return level_names.get(level, f"Level {level}") +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_CRITICAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_CRITICAL) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_level_names = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "loggerModule.py":49 + * logging.CRITICAL: "CRITICAL" + * } + * return level_names.get(level, f"Level {level}") # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_level, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Level, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_v_level_names, __pyx_v_level, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "loggerModule.py":39 + * + * # ( ) + * def get_level_name(level): # <<<<<<<<<<<<<< + * """ ( )""" + * level_names = { +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("loggerModule.get_level_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_level_names); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":64 + * """ + * + * def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): # <<<<<<<<<<<<<< + * super().__init__() + * self.baseFilename = os.path.abspath(filename) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_maxBytes = 0; + PyObject *__pyx_v_backupCount = 0; + PyObject *__pyx_v_encoding = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_filename,&__pyx_mstate_global->__pyx_n_u_maxBytes,&__pyx_mstate_global->__pyx_n_u_backupCount,&__pyx_mstate_global->__pyx_n_u_encoding,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 64, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 64, __pyx_L3_error) + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_10485760))); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_50))); + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_kp_u_utf_8))); + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, i); __PYX_ERR(0, 64, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 64, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 64, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 64, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_10485760))); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_50))); + if (!values[4]) values[4] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_kp_u_utf_8))); + } + __pyx_v_self = values[0]; + __pyx_v_filename = values[1]; + __pyx_v_maxBytes = values[2]; + __pyx_v_backupCount = values[3]; + __pyx_v_encoding = values[4]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, __pyx_nargs); __PYX_ERR(0, 64, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler___init__(__pyx_self, __pyx_v_self, __pyx_v_filename, __pyx_v_maxBytes, __pyx_v_backupCount, __pyx_v_encoding); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_maxBytes, PyObject *__pyx_v_backupCount, PyObject *__pyx_v_encoding) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "loggerModule.py":65 + * + * def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): + * super().__init__() # <<<<<<<<<<<<<< + * self.baseFilename = os.path.abspath(filename) + * self.maxBytes = maxBytes +*/ + __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_builtin_super); + __pyx_t_5 = __pyx_builtin_super; + __pyx_t_6 = __Pyx_CyFunction_GetClassObj(__pyx_self); + if (!__pyx_t_6) { PyErr_SetString(PyExc_RuntimeError, "super(): empty __class__ cell"); __PYX_ERR(0, 65, __pyx_L1_error) } + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_v_self}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_init, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":66 + * def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): + * super().__init__() + * self.baseFilename = os.path.abspath(filename) # <<<<<<<<<<<<<< + * self.maxBytes = maxBytes + * self.backupCount = backupCount +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_filename}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_abspath, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename, __pyx_t_1) < 0) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":67 + * super().__init__() + * self.baseFilename = os.path.abspath(filename) + * self.maxBytes = maxBytes # <<<<<<<<<<<<<< + * self.backupCount = backupCount + * self.encoding = encoding +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_maxBytes, __pyx_v_maxBytes) < 0) __PYX_ERR(0, 67, __pyx_L1_error) + + /* "loggerModule.py":68 + * self.baseFilename = os.path.abspath(filename) + * self.maxBytes = maxBytes + * self.backupCount = backupCount # <<<<<<<<<<<<<< + * self.encoding = encoding + * self.stream = None +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backupCount, __pyx_v_backupCount) < 0) __PYX_ERR(0, 68, __pyx_L1_error) + + /* "loggerModule.py":69 + * self.maxBytes = maxBytes + * self.backupCount = backupCount + * self.encoding = encoding # <<<<<<<<<<<<<< + * self.stream = None + * self._lock = threading.Lock() +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_encoding, __pyx_v_encoding) < 0) __PYX_ERR(0, 69, __pyx_L1_error) + + /* "loggerModule.py":70 + * self.backupCount = backupCount + * self.encoding = encoding + * self.stream = None # <<<<<<<<<<<<<< + * self._lock = threading.Lock() + * self._open_file() +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream, Py_None) < 0) __PYX_ERR(0, 70, __pyx_L1_error) + + /* "loggerModule.py":71 + * self.encoding = encoding + * self.stream = None + * self._lock = threading.Lock() # <<<<<<<<<<<<<< + * self._open_file() + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Lock); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lock, __pyx_t_1) < 0) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":72 + * self.stream = None + * self._lock = threading.Lock() + * self._open_file() # <<<<<<<<<<<<<< + * + * def _open_file(self): +*/ + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_open_file, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":64 + * """ + * + * def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): # <<<<<<<<<<<<<< + * super().__init__() + * self.baseFilename = os.path.abspath(filename) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":74 + * self._open_file() + * + * def _open_file(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_3_open_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_2_open_file, "\355\214\214\354\235\274 \354\212\244\355\212\270\353\246\274 \354\227\264\352\270\260"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_3_open_file = {"_open_file", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_3_open_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_2_open_file}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_3_open_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_open_file (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 74, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 74, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_open_file", 0) < 0) __PYX_ERR(0, 74, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_open_file", 1, 1, 1, i); __PYX_ERR(0, 74, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 74, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_open_file", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 74, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._open_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_2_open_file(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_2_open_file(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_v_e = NULL; + PyObject *__pyx_v_sys = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + size_t __pyx_t_11; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14[4]; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + char const *__pyx_t_17; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_open_file", 0); + + /* "loggerModule.py":76 + * def _open_file(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * # + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "loggerModule.py":78 + * try: + * # + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) # <<<<<<<<<<<<<< + * self.stream = open(self.baseFilename, 'a', encoding=self.encoding) + * except Exception as e: +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_makedirs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_8 = __pyx_t_10; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_9}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_dirname, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_11 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_11 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_10 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exist_ok, Py_True, __pyx_t_10, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 78, __pyx_L3_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 78, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":79 + * # + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) + * self.stream = open(self.baseFilename, 'a', encoding=self.encoding) # <<<<<<<<<<<<<< + * except Exception as e: + * # stderr +*/ + __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_builtin_open); + __pyx_t_10 = __pyx_builtin_open; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_11 = 1; + { + PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_6, __pyx_mstate_global->__pyx_n_u_a}; + __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 79, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_encoding, __pyx_t_5, __pyx_t_9, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 79, __pyx_L3_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_10, __pyx_callargs+__pyx_t_11, (3-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream, __pyx_t_4) < 0) __PYX_ERR(0, 79, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":76 + * def _open_file(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * # + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "loggerModule.py":80 + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) + * self.stream = open(self.baseFilename, 'a', encoding=self.encoding) + * except Exception as e: # <<<<<<<<<<<<<< + * # stderr + * import sys +*/ + __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_12) { + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._open_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_10, &__pyx_t_9) < 0) __PYX_ERR(0, 80, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __pyx_v_e = __pyx_t_10; + /*try:*/ { + + /* "loggerModule.py":82 + * except Exception as e: + * # stderr + * import sys # <<<<<<<<<<<<<< + * print(f"[Logger] : {self.baseFilename}, : {e}", file=sys.stderr) + * self.stream = None +*/ + __pyx_t_5 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_sys, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_sys = __pyx_t_5; + __pyx_t_5 = 0; + + /* "loggerModule.py":83 + * # stderr + * import sys + * print(f"[Logger] : {self.baseFilename}, : {e}", file=sys.stderr) # <<<<<<<<<<<<<< + * self.stream = None + * +*/ + __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_builtin_print); + __pyx_t_7 = __pyx_builtin_print; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_e, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_14[0] = __pyx_mstate_global->__pyx_kp_u_Logger; + __pyx_t_14[1] = __pyx_t_13; + __pyx_t_14[2] = __pyx_mstate_global->__pyx_kp_u_; + __pyx_t_14[3] = __pyx_t_8; + __pyx_t_15 = __Pyx_PyUnicode_Join(__pyx_t_14, 4, 19 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8), 65535 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_13) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8)); + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_sys, __pyx_mstate_global->__pyx_n_u_stderr); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = 1; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_15}; + __pyx_t_13 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_13); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_file, __pyx_t_8, __pyx_t_13, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 83, __pyx_L14_error) + __pyx_t_5 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_13); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 83, __pyx_L14_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":84 + * import sys + * print(f"[Logger] : {self.baseFilename}, : {e}", file=sys.stderr) + * self.stream = None # <<<<<<<<<<<<<< + * + * def _close_file(self): +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream, Py_None) < 0) __PYX_ERR(0, 84, __pyx_L14_error) + } + + /* "loggerModule.py":80 + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) + * self.stream = open(self.baseFilename, 'a', encoding=self.encoding) + * except Exception as e: # <<<<<<<<<<<<<< + * # stderr + * import sys +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0; + goto __pyx_L15; + } + __pyx_L14_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); + if ( unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_21); + __Pyx_XGOTREF(__pyx_t_22); + __Pyx_XGOTREF(__pyx_t_23); + __pyx_t_12 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0; + } + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_XGIVEREF(__pyx_t_23); + __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); + __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; + __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; + goto __pyx_L5_except_error; + } + __pyx_L15:; + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + + /* "loggerModule.py":76 + * def _open_file(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * # + * os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L8_try_end:; + } + + /* "loggerModule.py":74 + * self._open_file() + * + * def _open_file(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._open_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XDECREF(__pyx_v_sys); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":86 + * self.stream = None + * + * def _close_file(self): # <<<<<<<<<<<<<< + * """ """ + * if self.stream: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_5_close_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_4_close_file, "\355\214\214\354\235\274 \354\212\244\355\212\270\353\246\274 \353\213\253\352\270\260"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_5_close_file = {"_close_file", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_5_close_file, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_4_close_file}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_5_close_file(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_close_file (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 86, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 86, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_close_file", 0) < 0) __PYX_ERR(0, 86, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_close_file", 1, 1, 1, i); __PYX_ERR(0, 86, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 86, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_close_file", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 86, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._close_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_4_close_file(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_4_close_file(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_close_file", 0); + + /* "loggerModule.py":88 + * def _close_file(self): + * """ """ + * if self.stream: # <<<<<<<<<<<<<< + * try: + * self.stream.flush() +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "loggerModule.py":89 + * """ """ + * if self.stream: + * try: # <<<<<<<<<<<<<< + * self.stream.flush() + * self.stream.close() +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "loggerModule.py":90 + * if self.stream: + * try: + * self.stream.flush() # <<<<<<<<<<<<<< + * self.stream.close() + * except Exception: +*/ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 90, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_flush, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":91 + * try: + * self.stream.flush() + * self.stream.close() # <<<<<<<<<<<<<< + * except Exception: + * pass +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_close, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":89 + * """ """ + * if self.stream: + * try: # <<<<<<<<<<<<<< + * self.stream.flush() + * self.stream.close() +*/ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":92 + * self.stream.flush() + * self.stream.close() + * except Exception: # <<<<<<<<<<<<<< + * pass + * self.stream = None +*/ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_9) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L5_exception_handled; + } + goto __pyx_L6_except_error; + + /* "loggerModule.py":89 + * """ """ + * if self.stream: + * try: # <<<<<<<<<<<<<< + * self.stream.flush() + * self.stream.close() +*/ + __pyx_L6_except_error:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L5_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + __pyx_L9_try_end:; + } + + /* "loggerModule.py":94 + * except Exception: + * pass + * self.stream = None # <<<<<<<<<<<<<< + * + * def _should_rollover(self): +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream, Py_None) < 0) __PYX_ERR(0, 94, __pyx_L1_error) + + /* "loggerModule.py":88 + * def _close_file(self): + * """ """ + * if self.stream: # <<<<<<<<<<<<<< + * try: + * self.stream.flush() +*/ + } + + /* "loggerModule.py":86 + * self.stream = None + * + * def _close_file(self): # <<<<<<<<<<<<<< + * """ """ + * if self.stream: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._close_file", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":96 + * self.stream = None + * + * def _should_rollover(self): # <<<<<<<<<<<<<< + * """ """ + * if self.stream is None: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_7_should_rollover(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_6_should_rollover, "\353\241\244\354\230\244\353\262\204\352\260\200 \355\225\204\354\232\224\355\225\234\354\247\200 \355\231\225\354\235\270"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_7_should_rollover = {"_should_rollover", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_7_should_rollover, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_6_should_rollover}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_7_should_rollover(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_should_rollover (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 96, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 96, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_should_rollover", 0) < 0) __PYX_ERR(0, 96, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_should_rollover", 1, 1, 1, i); __PYX_ERR(0, 96, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 96, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_should_rollover", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 96, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._should_rollover", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_6_should_rollover(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_6_should_rollover(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_v_size = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_should_rollover", 0); + + /* "loggerModule.py":98 + * def _should_rollover(self): + * """ """ + * if self.stream is None: # <<<<<<<<<<<<<< + * return False + * try: +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 == Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "loggerModule.py":99 + * """ """ + * if self.stream is None: + * return False # <<<<<<<<<<<<<< + * try: + * # +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "loggerModule.py":98 + * def _should_rollover(self): + * """ """ + * if self.stream is None: # <<<<<<<<<<<<<< + * return False + * try: +*/ + } + + /* "loggerModule.py":100 + * if self.stream is None: + * return False + * try: # <<<<<<<<<<<<<< + * # + * self.stream.seek(0, 2) # +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "loggerModule.py":102 + * try: + * # + * self.stream.seek(0, 2) # # <<<<<<<<<<<<<< + * size = self.stream.tell() + * return size >= self.maxBytes +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_seek); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 102, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":103 + * # + * self.stream.seek(0, 2) # + * size = self.stream.tell() # <<<<<<<<<<<<<< + * return size >= self.maxBytes + * except Exception: +*/ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 103, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_tell, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_size = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":104 + * self.stream.seek(0, 2) # + * size = self.stream.tell() + * return size >= self.maxBytes # <<<<<<<<<<<<<< + * except Exception: + * return False +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_maxBytes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_size, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L8_try_return; + + /* "loggerModule.py":100 + * if self.stream is None: + * return False + * try: # <<<<<<<<<<<<<< + * # + * self.stream.seek(0, 2) # +*/ + } + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":105 + * size = self.stream.tell() + * return size >= self.maxBytes + * except Exception: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_9) { + __Pyx_ErrRestore(0,0,0); + + /* "loggerModule.py":106 + * return size >= self.maxBytes + * except Exception: + * return False # <<<<<<<<<<<<<< + * + * def _do_rollover(self): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + + /* "loggerModule.py":100 + * if self.stream is None: + * return False + * try: # <<<<<<<<<<<<<< + * # + * self.stream.seek(0, 2) # +*/ + __pyx_L6_except_error:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L8_try_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + } + + /* "loggerModule.py":96 + * self.stream = None + * + * def _should_rollover(self): # <<<<<<<<<<<<<< + * """ """ + * if self.stream is None: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._should_rollover", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_size); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":108 + * return False + * + * def _do_rollover(self): # <<<<<<<<<<<<<< + * """ - Windows """ + * self._close_file() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_9_do_rollover(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_8_do_rollover, "\353\241\244\354\230\244\353\262\204 \354\213\244\355\226\211 - Windows \354\225\210\354\240\204 \353\260\251\354\213\235"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_9_do_rollover = {"_do_rollover", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_9_do_rollover, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_8_do_rollover}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_9_do_rollover(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_do_rollover (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 108, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 108, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_do_rollover", 0) < 0) __PYX_ERR(0, 108, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_do_rollover", 1, 1, 1, i); __PYX_ERR(0, 108, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 108, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_do_rollover", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 108, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._do_rollover", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_8_do_rollover(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_8_do_rollover(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_v_timestamp = NULL; + PyObject *__pyx_v_base = NULL; + PyObject *__pyx_v_ext = NULL; + PyObject *__pyx_v_backup_name = NULL; + PyObject *__pyx_v_shutil = NULL; + CYTHON_UNUSED PyObject *__pyx_v_f = NULL; + PyObject *__pyx_v_e = NULL; + PyObject *__pyx_v_sys = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *(*__pyx_t_11)(PyObject *); + PyObject *__pyx_t_12[4]; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + int __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + PyObject *__pyx_t_24 = NULL; + PyObject *__pyx_t_25 = NULL; + PyObject *__pyx_t_26 = NULL; + PyObject *__pyx_t_27 = NULL; + int __pyx_t_28; + char const *__pyx_t_29; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_do_rollover", 0); + + /* "loggerModule.py":110 + * def _do_rollover(self): + * """ - Windows """ + * self._close_file() # <<<<<<<<<<<<<< + * + * try: +*/ + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_close_file, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":112 + * self._close_file() + * + * try: # <<<<<<<<<<<<<< + * # + * timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + /* "loggerModule.py":114 + * try: + * # + * timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') # <<<<<<<<<<<<<< + * base, ext = os.path.splitext(self.baseFilename) + * backup_name = f"{base}_{timestamp}{ext}" +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 114, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_now); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 114, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_2 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Y_m_d__H_M_S}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_strftime, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_timestamp = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":115 + * # + * timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + * base, ext = os.path.splitext(self.baseFilename) # <<<<<<<<<<<<<< + * backup_name = f"{base}_{timestamp}{ext}" + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = __pyx_t_10; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_splitext, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 115, __pyx_L3_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_10); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_2); + } else { + __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_XGOTREF(__pyx_t_10); + __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_XGOTREF(__pyx_t_2); + } + #else + __pyx_t_10 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); + index = 0; __pyx_t_10 = __pyx_t_11(__pyx_t_7); if (unlikely(!__pyx_t_10)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_10); + index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_7); if (unlikely(!__pyx_t_2)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_7), 2) < 0) __PYX_ERR(0, 115, __pyx_L3_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L10_unpacking_done; + __pyx_L9_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 115, __pyx_L3_error) + __pyx_L10_unpacking_done:; + } + __pyx_v_base = __pyx_t_10; + __pyx_t_10 = 0; + __pyx_v_ext = __pyx_t_2; + __pyx_t_2 = 0; + + /* "loggerModule.py":116 + * timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + * base, ext = os.path.splitext(self.baseFilename) + * backup_name = f"{base}_{timestamp}{ext}" # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_base, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_timestamp, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_ext, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 116, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_12[0] = __pyx_t_1; + __pyx_t_12[1] = __pyx_mstate_global->__pyx_n_u__2; + __pyx_t_12[2] = __pyx_t_2; + __pyx_t_12[3] = __pyx_t_10; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_12, 4, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10)); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 116, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_backup_name = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "loggerModule.py":119 + * + * # + * if os.path.exists(self.baseFilename): # <<<<<<<<<<<<<< + * try: + * os.rename(self.baseFilename, backup_name) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_10); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_2}; + __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_exists, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 119, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 119, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":120 + * # + * if os.path.exists(self.baseFilename): + * try: # <<<<<<<<<<<<<< + * os.rename(self.baseFilename, backup_name) + * except OSError: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + /*try:*/ { + + /* "loggerModule.py":121 + * if os.path.exists(self.baseFilename): + * try: + * os.rename(self.baseFilename, backup_name) # <<<<<<<<<<<<<< + * except OSError: + * # rename +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_rename); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 121, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_10); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_2, __pyx_v_backup_name}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 121, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":120 + * # + * if os.path.exists(self.baseFilename): + * try: # <<<<<<<<<<<<<< + * os.rename(self.baseFilename, backup_name) + * except OSError: +*/ + } + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + goto __pyx_L17_try_end; + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "loggerModule.py":122 + * try: + * os.rename(self.baseFilename, backup_name) + * except OSError: # <<<<<<<<<<<<<< + * # rename + * try: +*/ + __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError); + if (__pyx_t_17) { + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._do_rollover", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_10, &__pyx_t_2) < 0) __PYX_ERR(0, 122, __pyx_L14_except_error) + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_2); + + /* "loggerModule.py":124 + * except OSError: + * # rename + * try: # <<<<<<<<<<<<<< + * import shutil + * shutil.copy2(self.baseFilename, backup_name) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_20); + /*try:*/ { + + /* "loggerModule.py":125 + * # rename + * try: + * import shutil # <<<<<<<<<<<<<< + * shutil.copy2(self.baseFilename, backup_name) + * # ( ) +*/ + __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_shutil, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_shutil = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":126 + * try: + * import shutil + * shutil.copy2(self.baseFilename, backup_name) # <<<<<<<<<<<<<< + * # ( ) + * with open(self.baseFilename, 'w', encoding=self.encoding) as f: +*/ + __pyx_t_8 = __pyx_v_shutil; + __Pyx_INCREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 126, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_9, __pyx_v_backup_name}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy2, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":128 + * shutil.copy2(self.baseFilename, backup_name) + * # ( ) + * with open(self.baseFilename, 'w', encoding=self.encoding) as f: # <<<<<<<<<<<<<< + * pass + * except Exception: +*/ + /*with:*/ { + __pyx_t_9 = NULL; + __Pyx_INCREF(__pyx_builtin_open); + __pyx_t_8 = __pyx_builtin_open; + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 128, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_encoding); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 128, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[3 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_9, __pyx_t_21, __pyx_mstate_global->__pyx_n_u_w}; + __pyx_t_23 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 128, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_23); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_encoding, __pyx_t_22, __pyx_t_23, __pyx_callargs+3, 0) < 0) __PYX_ERR(0, 128, __pyx_L20_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_3, (3-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_23); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_24 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 128, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_24); + __pyx_t_23 = NULL; + __pyx_t_22 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 128, __pyx_L28_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_22))) { + __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_22); + assert(__pyx_t_23); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_22); + __Pyx_INCREF(__pyx_t_23); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_22, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_23, NULL}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_22, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L28_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_22 = __pyx_t_8; + __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + (void)__pyx_t_25; (void)__pyx_t_26; (void)__pyx_t_27; /* mark used */ + /*try:*/ { + __pyx_v_f = __pyx_t_22; + __pyx_t_22 = 0; + + /* "loggerModule.py":129 + * # ( ) + * with open(self.baseFilename, 'w', encoding=self.encoding) as f: + * pass # <<<<<<<<<<<<<< + * except Exception: + * pass +*/ + } + } + } + + /* "loggerModule.py":128 + * shutil.copy2(self.baseFilename, backup_name) + * # ( ) + * with open(self.baseFilename, 'w', encoding=self.encoding) as f: # <<<<<<<<<<<<<< + * pass + * except Exception: +*/ + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_24) { + __pyx_t_27 = __Pyx_PyObject_Call(__pyx_t_24, __pyx_mstate_global->__pyx_tuple[1], NULL); + __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0; + if (unlikely(!__pyx_t_27)) __PYX_ERR(0, 128, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_27); + __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; + } + goto __pyx_L33; + } + __pyx_L33:; + } + goto __pyx_L42; + __pyx_L28_error:; + __Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0; + goto __pyx_L20_error; + __pyx_L42:; + } + + /* "loggerModule.py":124 + * except OSError: + * # rename + * try: # <<<<<<<<<<<<<< + * import shutil + * shutil.copy2(self.baseFilename, backup_name) +*/ + } + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; + goto __pyx_L27_try_end; + __pyx_L20_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "loggerModule.py":130 + * with open(self.baseFilename, 'w', encoding=self.encoding) as f: + * pass + * except Exception: # <<<<<<<<<<<<<< + * pass + * +*/ + __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_17) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L21_exception_handled; + } + goto __pyx_L22_except_error; + + /* "loggerModule.py":124 + * except OSError: + * # rename + * try: # <<<<<<<<<<<<<< + * import shutil + * shutil.copy2(self.baseFilename, backup_name) +*/ + __pyx_L22_except_error:; + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); + goto __pyx_L14_except_error; + __pyx_L21_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); + __pyx_L27_try_end:; + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L13_exception_handled; + } + goto __pyx_L14_except_error; + + /* "loggerModule.py":120 + * # + * if os.path.exists(self.baseFilename): + * try: # <<<<<<<<<<<<<< + * os.rename(self.baseFilename, backup_name) + * except OSError: +*/ + __pyx_L14_except_error:; + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + goto __pyx_L3_error; + __pyx_L13_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + __pyx_L17_try_end:; + } + + /* "loggerModule.py":119 + * + * # + * if os.path.exists(self.baseFilename): # <<<<<<<<<<<<<< + * try: + * os.rename(self.baseFilename, backup_name) +*/ + } + + /* "loggerModule.py":134 + * + * # + * self._cleanup_old_backups() # <<<<<<<<<<<<<< + * + * except Exception as e: +*/ + __pyx_t_10 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_10); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_cleanup_old_backups, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":112 + * self._close_file() + * + * try: # <<<<<<<<<<<<<< + * # + * timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') +*/ + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "loggerModule.py":136 + * self._cleanup_old_backups() + * + * except Exception as e: # <<<<<<<<<<<<<< + * import sys + * print(f"[Logger] : {e}", file=sys.stderr) +*/ + __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_17) { + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._do_rollover", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_10, &__pyx_t_7) < 0) __PYX_ERR(0, 136, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_10); + __pyx_v_e = __pyx_t_10; + /*try:*/ { + + /* "loggerModule.py":137 + * + * except Exception as e: + * import sys # <<<<<<<<<<<<<< + * print(f"[Logger] : {e}", file=sys.stderr) + * +*/ + __pyx_t_22 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_sys, NULL); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 137, __pyx_L50_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_v_sys = __pyx_t_22; + __pyx_t_22 = 0; + + /* "loggerModule.py":138 + * except Exception as e: + * import sys + * print(f"[Logger] : {e}", file=sys.stderr) # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_builtin_print); + __pyx_t_8 = __pyx_builtin_print; + __pyx_t_23 = __Pyx_PyObject_FormatSimple(__pyx_v_e, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 138, __pyx_L50_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_21 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Logger_2, __pyx_t_23); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 138, __pyx_L50_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_sys, __pyx_mstate_global->__pyx_n_u_stderr); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 138, __pyx_L50_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_3 = 1; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, __pyx_t_21}; + __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 138, __pyx_L50_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_file, __pyx_t_23, __pyx_t_9, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 138, __pyx_L50_error) + __pyx_t_22 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_8, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 138, __pyx_L50_error) + __Pyx_GOTREF(__pyx_t_22); + } + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + } + + /* "loggerModule.py":136 + * self._cleanup_old_backups() + * + * except Exception as e: # <<<<<<<<<<<<<< + * import sys + * print(f"[Logger] : {e}", file=sys.stderr) +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0; + goto __pyx_L51; + } + __pyx_L50_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18); + if ( unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_18); + __pyx_t_17 = __pyx_lineno; __pyx_t_28 = __pyx_clineno; __pyx_t_29 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0; + } + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_ErrRestore(__pyx_t_16, __pyx_t_15, __pyx_t_14); + __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_28; __pyx_filename = __pyx_t_29; + goto __pyx_L5_except_error; + } + __pyx_L51:; + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + + /* "loggerModule.py":112 + * self._close_file() + * + * try: # <<<<<<<<<<<<<< + * # + * timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); + __pyx_L8_try_end:; + } + + /* "loggerModule.py":141 + * + * # + * self._open_file() # <<<<<<<<<<<<<< + * + * def _cleanup_old_backups(self): +*/ + __pyx_t_10 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_10); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_open_file, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":108 + * return False + * + * def _do_rollover(self): # <<<<<<<<<<<<<< + * """ - Windows """ + * self._close_file() +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_21); + __Pyx_XDECREF(__pyx_t_22); + __Pyx_XDECREF(__pyx_t_23); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._do_rollover", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_timestamp); + __Pyx_XDECREF(__pyx_v_base); + __Pyx_XDECREF(__pyx_v_ext); + __Pyx_XDECREF(__pyx_v_backup_name); + __Pyx_XDECREF(__pyx_v_shutil); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XDECREF(__pyx_v_sys); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":143 + * self._open_file() + * + * def _cleanup_old_backups(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_11_cleanup_old_backups(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_10_cleanup_old_backups, "\354\230\244\353\236\230\353\220\234 \353\260\261\354\227\205 \355\214\214\354\235\274 \354\240\225\353\246\254"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_11_cleanup_old_backups = {"_cleanup_old_backups", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_11_cleanup_old_backups, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_10_cleanup_old_backups}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_11_cleanup_old_backups(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_cleanup_old_backups (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 143, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 143, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_cleanup_old_backups", 0) < 0) __PYX_ERR(0, 143, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_cleanup_old_backups", 1, 1, 1, i); __PYX_ERR(0, 143, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 143, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_cleanup_old_backups", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 143, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._cleanup_old_backups", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_10_cleanup_old_backups(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":162 + * + * # backupCount + * backup_files.sort(key=lambda x: x[1], reverse=True) # <<<<<<<<<<<<<< + * for file_path, _ in backup_files[self.backupCount:]: + * try: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_20_cleanup_old_backups_lambda(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_20_cleanup_old_backups_lambda = {"lambda", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_20_cleanup_old_backups_lambda, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_20_cleanup_old_backups_lambda(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_x = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 162, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 162, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda", 0) < 0) __PYX_ERR(0, 162, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, i); __PYX_ERR(0, 162, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 162, __pyx_L3_error) + } + __pyx_v_x = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 162, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._cleanup_old_backups.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, __pyx_v_x); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._cleanup_old_backups.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":143 + * self._open_file() + * + * def _cleanup_old_backups(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_10_cleanup_old_backups(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_v_base_dir = NULL; + PyObject *__pyx_v_base_name = NULL; + PyObject *__pyx_v_name_without_ext = NULL; + PyObject *__pyx_v_ext = NULL; + PyObject *__pyx_v_backup_files = NULL; + PyObject *__pyx_v_f = NULL; + PyObject *__pyx_v_full_path = NULL; + PyObject *__pyx_v_mtime = NULL; + PyObject *__pyx_v_file_path = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + Py_ssize_t __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_t_12; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + int __pyx_t_18; + int __pyx_t_19; + Py_ssize_t __pyx_t_20; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_cleanup_old_backups", 0); + + /* "loggerModule.py":145 + * def _cleanup_old_backups(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * base_dir = os.path.dirname(self.baseFilename) + * base_name = os.path.basename(self.baseFilename) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "loggerModule.py":146 + * """ """ + * try: + * base_dir = os.path.dirname(self.baseFilename) # <<<<<<<<<<<<<< + * base_name = os.path.basename(self.baseFilename) + * name_without_ext, ext = os.path.splitext(base_name) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_dirname, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_base_dir = __pyx_t_4; + __pyx_t_4 = 0; + + /* "loggerModule.py":147 + * try: + * base_dir = os.path.dirname(self.baseFilename) + * base_name = os.path.basename(self.baseFilename) # <<<<<<<<<<<<<< + * name_without_ext, ext = os.path.splitext(base_name) + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 147, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_baseFilename); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_basename, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_base_name = __pyx_t_4; + __pyx_t_4 = 0; + + /* "loggerModule.py":148 + * base_dir = os.path.dirname(self.baseFilename) + * base_name = os.path.basename(self.baseFilename) + * name_without_ext, ext = os.path.splitext(base_name) # <<<<<<<<<<<<<< + * + * # : {name}_{timestamp}.log +*/ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_base_name}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_splitext, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 148, __pyx_L3_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_7); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_XGOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 148, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_7 = __pyx_t_9(__pyx_t_6); if (unlikely(!__pyx_t_7)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_5 = __pyx_t_9(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_6), 2) < 0) __PYX_ERR(0, 148, __pyx_L3_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L10_unpacking_done; + __pyx_L9_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 148, __pyx_L3_error) + __pyx_L10_unpacking_done:; + } + __pyx_v_name_without_ext = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v_ext = __pyx_t_5; + __pyx_t_5 = 0; + + /* "loggerModule.py":151 + * + * # : {name}_{timestamp}.log + * backup_files = [] # <<<<<<<<<<<<<< + * for f in os.listdir(base_dir): + * if f.startswith(name_without_ext + '_') and f.endswith(ext): +*/ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_backup_files = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":152 + * # : {name}_{timestamp}.log + * backup_files = [] + * for f in os.listdir(base_dir): # <<<<<<<<<<<<<< + * if f.startswith(name_without_ext + '_') and f.endswith(ext): + * full_path = os.path.join(base_dir, f) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 152, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_listdir); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_base_dir}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_6 = __pyx_t_4; __Pyx_INCREF(__pyx_t_6); + __pyx_t_10 = 0; + __pyx_t_11 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 152, __pyx_L3_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_11)) { + if (likely(PyList_CheckExact(__pyx_t_6))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 152, __pyx_L3_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_10); + ++__pyx_t_10; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 152, __pyx_L3_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10)); + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_10); + #endif + ++__pyx_t_10; + } + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L3_error) + } else { + __pyx_t_4 = __pyx_t_11(__pyx_t_6); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 152, __pyx_L3_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_f, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":153 + * backup_files = [] + * for f in os.listdir(base_dir): + * if f.startswith(name_without_ext + '_') and f.endswith(ext): # <<<<<<<<<<<<<< + * full_path = os.path.join(base_dir, f) + * try: +*/ + __pyx_t_5 = __pyx_v_f; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_7 = PyNumber_Add(__pyx_v_name_without_ext, __pyx_mstate_global->__pyx_n_u__2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 153, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_startswith, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 153, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_13) { + } else { + __pyx_t_12 = __pyx_t_13; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_7 = __pyx_v_f; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_ext}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_endswith, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 153, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_12 = __pyx_t_13; + __pyx_L14_bool_binop_done:; + if (__pyx_t_12) { + + /* "loggerModule.py":154 + * for f in os.listdir(base_dir): + * if f.startswith(name_without_ext + '_') and f.endswith(ext): + * full_path = os.path.join(base_dir, f) # <<<<<<<<<<<<<< + * try: + * mtime = os.path.getmtime(full_path) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 154, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 154, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __pyx_t_14; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_v_base_dir, __pyx_v_f}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_join, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_full_path, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":155 + * if f.startswith(name_without_ext + '_') and f.endswith(ext): + * full_path = os.path.join(base_dir, f) + * try: # <<<<<<<<<<<<<< + * mtime = os.path.getmtime(full_path) + * backup_files.append((full_path, mtime)) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_17); + /*try:*/ { + + /* "loggerModule.py":156 + * full_path = os.path.join(base_dir, f) + * try: + * mtime = os.path.getmtime(full_path) # <<<<<<<<<<<<<< + * backup_files.append((full_path, mtime)) + * except Exception: +*/ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 156, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 156, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_14 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_14); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_14, __pyx_v_full_path}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_getmtime, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 156, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_mtime, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":157 + * try: + * mtime = os.path.getmtime(full_path) + * backup_files.append((full_path, mtime)) # <<<<<<<<<<<<<< + * except Exception: + * pass +*/ + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_full_path); + __Pyx_GIVEREF(__pyx_v_full_path); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_full_path) != (0)) __PYX_ERR(0, 157, __pyx_L16_error); + __Pyx_INCREF(__pyx_v_mtime); + __Pyx_GIVEREF(__pyx_v_mtime); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_mtime) != (0)) __PYX_ERR(0, 157, __pyx_L16_error); + __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_backup_files, __pyx_t_4); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 157, __pyx_L16_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":155 + * if f.startswith(name_without_ext + '_') and f.endswith(ext): + * full_path = os.path.join(base_dir, f) + * try: # <<<<<<<<<<<<<< + * mtime = os.path.getmtime(full_path) + * backup_files.append((full_path, mtime)) +*/ + } + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + goto __pyx_L23_try_end; + __pyx_L16_error:; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":158 + * mtime = os.path.getmtime(full_path) + * backup_files.append((full_path, mtime)) + * except Exception: # <<<<<<<<<<<<<< + * pass + * +*/ + __pyx_t_19 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_19) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L17_exception_handled; + } + goto __pyx_L18_except_error; + + /* "loggerModule.py":155 + * if f.startswith(name_without_ext + '_') and f.endswith(ext): + * full_path = os.path.join(base_dir, f) + * try: # <<<<<<<<<<<<<< + * mtime = os.path.getmtime(full_path) + * backup_files.append((full_path, mtime)) +*/ + __pyx_L18_except_error:; + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); + goto __pyx_L3_error; + __pyx_L17_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); + __pyx_L23_try_end:; + } + + /* "loggerModule.py":153 + * backup_files = [] + * for f in os.listdir(base_dir): + * if f.startswith(name_without_ext + '_') and f.endswith(ext): # <<<<<<<<<<<<<< + * full_path = os.path.join(base_dir, f) + * try: +*/ + } + + /* "loggerModule.py":152 + * # : {name}_{timestamp}.log + * backup_files = [] + * for f in os.listdir(base_dir): # <<<<<<<<<<<<<< + * if f.startswith(name_without_ext + '_') and f.endswith(ext): + * full_path = os.path.join(base_dir, f) +*/ + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":162 + * + * # backupCount + * backup_files.sort(key=lambda x: x[1], reverse=True) # <<<<<<<<<<<<<< + * for file_path, _ in backup_files[self.backupCount:]: + * try: +*/ + __pyx_t_4 = __pyx_v_backup_files; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_20_cleanup_old_backups_lambda, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 162, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_4, NULL}; + __pyx_t_14 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 162, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_14); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_5, __pyx_t_14, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 162, __pyx_L3_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_reverse, Py_True, __pyx_t_14, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 162, __pyx_L3_error) + __pyx_t_6 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_14); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 162, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":163 + * # backupCount + * backup_files.sort(key=lambda x: x[1], reverse=True) + * for file_path, _ in backup_files[self.backupCount:]: # <<<<<<<<<<<<<< + * try: + * os.remove(file_path) +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_backupCount); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = (__pyx_t_6 == Py_None); + if (__pyx_t_12) { + __pyx_t_10 = 0; + } else { + __pyx_t_20 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_20 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L3_error) + __pyx_t_10 = __pyx_t_20; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyList_GetSlice(__pyx_v_backup_files, __pyx_t_10, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_14 = __pyx_t_6; __Pyx_INCREF(__pyx_t_14); + __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_14); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 163, __pyx_L3_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + __pyx_t_6 = __Pyx_PyList_GetItemRef(__pyx_t_14, __pyx_t_10); + ++__pyx_t_10; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { + PyObject* sequence = __pyx_t_6; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 163, __pyx_L3_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 163, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); + index = 0; __pyx_t_5 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L29_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_4 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L29_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_7), 2) < 0) __PYX_ERR(0, 163, __pyx_L3_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L30_unpacking_done; + __pyx_L29_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 163, __pyx_L3_error) + __pyx_L30_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_file_path, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":164 + * backup_files.sort(key=lambda x: x[1], reverse=True) + * for file_path, _ in backup_files[self.backupCount:]: + * try: # <<<<<<<<<<<<<< + * os.remove(file_path) + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_15); + /*try:*/ { + + /* "loggerModule.py":165 + * for file_path, _ in backup_files[self.backupCount:]: + * try: + * os.remove(file_path) # <<<<<<<<<<<<<< + * except Exception: + * pass +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 165, __pyx_L31_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_remove); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L31_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_file_path}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 165, __pyx_L31_error) + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":164 + * backup_files.sort(key=lambda x: x[1], reverse=True) + * for file_path, _ in backup_files[self.backupCount:]: + * try: # <<<<<<<<<<<<<< + * os.remove(file_path) + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L38_try_end; + __pyx_L31_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":166 + * try: + * os.remove(file_path) + * except Exception: # <<<<<<<<<<<<<< + * pass + * except Exception: +*/ + __pyx_t_19 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_19) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L32_exception_handled; + } + goto __pyx_L33_except_error; + + /* "loggerModule.py":164 + * backup_files.sort(key=lambda x: x[1], reverse=True) + * for file_path, _ in backup_files[self.backupCount:]: + * try: # <<<<<<<<<<<<<< + * os.remove(file_path) + * except Exception: +*/ + __pyx_L33_except_error:; + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15); + goto __pyx_L3_error; + __pyx_L32_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15); + __pyx_L38_try_end:; + } + + /* "loggerModule.py":163 + * # backupCount + * backup_files.sort(key=lambda x: x[1], reverse=True) + * for file_path, _ in backup_files[self.backupCount:]: # <<<<<<<<<<<<<< + * try: + * os.remove(file_path) +*/ + } + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "loggerModule.py":145 + * def _cleanup_old_backups(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * base_dir = os.path.dirname(self.baseFilename) + * base_name = os.path.basename(self.baseFilename) +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":168 + * except Exception: + * pass + * except Exception: # <<<<<<<<<<<<<< + * pass + * +*/ + __pyx_t_19 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_19) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L4_exception_handled; + } + goto __pyx_L5_except_error; + + /* "loggerModule.py":145 + * def _cleanup_old_backups(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * base_dir = os.path.dirname(self.baseFilename) + * base_name = os.path.basename(self.baseFilename) +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L4_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L8_try_end:; + } + + /* "loggerModule.py":143 + * self._open_file() + * + * def _cleanup_old_backups(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler._cleanup_old_backups", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_base_dir); + __Pyx_XDECREF(__pyx_v_base_name); + __Pyx_XDECREF(__pyx_v_name_without_ext); + __Pyx_XDECREF(__pyx_v_ext); + __Pyx_XDECREF(__pyx_v_backup_files); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XDECREF(__pyx_v_full_path); + __Pyx_XDECREF(__pyx_v_mtime); + __Pyx_XDECREF(__pyx_v_file_path); + __Pyx_XDECREF(__pyx_v__); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":171 + * pass + * + * def emit(self, record): # <<<<<<<<<<<<<< + * """ """ + * with self._lock: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_13emit(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_12emit, "\353\241\234\352\267\270 \353\240\210\354\275\224\353\223\234 \354\266\234\353\240\245"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_13emit = {"emit", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_13emit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_12emit}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_13emit(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_record = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("emit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_record,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 171, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 171, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 171, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "emit", 0) < 0) __PYX_ERR(0, 171, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("emit", 1, 2, 2, i); __PYX_ERR(0, 171, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 171, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 171, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_record = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("emit", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 171, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.emit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_12emit(__pyx_self, __pyx_v_self, __pyx_v_record); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_12emit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_record) { + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("emit", 0); + + /* "loggerModule.py":173 + * def emit(self, record): + * """ """ + * with self._lock: # <<<<<<<<<<<<<< + * try: + * # +*/ + /*with:*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lock); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 173, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "loggerModule.py":174 + * """ """ + * with self._lock: + * try: # <<<<<<<<<<<<<< + * # + * if self._should_rollover(): +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "loggerModule.py":176 + * try: + * # + * if self._should_rollover(): # <<<<<<<<<<<<<< + * self._do_rollover() + * +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_should_rollover, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 176, __pyx_L13_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":177 + * # + * if self._should_rollover(): + * self._do_rollover() # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_do_rollover, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":176 + * try: + * # + * if self._should_rollover(): # <<<<<<<<<<<<<< + * self._do_rollover() + * +*/ + } + + /* "loggerModule.py":180 + * + * # + * if self.stream is None: # <<<<<<<<<<<<<< + * self._open_file() + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_13 = (__pyx_t_1 == Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":181 + * # + * if self.stream is None: + * self._open_file() # <<<<<<<<<<<<<< + * + * if self.stream: +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_open_file, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":180 + * + * # + * if self.stream is None: # <<<<<<<<<<<<<< + * self._open_file() + * +*/ + } + + /* "loggerModule.py":183 + * self._open_file() + * + * if self.stream: # <<<<<<<<<<<<<< + * msg = self.format(record) + * self.stream.write(msg + '\n') +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 183, __pyx_L13_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":184 + * + * if self.stream: + * msg = self.format(record) # <<<<<<<<<<<<<< + * self.stream.write(msg + '\n') + * self.stream.flush() +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_record}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_msg = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":185 + * if self.stream: + * msg = self.format(record) + * self.stream.write(msg + '\n') # <<<<<<<<<<<<<< + * self.stream.flush() + * except Exception: +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Add(__pyx_v_msg, __pyx_mstate_global->__pyx_kp_u__3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 185, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_write, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":186 + * msg = self.format(record) + * self.stream.write(msg + '\n') + * self.stream.flush() # <<<<<<<<<<<<<< + * except Exception: + * self.handleError(record) +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_stream); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_flush, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":183 + * self._open_file() + * + * if self.stream: # <<<<<<<<<<<<<< + * msg = self.format(record) + * self.stream.write(msg + '\n') +*/ + } + + /* "loggerModule.py":174 + * """ """ + * with self._lock: + * try: # <<<<<<<<<<<<<< + * # + * if self._should_rollover(): +*/ + } + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L18_try_end; + __pyx_L13_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":187 + * self.stream.write(msg + '\n') + * self.stream.flush() + * except Exception: # <<<<<<<<<<<<<< + * self.handleError(record) + * +*/ + __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_14) { + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.emit", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 187, __pyx_L15_except_error) + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + + /* "loggerModule.py":188 + * self.stream.flush() + * except Exception: + * self.handleError(record) # <<<<<<<<<<<<<< + * + * def close(self): +*/ + __pyx_t_15 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_15); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_v_record}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_handleError, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L15_except_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L14_exception_handled; + } + goto __pyx_L15_except_error; + + /* "loggerModule.py":174 + * """ """ + * with self._lock: + * try: # <<<<<<<<<<<<<< + * # + * if self._should_rollover(): +*/ + __pyx_L15_except_error:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L7_error; + __pyx_L14_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + __pyx_L18_try_end:; + } + + /* "loggerModule.py":173 + * def emit(self, record): + * """ """ + * with self._lock: # <<<<<<<<<<<<<< + * try: + * # +*/ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + /*except:*/ { + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.emit", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_1) < 0) __PYX_ERR(0, 173, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_Pack(3, __pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 173, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (__pyx_t_13 < 0) __PYX_ERR(0, 173, __pyx_L9_except_error) + __pyx_t_16 = (!__pyx_t_13); + if (unlikely(__pyx_t_16)) { + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_1); + __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_1 = 0; + __PYX_ERR(0, 173, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_2) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[1], NULL); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L27; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L1_error; + __pyx_L27:; + } + + /* "loggerModule.py":171 + * pass + * + * def emit(self, record): # <<<<<<<<<<<<<< + * """ """ + * with self._lock: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.emit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":190 + * self.handleError(record) + * + * def close(self): # <<<<<<<<<<<<<< + * """ """ + * with self._lock: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_15close(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_14close, "\355\225\270\353\223\244\353\237\254 \354\242\205\353\243\214"); +static PyMethodDef __pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_15close = {"close", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_15close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_30WindowsSafeRotatingFileHandler_14close}; +static PyObject *__pyx_pw_12loggerModule_30WindowsSafeRotatingFileHandler_15close(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 190, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 190, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "close", 0) < 0) __PYX_ERR(0, 190, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("close", 1, 1, 1, i); __PYX_ERR(0, 190, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 190, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("close", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 190, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.close", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_14close(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_30WindowsSafeRotatingFileHandler_14close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("close", 0); + + /* "loggerModule.py":192 + * def close(self): + * """ """ + * with self._lock: # <<<<<<<<<<<<<< + * self._close_file() + * super().close() +*/ + /*with:*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lock); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 192, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "loggerModule.py":193 + * """ """ + * with self._lock: + * self._close_file() # <<<<<<<<<<<<<< + * super().close() + * +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_close_file, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":192 + * def close(self): + * """ """ + * with self._lock: # <<<<<<<<<<<<<< + * self._close_file() + * super().close() +*/ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + /*except:*/ { + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.close", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_3, &__pyx_t_5) < 0) __PYX_ERR(0, 192, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_5); + __pyx_t_4 = PyTuple_Pack(3, __pyx_t_1, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 192, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 192, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_10); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_11 < 0) __PYX_ERR(0, 192, __pyx_L9_except_error) + __pyx_t_12 = (!__pyx_t_11); + if (unlikely(__pyx_t_12)) { + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_3, __pyx_t_5); + __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_5 = 0; + __PYX_ERR(0, 192, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_2) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[1], NULL); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "loggerModule.py":194 + * with self._lock: + * self._close_file() + * super().close() # <<<<<<<<<<<<<< + * + * class Logger: +*/ + __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_builtin_super); + __pyx_t_13 = __pyx_builtin_super; + __pyx_t_14 = __Pyx_CyFunction_GetClassObj(__pyx_self); + if (!__pyx_t_14) { PyErr_SetString(PyExc_RuntimeError, "super(): empty __class__ cell"); __PYX_ERR(0, 194, __pyx_L1_error) } + __Pyx_INCREF(__pyx_t_14); + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_14, __pyx_v_self}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_close, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":190 + * self.handleError(record) + * + * def close(self): # <<<<<<<<<<<<<< + * """ """ + * with self._lock: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("loggerModule.WindowsSafeRotatingFileHandler.close", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":198 + * class Logger: + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", # <<<<<<<<<<<<<< + * file_log_level=logging.DEBUG, gui_log_level=logging.INFO, + * max_days=3, cleanup_interval=3600): +*/ + +static PyObject *__pyx_pf_12loggerModule_18__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, Py_None) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_kp_u_Edit_PartTimer_log_log)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_kp_u_Edit_PartTimer_log_log)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject*)__pyx_mstate_global->__pyx_kp_u_Edit_PartTimer_log_log)) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_Edit_PartTimer_log)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_Edit_PartTimer_log)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject*)__pyx_mstate_global->__pyx_n_u_Edit_PartTimer_log)) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg1); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg1) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_int_3)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_int_3)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 5, ((PyObject*)__pyx_mstate_global->__pyx_int_3)) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_int_3600)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_int_3600)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 6, ((PyObject*)__pyx_mstate_global->__pyx_int_3600)) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 198, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("loggerModule.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger___init__, "\n \352\260\234\354\204\240\353\220\234 Logger \354\264\210\352\270\260\355\231\224 (\354\204\234\353\262\204/CLI\354\232\251)\n :param gui_logger: \354\204\240\355\203\235\354\240\201 \354\275\234\353\260\261 \355\225\250\354\210\230(\353\251\224\354\213\234\354\247\200 \354\210\230\354\213\240\354\232\251)\n :param log_file: \353\241\234\352\267\270 \355\214\214\354\235\274 \354\235\264\353\246\204\n :param logger_name: \353\241\234\352\261\260 \354\235\264\353\246\204\n :param file_log_level: \355\214\214\354\235\274 \353\241\234\352\261\260\354\235\230 \353\241\234\352\267\270 \353\240\210\353\262\250\n :param gui_log_level: \354\275\234\353\260\261 \355\230\270\354\266\234 \353\241\234\352\267\270 \353\240\210\353\262\250(\352\270\260\353\263\270 INFO)\n :param max_days: \353\241\234\352\267\270 \355\214\214\354\235\274 \353\263\264\352\264\200 \354\235\274\354\210\230 (\352\270\260\353\263\270 3\354\235\274)\n :param cleanup_interval: \354\240\225\353\246\254 \354\236\221\354\227\205 \352\260\204\352\262\251(\354\264\210, \352\270\260\353\263\270 1\354\213\234\352\260\204)\n "); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger___init__}; +static PyObject *__pyx_pw_12loggerModule_6Logger_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_gui_logger = 0; + PyObject *__pyx_v_log_file = 0; + PyObject *__pyx_v_logger_name = 0; + PyObject *__pyx_v_file_log_level = 0; + PyObject *__pyx_v_gui_log_level = 0; + PyObject *__pyx_v_max_days = 0; + PyObject *__pyx_v_cleanup_interval = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_gui_logger,&__pyx_mstate_global->__pyx_n_u_log_file,&__pyx_mstate_global->__pyx_n_u_logger_name,&__pyx_mstate_global->__pyx_n_u_file_log_level,&__pyx_mstate_global->__pyx_n_u_gui_log_level,&__pyx_mstate_global->__pyx_n_u_max_days,&__pyx_mstate_global->__pyx_n_u_cleanup_interval,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 198, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < 0) __PYX_ERR(0, 198, __pyx_L3_error) + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_kp_u_Edit_PartTimer_log_log))); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_Edit_PartTimer_log))); + if (!values[4]) values[4] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + if (!values[5]) values[5] = __Pyx_NewRef(__pyx_dynamic_args->arg1); + if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_3))); + if (!values[7]) values[7] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_3600))); + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 8, i); __PYX_ERR(0, 198, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 198, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 198, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_kp_u_Edit_PartTimer_log_log))); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_Edit_PartTimer_log))); + if (!values[4]) values[4] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + if (!values[5]) values[5] = __Pyx_NewRef(__pyx_dynamic_args->arg1); + if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_3))); + if (!values[7]) values[7] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_3600))); + } + __pyx_v_self = values[0]; + __pyx_v_gui_logger = values[1]; + __pyx_v_log_file = values[2]; + __pyx_v_logger_name = values[3]; + __pyx_v_file_log_level = values[4]; + __pyx_v_gui_log_level = values[5]; + __pyx_v_max_days = values[6]; + __pyx_v_cleanup_interval = values[7]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 8, __pyx_nargs); __PYX_ERR(0, 198, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger___init__(__pyx_self, __pyx_v_self, __pyx_v_gui_logger, __pyx_v_log_file, __pyx_v_logger_name, __pyx_v_file_log_level, __pyx_v_gui_log_level, __pyx_v_max_days, __pyx_v_cleanup_interval); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_gui_logger, PyObject *__pyx_v_log_file, PyObject *__pyx_v_logger_name, PyObject *__pyx_v_file_log_level, PyObject *__pyx_v_gui_log_level, PyObject *__pyx_v_max_days, PyObject *__pyx_v_cleanup_interval) { + PyObject *__pyx_v_pid = NULL; + PyObject *__pyx_v_base_name = NULL; + PyObject *__pyx_v_ext = NULL; + PyObject *__pyx_v_handler = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7[4]; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9[3]; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + PyObject *(*__pyx_t_12)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "loggerModule.py":211 + * :param cleanup_interval: (, 1) + * """ + * self.gui_logger = gui_logger # <<<<<<<<<<<<<< + * self.file_log_level = file_log_level + * self.gui_log_level = gui_log_level +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_logger, __pyx_v_gui_logger) < 0) __PYX_ERR(0, 211, __pyx_L1_error) + + /* "loggerModule.py":212 + * """ + * self.gui_logger = gui_logger + * self.file_log_level = file_log_level # <<<<<<<<<<<<<< + * self.gui_log_level = gui_log_level + * self.max_days = max_days +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_file_log_level, __pyx_v_file_log_level) < 0) __PYX_ERR(0, 212, __pyx_L1_error) + + /* "loggerModule.py":213 + * self.gui_logger = gui_logger + * self.file_log_level = file_log_level + * self.gui_log_level = gui_log_level # <<<<<<<<<<<<<< + * self.max_days = max_days + * self.cleanup_interval = cleanup_interval +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_log_level, __pyx_v_gui_log_level) < 0) __PYX_ERR(0, 213, __pyx_L1_error) + + /* "loggerModule.py":214 + * self.file_log_level = file_log_level + * self.gui_log_level = gui_log_level + * self.max_days = max_days # <<<<<<<<<<<<<< + * self.cleanup_interval = cleanup_interval + * self.log_dir = Path(log_file).parent +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_max_days, __pyx_v_max_days) < 0) __PYX_ERR(0, 214, __pyx_L1_error) + + /* "loggerModule.py":215 + * self.gui_log_level = gui_log_level + * self.max_days = max_days + * self.cleanup_interval = cleanup_interval # <<<<<<<<<<<<<< + * self.log_dir = Path(log_file).parent + * self.log_base_name = Path(log_file).stem +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cleanup_interval, __pyx_v_cleanup_interval) < 0) __PYX_ERR(0, 215, __pyx_L1_error) + + /* "loggerModule.py":216 + * self.max_days = max_days + * self.cleanup_interval = cleanup_interval + * self.log_dir = Path(log_file).parent # <<<<<<<<<<<<<< + * self.log_base_name = Path(log_file).stem + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_log_file}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_parent); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_dir, __pyx_t_3) < 0) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":217 + * self.cleanup_interval = cleanup_interval + * self.log_dir = Path(log_file).parent + * self.log_base_name = Path(log_file).stem # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_log_file}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_stem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_base_name, __pyx_t_2) < 0) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":220 + * + * # + * self.log_dir.mkdir(parents=True, exist_ok=True) # <<<<<<<<<<<<<< + * + * # PID +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_dir); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, NULL}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_parents, Py_True, __pyx_t_5, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 220, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exist_ok, Py_True, __pyx_t_5, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 220, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_mkdir, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":225 + * # () PermissionError + * # . + * pid = os.getpid() # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_getpid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_pid = __pyx_t_2; + __pyx_t_2 = 0; + + /* "loggerModule.py":228 + * + * # + * if log_file.endswith('.log'): # <<<<<<<<<<<<<< + * base_name = log_file[:-4] + * ext = '.log' +*/ + __pyx_t_3 = __pyx_v_log_file; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_log}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_endswith, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { + + /* "loggerModule.py":229 + * # + * if log_file.endswith('.log'): + * base_name = log_file[:-4] # <<<<<<<<<<<<<< + * ext = '.log' + * else: +*/ + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_log_file, 0, -4L, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_base_name = __pyx_t_2; + __pyx_t_2 = 0; + + /* "loggerModule.py":230 + * if log_file.endswith('.log'): + * base_name = log_file[:-4] + * ext = '.log' # <<<<<<<<<<<<<< + * else: + * base_name = log_file +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_log); + __pyx_v_ext = __pyx_mstate_global->__pyx_kp_u_log; + + /* "loggerModule.py":228 + * + * # + * if log_file.endswith('.log'): # <<<<<<<<<<<<<< + * base_name = log_file[:-4] + * ext = '.log' +*/ + goto __pyx_L3; + } + + /* "loggerModule.py":232 + * ext = '.log' + * else: + * base_name = log_file # <<<<<<<<<<<<<< + * ext = '.log' + * +*/ + /*else*/ { + __Pyx_INCREF(__pyx_v_log_file); + __pyx_v_base_name = __pyx_v_log_file; + + /* "loggerModule.py":233 + * else: + * base_name = log_file + * ext = '.log' # <<<<<<<<<<<<<< + * + * # PID (: app_1234.log) +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_log); + __pyx_v_ext = __pyx_mstate_global->__pyx_kp_u_log; + } + __pyx_L3:; + + /* "loggerModule.py":238 + * # , + * # PID . + * self.actual_log_file = self.log_dir / f"{Path(base_name).stem}_{pid}{ext}" # <<<<<<<<<<<<<< + * + * # cleanup (PID ) +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_dir); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_base_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_stem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_pid, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7[0] = __pyx_t_1; + __pyx_t_7[1] = __pyx_mstate_global->__pyx_n_u__2; + __pyx_t_7[2] = __pyx_t_3; + __pyx_t_7[3] = __pyx_v_ext; + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + __Pyx_PyUnicode_GET_LENGTH(__pyx_v_ext), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_ext)); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actual_log_file, __pyx_t_3) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":242 + * # cleanup (PID ) + * # self.log_base_name stem PID + * self.log_base_name = Path(log_file).stem # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_log_file}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_stem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_base_name, __pyx_t_2) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":245 + * + * # + * self.logger = logging.getLogger(f"{logger_name}_{pid}") # # <<<<<<<<<<<<<< + * self.logger.setLevel(file_log_level) + * # ( ) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_getLogger); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_logger_name, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_pid, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9[0] = __pyx_t_5; + __pyx_t_9[1] = __pyx_mstate_global->__pyx_n_u__2; + __pyx_t_9[2] = __pyx_t_8; + __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_9, 3, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8)); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_1, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_10}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger, __pyx_t_2) < 0) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":246 + * # + * self.logger = logging.getLogger(f"{logger_name}_{pid}") # + * self.logger.setLevel(file_log_level) # <<<<<<<<<<<<<< + * # ( ) + * self.logger.propagate = False +*/ + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_1 = __pyx_t_10; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_file_log_level}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setLevel, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":248 + * self.logger.setLevel(file_log_level) + * # ( ) + * self.logger.propagate = False # <<<<<<<<<<<<<< + * + * # ( ) +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_propagate, Py_False) < 0) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":251 + * + * # ( ) + * for handler in self.logger.handlers[:]: # <<<<<<<<<<<<<< + * self.logger.removeHandler(handler) + * +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_handlers); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_10, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[1], 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_10 = __pyx_t_2; __Pyx_INCREF(__pyx_t_10); + __pyx_t_11 = 0; + __pyx_t_12 = NULL; + } else { + __pyx_t_11 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 251, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_12)) { + if (likely(PyList_CheckExact(__pyx_t_10))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 251, __pyx_L1_error) + #endif + if (__pyx_t_11 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_10, __pyx_t_11); + ++__pyx_t_11; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 251, __pyx_L1_error) + #endif + if (__pyx_t_11 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_11)); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_11); + #endif + ++__pyx_t_11; + } + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error) + } else { + __pyx_t_2 = __pyx_t_12(__pyx_t_10); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 251, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_handler, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":252 + * # ( ) + * for handler in self.logger.handlers[:]: + * self.logger.removeHandler(handler) # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_handler}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_removeHandler, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":251 + * + * # ( ) + * for handler in self.logger.handlers[:]: # <<<<<<<<<<<<<< + * self.logger.removeHandler(handler) + * +*/ + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "loggerModule.py":255 + * + * # + * self.simple_format = "[%(asctime)s] [%(levelname)s] %(message)s" # <<<<<<<<<<<<<< + * self.detailed_format = ( + * "[%(asctime)s] [%(threadName)s] [%(levelname)s] " +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simple_format, __pyx_mstate_global->__pyx_kp_u_asctime_s_levelname_s_message_s) < 0) __PYX_ERR(0, 255, __pyx_L1_error) + + /* "loggerModule.py":256 + * # + * self.simple_format = "[%(asctime)s] [%(levelname)s] %(message)s" + * self.detailed_format = ( # <<<<<<<<<<<<<< + * "[%(asctime)s] [%(threadName)s] [%(levelname)s] " + * "[%(filename)s:%(funcName)s:%(lineno)d] %(message)s" +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_detailed_format, __pyx_mstate_global->__pyx_kp_u_asctime_s_threadName_s_levelnam) < 0) __PYX_ERR(0, 256, __pyx_L1_error) + + /* "loggerModule.py":264 + * + * # + * self._add_console_handler(file_log_level) # <<<<<<<<<<<<<< + * # (PID ) + * self._add_file_handler(str(self.actual_log_file), file_log_level) +*/ + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_file_log_level}; + __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_console_handler, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "loggerModule.py":266 + * self._add_console_handler(file_log_level) + * # (PID ) + * self._add_file_handler(str(self.actual_log_file), file_log_level) # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_actual_log_file); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_file_log_level}; + __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_add_file_handler, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "loggerModule.py":269 + * + * # + * self._start_cleanup_thread() # <<<<<<<<<<<<<< + * + * def _add_console_handler(self, level): +*/ + __pyx_t_1 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_10 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_start_cleanup_thread, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "loggerModule.py":198 + * class Logger: + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", # <<<<<<<<<<<<<< + * file_log_level=logging.DEBUG, gui_log_level=logging.INFO, + * max_days=3, cleanup_interval=3600): +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("loggerModule.Logger.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pid); + __Pyx_XDECREF(__pyx_v_base_name); + __Pyx_XDECREF(__pyx_v_ext); + __Pyx_XDECREF(__pyx_v_handler); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":271 + * self._start_cleanup_thread() + * + * def _add_console_handler(self, level): # <<<<<<<<<<<<<< + * """ """ + * console_handler = logging.StreamHandler() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_3_add_console_handler(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_2_add_console_handler, "\354\275\230\354\206\224 \355\225\270\353\223\244\353\237\254 \354\266\224\352\260\200"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_3_add_console_handler = {"_add_console_handler", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_3_add_console_handler, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_2_add_console_handler}; +static PyObject *__pyx_pw_12loggerModule_6Logger_3_add_console_handler(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_level = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_add_console_handler (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_level,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 271, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 271, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 271, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_add_console_handler", 0) < 0) __PYX_ERR(0, 271, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_add_console_handler", 1, 2, 2, i); __PYX_ERR(0, 271, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 271, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 271, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_level = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_add_console_handler", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 271, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger._add_console_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_2_add_console_handler(__pyx_self, __pyx_v_self, __pyx_v_level); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_2_add_console_handler(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_level) { + PyObject *__pyx_v_console_handler = NULL; + PyObject *__pyx_v_formatter = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_add_console_handler", 0); + + /* "loggerModule.py":273 + * def _add_console_handler(self, level): + * """ """ + * console_handler = logging.StreamHandler() # <<<<<<<<<<<<<< + * console_handler.setLevel(level) + * formatter = logging.Formatter( +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_StreamHandler); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_console_handler = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":274 + * """ """ + * console_handler = logging.StreamHandler() + * console_handler.setLevel(level) # <<<<<<<<<<<<<< + * formatter = logging.Formatter( + * self.detailed_format if level <= logging.DEBUG else self.simple_format +*/ + __pyx_t_4 = __pyx_v_console_handler; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_level}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setLevel, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":275 + * console_handler = logging.StreamHandler() + * console_handler.setLevel(level) + * formatter = logging.Formatter( # <<<<<<<<<<<<<< + * self.detailed_format if level <= logging.DEBUG else self.simple_format + * ) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Formatter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":276 + * console_handler.setLevel(level) + * formatter = logging.Formatter( + * self.detailed_format if level <= logging.DEBUG else self.simple_format # <<<<<<<<<<<<<< + * ) + * console_handler.setFormatter(formatter) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DEBUG); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyObject_RichCompare(__pyx_v_level, __pyx_t_7, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_detailed_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + } else { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simple_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + } + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_formatter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":278 + * self.detailed_format if level <= logging.DEBUG else self.simple_format + * ) + * console_handler.setFormatter(formatter) # <<<<<<<<<<<<<< + * self.logger.addHandler(console_handler) + * +*/ + __pyx_t_3 = __pyx_v_console_handler; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_formatter}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setFormatter, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":279 + * ) + * console_handler.setFormatter(formatter) + * self.logger.addHandler(console_handler) # <<<<<<<<<<<<<< + * + * def _add_file_handler(self, log_file, level): +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_console_handler}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_addHandler, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":271 + * self._start_cleanup_thread() + * + * def _add_console_handler(self, level): # <<<<<<<<<<<<<< + * """ """ + * console_handler = logging.StreamHandler() +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger._add_console_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_console_handler); + __Pyx_XDECREF(__pyx_v_formatter); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":281 + * self.logger.addHandler(console_handler) + * + * def _add_file_handler(self, log_file, level): # <<<<<<<<<<<<<< + * """ + (Windows )""" + * # .log .log +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_5_add_file_handler(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_4_add_file_handler, "\355\214\214\354\235\274 \355\201\254\352\270\260 \352\270\260\353\260\230 \353\241\234\355\205\214\354\235\264\355\214\205 + \354\210\230\353\252\205 \352\264\200\353\246\254 (Windows \355\230\270\355\231\230)"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_5_add_file_handler = {"_add_file_handler", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_5_add_file_handler, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_4_add_file_handler}; +static PyObject *__pyx_pw_12loggerModule_6Logger_5_add_file_handler(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_log_file = 0; + PyObject *__pyx_v_level = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_add_file_handler (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_log_file,&__pyx_mstate_global->__pyx_n_u_level,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 281, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 281, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 281, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 281, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_add_file_handler", 0) < 0) __PYX_ERR(0, 281, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_add_file_handler", 1, 3, 3, i); __PYX_ERR(0, 281, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 281, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 281, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 281, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_log_file = values[1]; + __pyx_v_level = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_add_file_handler", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 281, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger._add_file_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_4_add_file_handler(__pyx_self, __pyx_v_self, __pyx_v_log_file, __pyx_v_level); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_4_add_file_handler(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_log_file, PyObject *__pyx_v_level) { + PyObject *__pyx_v_base_name = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; + PyObject *__pyx_v_file_handler = NULL; + PyObject *__pyx_v_formatter = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_add_file_handler", 0); + __Pyx_INCREF(__pyx_v_log_file); + + /* "loggerModule.py":284 + * """ + (Windows )""" + * # .log .log + * if not log_file.endswith('.log'): # <<<<<<<<<<<<<< + * base_name, _ = os.path.splitext(log_file) + * log_file = base_name + '.log' +*/ + __pyx_t_2 = __pyx_v_log_file; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_log}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_endswith, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = (!__pyx_t_4); + if (__pyx_t_5) { + + /* "loggerModule.py":285 + * # .log .log + * if not log_file.endswith('.log'): + * base_name, _ = os.path.splitext(log_file) # <<<<<<<<<<<<<< + * log_file = base_name + '.log' + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_path); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_log_file}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_splitext, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 285, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_7); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_2); + } else { + __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_2); + } + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_7 = __pyx_t_8(__pyx_t_6); if (unlikely(!__pyx_t_7)) goto __pyx_L4_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_2 = __pyx_t_8(__pyx_t_6); if (unlikely(!__pyx_t_2)) goto __pyx_L4_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_6), 2) < 0) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L5_unpacking_done; + __pyx_L4_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_L5_unpacking_done:; + } + __pyx_v_base_name = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v__ = __pyx_t_2; + __pyx_t_2 = 0; + + /* "loggerModule.py":286 + * if not log_file.endswith('.log'): + * base_name, _ = os.path.splitext(log_file) + * log_file = base_name + '.log' # <<<<<<<<<<<<<< + * + * # Windows +*/ + __pyx_t_1 = PyNumber_Add(__pyx_v_base_name, __pyx_mstate_global->__pyx_kp_u_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_log_file, __pyx_t_1); + __pyx_t_1 = 0; + + /* "loggerModule.py":284 + * """ + (Windows )""" + * # .log .log + * if not log_file.endswith('.log'): # <<<<<<<<<<<<<< + * base_name, _ = os.path.splitext(log_file) + * log_file = base_name + '.log' +*/ + } + + /* "loggerModule.py":290 + * # Windows + * # RotatingFileHandler Windows + * file_handler = WindowsSafeRotatingFileHandler( # <<<<<<<<<<<<<< + * log_file, + * maxBytes=10 * 1024 * 1024, # 10MB +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "loggerModule.py":291 + * # RotatingFileHandler Windows + * file_handler = WindowsSafeRotatingFileHandler( + * log_file, # <<<<<<<<<<<<<< + * maxBytes=10 * 1024 * 1024, # 10MB + * backupCount=50, +*/ + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_2, __pyx_v_log_file}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_maxBytes, __pyx_mstate_global->__pyx_int_10485760, __pyx_t_6, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 290, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_backupCount, __pyx_mstate_global->__pyx_int_50, __pyx_t_6, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 290, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_encoding, __pyx_mstate_global->__pyx_kp_u_utf_8, __pyx_t_6, __pyx_callargs+2, 2) < 0) __PYX_ERR(0, 290, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_file_handler = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":297 + * ) + * + * file_handler.setLevel(level) # <<<<<<<<<<<<<< + * formatter = logging.Formatter( + * self.detailed_format if level <= logging.DEBUG else self.simple_format +*/ + __pyx_t_7 = __pyx_v_file_handler; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_level}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setLevel, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":298 + * + * file_handler.setLevel(level) + * formatter = logging.Formatter( # <<<<<<<<<<<<<< + * self.detailed_format if level <= logging.DEBUG else self.simple_format + * ) +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Formatter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":299 + * file_handler.setLevel(level) + * formatter = logging.Formatter( + * self.detailed_format if level <= logging.DEBUG else self.simple_format # <<<<<<<<<<<<<< + * ) + * file_handler.setFormatter(formatter) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_DEBUG); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyObject_RichCompare(__pyx_v_level, __pyx_t_10, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_5) { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_detailed_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = __pyx_t_9; + __pyx_t_9 = 0; + } else { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_simple_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = __pyx_t_9; + __pyx_t_9 = 0; + } + __pyx_t_3 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_3 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_formatter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":301 + * self.detailed_format if level <= logging.DEBUG else self.simple_format + * ) + * file_handler.setFormatter(formatter) # <<<<<<<<<<<<<< + * self.logger.addHandler(file_handler) + * +*/ + __pyx_t_2 = __pyx_v_file_handler; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_formatter}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setFormatter, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":302 + * ) + * file_handler.setFormatter(formatter) + * self.logger.addHandler(file_handler) # <<<<<<<<<<<<<< + * + * # ( ) +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_file_handler}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_addHandler, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":305 + * + * # ( ) + * self.file_handler = file_handler # <<<<<<<<<<<<<< + * + * def _start_cleanup_thread(self): +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_file_handler, __pyx_v_file_handler) < 0) __PYX_ERR(0, 305, __pyx_L1_error) + + /* "loggerModule.py":281 + * self.logger.addHandler(console_handler) + * + * def _add_file_handler(self, log_file, level): # <<<<<<<<<<<<<< + * """ + (Windows )""" + * # .log .log +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("loggerModule.Logger._add_file_handler", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_base_name); + __Pyx_XDECREF(__pyx_v__); + __Pyx_XDECREF(__pyx_v_file_handler); + __Pyx_XDECREF(__pyx_v_formatter); + __Pyx_XDECREF(__pyx_v_log_file); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":307 + * self.file_handler = file_handler + * + * def _start_cleanup_thread(self): # <<<<<<<<<<<<<< + * """ """ + * def cleanup_worker(): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_7_start_cleanup_thread(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_6_start_cleanup_thread, "\354\236\220\353\217\231 \354\240\225\353\246\254 \354\212\244\353\240\210\353\223\234 \354\213\234\354\236\221"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_7_start_cleanup_thread = {"_start_cleanup_thread", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_7_start_cleanup_thread, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_6_start_cleanup_thread}; +static PyObject *__pyx_pw_12loggerModule_6Logger_7_start_cleanup_thread(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_start_cleanup_thread (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 307, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 307, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_start_cleanup_thread", 0) < 0) __PYX_ERR(0, 307, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_start_cleanup_thread", 1, 1, 1, i); __PYX_ERR(0, 307, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 307, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_start_cleanup_thread", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 307, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger._start_cleanup_thread", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_6_start_cleanup_thread(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":309 + * def _start_cleanup_thread(self): + * """ """ + * def cleanup_worker(): # <<<<<<<<<<<<<< + * while True: + * try: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_21_start_cleanup_thread_1cleanup_worker(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_21_start_cleanup_thread_1cleanup_worker = {"cleanup_worker", (PyCFunction)__pyx_pw_12loggerModule_6Logger_21_start_cleanup_thread_1cleanup_worker, METH_NOARGS, 0}; +static PyObject *__pyx_pw_12loggerModule_6Logger_21_start_cleanup_thread_1cleanup_worker(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cleanup_worker (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_12loggerModule_6Logger_21_start_cleanup_thread_cleanup_worker(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_21_start_cleanup_thread_cleanup_worker(PyObject *__pyx_self) { + struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *__pyx_cur_scope; + struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *__pyx_outer_scope; + CYTHON_UNUSED PyObject *__pyx_v_e = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cleanup_worker", 0); + __pyx_outer_scope = (struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *) __Pyx_CyFunction_GetClosure(__pyx_self); + __pyx_cur_scope = __pyx_outer_scope; + + /* "loggerModule.py":310 + * """ """ + * def cleanup_worker(): + * while True: # <<<<<<<<<<<<<< + * try: + * self._cleanup_old_logs() +*/ + while (1) { + + /* "loggerModule.py":311 + * def cleanup_worker(): + * while True: + * try: # <<<<<<<<<<<<<< + * self._cleanup_old_logs() + * time.sleep(self.cleanup_interval) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "loggerModule.py":312 + * while True: + * try: + * self._cleanup_old_logs() # <<<<<<<<<<<<<< + * time.sleep(self.cleanup_interval) + * except Exception as e: +*/ + if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 312, __pyx_L5_error) } + __pyx_t_5 = __pyx_cur_scope->__pyx_v_self; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_cleanup_old_logs, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 312, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":313 + * try: + * self._cleanup_old_logs() + * time.sleep(self.cleanup_interval) # <<<<<<<<<<<<<< + * except Exception as e: + * # +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 313, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_sleep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 313, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 313, __pyx_L5_error) } + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self, __pyx_mstate_global->__pyx_n_u_cleanup_interval); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 313, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":311 + * def cleanup_worker(): + * while True: + * try: # <<<<<<<<<<<<<< + * self._cleanup_old_logs() + * time.sleep(self.cleanup_interval) +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L12_try_end; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "loggerModule.py":314 + * self._cleanup_old_logs() + * time.sleep(self.cleanup_interval) + * except Exception as e: # <<<<<<<<<<<<<< + * # + * pass +*/ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_9) { + __Pyx_AddTraceback("loggerModule.Logger._start_cleanup_thread.cleanup_worker", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 314, __pyx_L7_except_error) + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __pyx_v_e = __pyx_t_8; + /*try:*/ { + } + /*finally:*/ { + /*normal exit:*/{ + __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0; + goto __pyx_L19; + } + __pyx_L19:; + } + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_exception_handled; + } + goto __pyx_L7_except_error; + + /* "loggerModule.py":311 + * def cleanup_worker(): + * while True: + * try: # <<<<<<<<<<<<<< + * self._cleanup_old_logs() + * time.sleep(self.cleanup_interval) +*/ + __pyx_L7_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L6_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L12_try_end:; + } + } + + /* "loggerModule.py":309 + * def _start_cleanup_thread(self): + * """ """ + * def cleanup_worker(): # <<<<<<<<<<<<<< + * while True: + * try: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("loggerModule.Logger._start_cleanup_thread.cleanup_worker", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":307 + * self.file_handler = file_handler + * + * def _start_cleanup_thread(self): # <<<<<<<<<<<<<< + * """ """ + * def cleanup_worker(): +*/ + +static PyObject *__pyx_pf_12loggerModule_6Logger_6_start_cleanup_thread(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *__pyx_cur_scope; + PyObject *__pyx_v_cleanup_worker = 0; + PyObject *__pyx_v_cleanup_thread = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_start_cleanup_thread", 0); + __pyx_cur_scope = (struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *)__pyx_tp_new_12loggerModule___pyx_scope_struct___start_cleanup_thread(__pyx_mstate_global->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 307, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_self); + + /* "loggerModule.py":309 + * def _start_cleanup_thread(self): + * """ """ + * def cleanup_worker(): # <<<<<<<<<<<<<< + * while True: + * try: +*/ + __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_21_start_cleanup_thread_1cleanup_worker, 0, __pyx_mstate_global->__pyx_n_u_Logger__start_cleanup_thread_loc, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_cleanup_worker = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":318 + * pass + * + * cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True) # <<<<<<<<<<<<<< + * cleanup_thread.start() + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Thread); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_2, NULL}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_target, __pyx_v_cleanup_worker, __pyx_t_3, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 318, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_daemon, Py_True, __pyx_t_3, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_cleanup_thread = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":319 + * + * cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True) + * cleanup_thread.start() # <<<<<<<<<<<<<< + * + * def _cleanup_old_logs(self): +*/ + __pyx_t_4 = __pyx_v_cleanup_thread; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_start, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":307 + * self.file_handler = file_handler + * + * def _start_cleanup_thread(self): # <<<<<<<<<<<<<< + * """ """ + * def cleanup_worker(): +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("loggerModule.Logger._start_cleanup_thread", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cleanup_worker); + __Pyx_XDECREF(__pyx_v_cleanup_thread); + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":321 + * cleanup_thread.start() + * + * def _cleanup_old_logs(self): # <<<<<<<<<<<<<< + * """ (> max_days) 10 """ + * cutoff_date = datetime.now() - timedelta(days=self.max_days) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_9_cleanup_old_logs(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_8_cleanup_old_logs, "\354\230\244\353\236\230\353\220\234 \353\241\234\352\267\270(> max_days) \353\260\217 \353\202\240\354\247\234\353\263\204 \354\265\234\353\214\200 10\352\260\234 \354\264\210\352\263\274\353\266\204 \354\240\225\353\246\254"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_9_cleanup_old_logs = {"_cleanup_old_logs", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_9_cleanup_old_logs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_8_cleanup_old_logs}; +static PyObject *__pyx_pw_12loggerModule_6Logger_9_cleanup_old_logs(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_cleanup_old_logs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 321, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 321, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_cleanup_old_logs", 0) < 0) __PYX_ERR(0, 321, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_cleanup_old_logs", 1, 1, 1, i); __PYX_ERR(0, 321, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 321, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_cleanup_old_logs", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 321, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger._cleanup_old_logs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_8_cleanup_old_logs(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":353 + * for day_key, items in by_day.items(): + * # + * items.sort(key=lambda x: x[1], reverse=True) # <<<<<<<<<<<<<< + * for (log_file, _mtime) in items[5:]: + * try: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_17_cleanup_old_logs_lambda1(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_17_cleanup_old_logs_lambda1 = {"lambda1", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_17_cleanup_old_logs_lambda1, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_12loggerModule_6Logger_17_cleanup_old_logs_lambda1(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_x = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda1 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 353, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 353, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda1", 0) < 0) __PYX_ERR(0, 353, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda1", 1, 1, 1, i); __PYX_ERR(0, 353, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 353, __pyx_L3_error) + } + __pyx_v_x = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda1", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 353, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger._cleanup_old_logs.lambda1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_lambda1(__pyx_self, __pyx_v_x); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_lambda1(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda1", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("loggerModule.Logger._cleanup_old_logs.lambda1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":321 + * cleanup_thread.start() + * + * def _cleanup_old_logs(self): # <<<<<<<<<<<<<< + * """ (> max_days) 10 """ + * cutoff_date = datetime.now() - timedelta(days=self.max_days) +*/ + +static PyObject *__pyx_pf_12loggerModule_6Logger_8_cleanup_old_logs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_v_cutoff_date = NULL; + PyObject *__pyx_v_log_pattern = NULL; + PyObject *__pyx_v_files = NULL; + PyObject *__pyx_v_log_file = NULL; + PyObject *__pyx_v_file_mtime = NULL; + PyObject *__pyx_v_mtime = NULL; + PyObject *__pyx_v_defaultdict = NULL; + PyObject *__pyx_v_by_day = NULL; + PyObject *__pyx_v_day_key = NULL; + PyObject *__pyx_v_items = NULL; + CYTHON_UNUSED PyObject *__pyx_v__mtime = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_t_15; + PyObject *(*__pyx_t_16)(PyObject *); + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + Py_ssize_t __pyx_t_19; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_cleanup_old_logs", 0); + + /* "loggerModule.py":323 + * def _cleanup_old_logs(self): + * """ (> max_days) 10 """ + * cutoff_date = datetime.now() - timedelta(days=self.max_days) # <<<<<<<<<<<<<< + * log_pattern = f"{self.log_base_name}*.log*" # .log, .log.1 + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_now); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_timedelta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_max_days); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, NULL}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_days, __pyx_t_6, __pyx_t_7, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_3, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_3 = PyNumber_Subtract(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_cutoff_date = __pyx_t_3; + __pyx_t_3 = 0; + + /* "loggerModule.py":324 + * """ (> max_days) 10 """ + * cutoff_date = datetime.now() - timedelta(days=self.max_days) + * log_pattern = f"{self.log_base_name}*.log*" # .log, .log.1 # <<<<<<<<<<<<<< + * + * files = [] +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_base_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_ConcatInPlace(__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_log_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_log_pattern = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "loggerModule.py":326 + * log_pattern = f"{self.log_base_name}*.log*" # .log, .log.1 + * + * files = [] # <<<<<<<<<<<<<< + * for log_file in self.log_dir.glob(log_pattern): + * try: +*/ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_files = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "loggerModule.py":327 + * + * files = [] + * for log_file in self.log_dir.glob(log_pattern): # <<<<<<<<<<<<<< + * try: + * if log_file.name == f"{self.log_base_name}.log": +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_dir); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_log_pattern}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_glob, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); + __pyx_t_8 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 327, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 327, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_8); + ++__pyx_t_8; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 327, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_8); + #endif + ++__pyx_t_8; + } + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 327, __pyx_L1_error) + } else { + __pyx_t_3 = __pyx_t_9(__pyx_t_1); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 327, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_log_file, __pyx_t_3); + __pyx_t_3 = 0; + + /* "loggerModule.py":328 + * files = [] + * for log_file in self.log_dir.glob(log_pattern): + * try: # <<<<<<<<<<<<<< + * if log_file.name == f"{self.log_base_name}.log": + * continue +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "loggerModule.py":329 + * for log_file in self.log_dir.glob(log_pattern): + * try: + * if log_file.name == f"{self.log_base_name}.log": # <<<<<<<<<<<<<< + * continue + * file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime) +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_log_file, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_base_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 329, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyUnicode_ConcatInPlace(__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_13 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_t_4, Py_EQ)); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 329, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":330 + * try: + * if log_file.name == f"{self.log_base_name}.log": + * continue # <<<<<<<<<<<<<< + * file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime) + * files.append((log_file, file_mtime)) +*/ + goto __pyx_L11_try_continue; + + /* "loggerModule.py":329 + * for log_file in self.log_dir.glob(log_pattern): + * try: + * if log_file.name == f"{self.log_base_name}.log": # <<<<<<<<<<<<<< + * continue + * file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime) +*/ + } + + /* "loggerModule.py":331 + * if log_file.name == f"{self.log_base_name}.log": + * continue + * file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime) # <<<<<<<<<<<<<< + * files.append((log_file, file_mtime)) + * except Exception: +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 331, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_fromtimestamp); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 331, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = __pyx_v_log_file; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_stat, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 331, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_st_mtime); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_file_mtime, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":332 + * continue + * file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime) + * files.append((log_file, file_mtime)) # <<<<<<<<<<<<<< + * except Exception: + * continue +*/ + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_log_file); + __Pyx_GIVEREF(__pyx_v_log_file); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_log_file) != (0)) __PYX_ERR(0, 332, __pyx_L5_error); + __Pyx_INCREF(__pyx_v_file_mtime); + __Pyx_GIVEREF(__pyx_v_file_mtime); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_file_mtime) != (0)) __PYX_ERR(0, 332, __pyx_L5_error); + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_files, __pyx_t_4); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 332, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":328 + * files = [] + * for log_file in self.log_dir.glob(log_pattern): + * try: # <<<<<<<<<<<<<< + * if log_file.name == f"{self.log_base_name}.log": + * continue +*/ + } + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L12_try_end; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":333 + * file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime) + * files.append((log_file, file_mtime)) + * except Exception: # <<<<<<<<<<<<<< + * continue + * +*/ + __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_15) { + __Pyx_AddTraceback("loggerModule.Logger._cleanup_old_logs", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_2) < 0) __PYX_ERR(0, 333, __pyx_L7_except_error) + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_2); + + /* "loggerModule.py":334 + * files.append((log_file, file_mtime)) + * except Exception: + * continue # <<<<<<<<<<<<<< + * + * # 1) +*/ + goto __pyx_L14_except_continue; + __pyx_L14_except_continue:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L11_try_continue; + } + goto __pyx_L7_except_error; + + /* "loggerModule.py":328 + * files = [] + * for log_file in self.log_dir.glob(log_pattern): + * try: # <<<<<<<<<<<<<< + * if log_file.name == f"{self.log_base_name}.log": + * continue +*/ + __pyx_L7_except_error:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L1_error; + __pyx_L11_try_continue:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L3_continue; + __pyx_L12_try_end:; + } + + /* "loggerModule.py":327 + * + * files = [] + * for log_file in self.log_dir.glob(log_pattern): # <<<<<<<<<<<<<< + * try: + * if log_file.name == f"{self.log_base_name}.log": +*/ + __pyx_L3_continue:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":337 + * + * # 1) + * for log_file, mtime in files: # <<<<<<<<<<<<<< + * if mtime < cutoff_date: + * try: +*/ + __pyx_t_1 = __pyx_v_files; __Pyx_INCREF(__pyx_t_1); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 337, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_8); + ++__pyx_t_8; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 337, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); + index = 0; __pyx_t_6 = __pyx_t_16(__pyx_t_3); if (unlikely(!__pyx_t_6)) goto __pyx_L19_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_4 = __pyx_t_16(__pyx_t_3); if (unlikely(!__pyx_t_4)) goto __pyx_L19_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_3), 2) < 0) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L20_unpacking_done; + __pyx_L19_unpacking_failed:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_L20_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_log_file, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_mtime, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":338 + * # 1) + * for log_file, mtime in files: + * if mtime < cutoff_date: # <<<<<<<<<<<<<< + * try: + * log_file.unlink() +*/ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_mtime, __pyx_v_cutoff_date, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":339 + * for log_file, mtime in files: + * if mtime < cutoff_date: + * try: # <<<<<<<<<<<<<< + * log_file.unlink() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_11, &__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + /*try:*/ { + + /* "loggerModule.py":340 + * if mtime < cutoff_date: + * try: + * log_file.unlink() # <<<<<<<<<<<<<< + * except Exception: + * pass +*/ + __pyx_t_4 = __pyx_v_log_file; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_unlink, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 340, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":339 + * for log_file, mtime in files: + * if mtime < cutoff_date: + * try: # <<<<<<<<<<<<<< + * log_file.unlink() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L29_try_end; + __pyx_L22_error:; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":341 + * try: + * log_file.unlink() + * except Exception: # <<<<<<<<<<<<<< + * pass + * +*/ + __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_15) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L23_exception_handled; + } + goto __pyx_L24_except_error; + + /* "loggerModule.py":339 + * for log_file, mtime in files: + * if mtime < cutoff_date: + * try: # <<<<<<<<<<<<<< + * log_file.unlink() + * except Exception: +*/ + __pyx_L24_except_error:; + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_11, __pyx_t_10); + goto __pyx_L1_error; + __pyx_L23_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_11, __pyx_t_10); + __pyx_L29_try_end:; + } + + /* "loggerModule.py":338 + * # 1) + * for log_file, mtime in files: + * if mtime < cutoff_date: # <<<<<<<<<<<<<< + * try: + * log_file.unlink() +*/ + } + + /* "loggerModule.py":337 + * + * # 1) + * for log_file, mtime in files: # <<<<<<<<<<<<<< + * if mtime < cutoff_date: + * try: +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":345 + * + * # 2) 5 ( ) + * from collections import defaultdict # <<<<<<<<<<<<<< + * by_day = defaultdict(list) + * for log_file, mtime in files: +*/ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_defaultdict); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_defaultdict); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_defaultdict) != (0)) __PYX_ERR(0, 345, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_defaultdict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_defaultdict = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":346 + * # 2) 5 ( ) + * from collections import defaultdict + * by_day = defaultdict(list) # <<<<<<<<<<<<<< + * for log_file, mtime in files: + * day_key = mtime.strftime('%Y-%m-%d') +*/ + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_v_defaultdict); + __pyx_t_4 = __pyx_v_defaultdict; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, ((PyObject *)(&PyList_Type))}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_by_day = __pyx_t_2; + __pyx_t_2 = 0; + + /* "loggerModule.py":347 + * from collections import defaultdict + * by_day = defaultdict(list) + * for log_file, mtime in files: # <<<<<<<<<<<<<< + * day_key = mtime.strftime('%Y-%m-%d') + * by_day[day_key].append((log_file, mtime)) +*/ + __pyx_t_2 = __pyx_v_files; __Pyx_INCREF(__pyx_t_2); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 347, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_8); + ++__pyx_t_8; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 347, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_6); + } else { + __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + } + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); + index = 0; __pyx_t_1 = __pyx_t_16(__pyx_t_3); if (unlikely(!__pyx_t_1)) goto __pyx_L35_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_6 = __pyx_t_16(__pyx_t_3); if (unlikely(!__pyx_t_6)) goto __pyx_L35_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_3), 2) < 0) __PYX_ERR(0, 347, __pyx_L1_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L36_unpacking_done; + __pyx_L35_unpacking_failed:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 347, __pyx_L1_error) + __pyx_L36_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_log_file, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_mtime, __pyx_t_6); + __pyx_t_6 = 0; + + /* "loggerModule.py":348 + * by_day = defaultdict(list) + * for log_file, mtime in files: + * day_key = mtime.strftime('%Y-%m-%d') # <<<<<<<<<<<<<< + * by_day[day_key].append((log_file, mtime)) + * +*/ + __pyx_t_6 = __pyx_v_mtime; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Y_m_d}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_strftime, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_day_key, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":349 + * for log_file, mtime in files: + * day_key = mtime.strftime('%Y-%m-%d') + * by_day[day_key].append((log_file, mtime)) # <<<<<<<<<<<<<< + * + * for day_key, items in by_day.items(): +*/ + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_by_day, __pyx_v_day_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_v_log_file); + __Pyx_GIVEREF(__pyx_v_log_file); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_log_file) != (0)) __PYX_ERR(0, 349, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mtime); + __Pyx_GIVEREF(__pyx_v_mtime); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_mtime) != (0)) __PYX_ERR(0, 349, __pyx_L1_error); + __pyx_t_14 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_6); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":347 + * from collections import defaultdict + * by_day = defaultdict(list) + * for log_file, mtime in files: # <<<<<<<<<<<<<< + * day_key = mtime.strftime('%Y-%m-%d') + * by_day[day_key].append((log_file, mtime)) +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":351 + * by_day[day_key].append((log_file, mtime)) + * + * for day_key, items in by_day.items(): # <<<<<<<<<<<<<< + * # + * items.sort(key=lambda x: x[1], reverse=True) +*/ + __pyx_t_8 = 0; + if (unlikely(__pyx_v_by_day == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 351, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_by_day, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_17), (&__pyx_t_15)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + while (1) { + __pyx_t_18 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_17, &__pyx_t_8, &__pyx_t_6, &__pyx_t_4, NULL, __pyx_t_15); + if (unlikely(__pyx_t_18 == 0)) break; + if (unlikely(__pyx_t_18 == -1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_day_key, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_items, __pyx_t_4); + __pyx_t_4 = 0; + + /* "loggerModule.py":353 + * for day_key, items in by_day.items(): + * # + * items.sort(key=lambda x: x[1], reverse=True) # <<<<<<<<<<<<<< + * for (log_file, _mtime) in items[5:]: + * try: +*/ + __pyx_t_6 = __pyx_v_items; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_17_cleanup_old_logs_lambda1, 0, __pyx_mstate_global->__pyx_n_u_Logger__cleanup_old_logs_locals, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_6, NULL}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_key, __pyx_t_1, __pyx_t_3, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 353, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_reverse, Py_True, __pyx_t_3, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 353, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_sort, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":354 + * # + * items.sort(key=lambda x: x[1], reverse=True) + * for (log_file, _mtime) in items[5:]: # <<<<<<<<<<<<<< + * try: + * if log_file.exists(): +*/ + __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_items, 5, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[2], 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); + __pyx_t_19 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_19 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 354, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 354, __pyx_L1_error) + #endif + if (__pyx_t_19 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_19); + ++__pyx_t_19; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 354, __pyx_L1_error) + #endif + if (__pyx_t_19 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_19)); + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_19); + #endif + ++__pyx_t_19; + } + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 354, __pyx_L1_error) + } else { + __pyx_t_4 = __pyx_t_9(__pyx_t_3); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 354, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 354, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_6); + } else { + __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 0); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + } + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); + index = 0; __pyx_t_1 = __pyx_t_16(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L42_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_6 = __pyx_t_16(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L42_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_7), 2) < 0) __PYX_ERR(0, 354, __pyx_L1_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L43_unpacking_done; + __pyx_L42_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 354, __pyx_L1_error) + __pyx_L43_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_log_file, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v__mtime, __pyx_t_6); + __pyx_t_6 = 0; + + /* "loggerModule.py":355 + * items.sort(key=lambda x: x[1], reverse=True) + * for (log_file, _mtime) in items[5:]: + * try: # <<<<<<<<<<<<<< + * if log_file.exists(): + * log_file.unlink() +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "loggerModule.py":356 + * for (log_file, _mtime) in items[5:]: + * try: + * if log_file.exists(): # <<<<<<<<<<<<<< + * log_file.unlink() + * except Exception: +*/ + __pyx_t_6 = __pyx_v_log_file; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_exists, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 356, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 356, __pyx_L44_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_13) { + + /* "loggerModule.py":357 + * try: + * if log_file.exists(): + * log_file.unlink() # <<<<<<<<<<<<<< + * except Exception: + * pass +*/ + __pyx_t_6 = __pyx_v_log_file; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_unlink, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 357, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":356 + * for (log_file, _mtime) in items[5:]: + * try: + * if log_file.exists(): # <<<<<<<<<<<<<< + * log_file.unlink() + * except Exception: +*/ + } + + /* "loggerModule.py":355 + * items.sort(key=lambda x: x[1], reverse=True) + * for (log_file, _mtime) in items[5:]: + * try: # <<<<<<<<<<<<<< + * if log_file.exists(): + * log_file.unlink() +*/ + } + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L51_try_end; + __pyx_L44_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":358 + * if log_file.exists(): + * log_file.unlink() + * except Exception: # <<<<<<<<<<<<<< + * pass + * +*/ + __pyx_t_18 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_18) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L45_exception_handled; + } + goto __pyx_L46_except_error; + + /* "loggerModule.py":355 + * items.sort(key=lambda x: x[1], reverse=True) + * for (log_file, _mtime) in items[5:]: + * try: # <<<<<<<<<<<<<< + * if log_file.exists(): + * log_file.unlink() +*/ + __pyx_L46_except_error:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L1_error; + __pyx_L45_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + __pyx_L51_try_end:; + } + + /* "loggerModule.py":354 + * # + * items.sort(key=lambda x: x[1], reverse=True) + * for (log_file, _mtime) in items[5:]: # <<<<<<<<<<<<<< + * try: + * if log_file.exists(): +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":321 + * cleanup_thread.start() + * + * def _cleanup_old_logs(self): # <<<<<<<<<<<<<< + * """ (> max_days) 10 """ + * cutoff_date = datetime.now() - timedelta(days=self.max_days) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger._cleanup_old_logs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cutoff_date); + __Pyx_XDECREF(__pyx_v_log_pattern); + __Pyx_XDECREF(__pyx_v_files); + __Pyx_XDECREF(__pyx_v_log_file); + __Pyx_XDECREF(__pyx_v_file_mtime); + __Pyx_XDECREF(__pyx_v_mtime); + __Pyx_XDECREF(__pyx_v_defaultdict); + __Pyx_XDECREF(__pyx_v_by_day); + __Pyx_XDECREF(__pyx_v_day_key); + __Pyx_XDECREF(__pyx_v_items); + __Pyx_XDECREF(__pyx_v__mtime); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":361 + * pass + * + * def log(self, message, level=logging.INFO, exc_info=False): # <<<<<<<<<<<<<< + * """ """ + * if exc_info: +*/ + +static PyObject *__pyx_pf_12loggerModule_20__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 361, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 361, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 361, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 361, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("loggerModule.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_11log(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_10log, "\353\241\234\352\267\270 \353\251\224\354\213\234\354\247\200 \352\270\260\353\241\235"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_11log = {"log", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_11log, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_10log}; +static PyObject *__pyx_pw_12loggerModule_6Logger_11log(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_level = 0; + PyObject *__pyx_v_exc_info = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("log (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,&__pyx_mstate_global->__pyx_n_u_level,&__pyx_mstate_global->__pyx_n_u_exc_info,0}; + struct __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 361, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 361, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 361, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 361, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 361, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "log", 0) < 0) __PYX_ERR(0, 361, __pyx_L3_error) + if (!values[2]) values[2] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("log", 0, 2, 4, i); __PYX_ERR(0, 361, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 361, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 361, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 361, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 361, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[2]) values[2] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + __pyx_v_level = values[2]; + __pyx_v_exc_info = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("log", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 361, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.log", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_10log(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_level, __pyx_v_exc_info); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_10log(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_level, PyObject *__pyx_v_exc_info) { + PyObject *__pyx_v_caller_frame = NULL; + PyObject *__pyx_v_record = NULL; + PyObject *__pyx_v_gui_formatter = NULL; + PyObject *__pyx_v_formatted_message = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5[3]; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("log", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":363 + * def log(self, message, level=logging.INFO, exc_info=False): + * """ """ + * if exc_info: # <<<<<<<<<<<<<< + * message = f"{message}\n{traceback.format_exc()}" + * +*/ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_exc_info); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 363, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":364 + * """ """ + * if exc_info: + * message = f"{message}\n{traceback.format_exc()}" # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_message, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_traceback); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_format_exc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5[0] = __pyx_t_2; + __pyx_t_5[1] = __pyx_mstate_global->__pyx_kp_u__3; + __pyx_t_5[2] = __pyx_t_4; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 1 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4)); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_3); + __pyx_t_3 = 0; + + /* "loggerModule.py":363 + * def log(self, message, level=logging.INFO, exc_info=False): + * """ """ + * if exc_info: # <<<<<<<<<<<<<< + * message = f"{message}\n{traceback.format_exc()}" + * +*/ + } + + /* "loggerModule.py":367 + * + * # + * caller_frame = logging.currentframe().f_back # <<<<<<<<<<<<<< + * record = self.logger.makeRecord( + * self.logger.name, level, caller_frame.f_code.co_filename, +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_currentframe); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_f_back); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_caller_frame = __pyx_t_6; + __pyx_t_6 = 0; + + /* "loggerModule.py":368 + * # + * caller_frame = logging.currentframe().f_back + * record = self.logger.makeRecord( # <<<<<<<<<<<<<< + * self.logger.name, level, caller_frame.f_code.co_filename, + * caller_frame.f_lineno, message, None, None, caller_frame.f_code.co_name +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_3); + + /* "loggerModule.py":369 + * caller_frame = logging.currentframe().f_back + * record = self.logger.makeRecord( + * self.logger.name, level, caller_frame.f_code.co_filename, # <<<<<<<<<<<<<< + * caller_frame.f_lineno, message, None, None, caller_frame.f_code.co_name + * ) +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_caller_frame, __pyx_mstate_global->__pyx_n_u_f_code); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_co_filename); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":370 + * record = self.logger.makeRecord( + * self.logger.name, level, caller_frame.f_code.co_filename, + * caller_frame.f_lineno, message, None, None, caller_frame.f_code.co_name # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_caller_frame, __pyx_mstate_global->__pyx_n_u_f_lineno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_caller_frame, __pyx_mstate_global->__pyx_n_u_f_code); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_co_name); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[9] = {__pyx_t_3, __pyx_t_8, __pyx_v_level, __pyx_t_9, __pyx_t_2, __pyx_v_message, Py_None, Py_None, __pyx_t_11}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_makeRecord, __pyx_callargs+__pyx_t_7, (9-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_record = __pyx_t_6; + __pyx_t_6 = 0; + + /* "loggerModule.py":374 + * + * # / + * if level >= self.file_log_level: # <<<<<<<<<<<<<< + * self.logger.handle(record) + * +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_file_log_level); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_level, __pyx_t_6, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "loggerModule.py":375 + * # / + * if level >= self.file_log_level: + * self.logger.handle(record) # <<<<<<<<<<<<<< + * + * # ( ) +*/ + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_6 = __pyx_t_11; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_record}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_handle, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":374 + * + * # / + * if level >= self.file_log_level: # <<<<<<<<<<<<<< + * self.logger.handle(record) + * +*/ + } + + /* "loggerModule.py":378 + * + * # ( ) + * if self.gui_logger and level >= self.gui_log_level: # <<<<<<<<<<<<<< + * gui_formatter = logging.Formatter( + * fmt="[%(asctime)s] %(message)s", +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_logger); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_12) { + } else { + __pyx_t_1 = __pyx_t_12; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_log_level); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyObject_RichCompare(__pyx_v_level, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_1 = __pyx_t_12; + __pyx_L6_bool_binop_done:; + if (__pyx_t_1) { + + /* "loggerModule.py":379 + * # ( ) + * if self.gui_logger and level >= self.gui_log_level: + * gui_formatter = logging.Formatter( # <<<<<<<<<<<<<< + * fmt="[%(asctime)s] %(message)s", + * datefmt="%H:%M:%S" +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Formatter); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_4, NULL}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_fmt, __pyx_mstate_global->__pyx_kp_u_asctime_s_message_s, __pyx_t_6, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 379, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_datefmt, __pyx_mstate_global->__pyx_kp_u_H_M_S, __pyx_t_6, __pyx_callargs+1, 1) < 0) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_t_11 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_2, __pyx_callargs+__pyx_t_7, (1-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + } + __pyx_v_gui_formatter = __pyx_t_11; + __pyx_t_11 = 0; + + /* "loggerModule.py":383 + * datefmt="%H:%M:%S" + * ) + * formatted_message = gui_formatter.format(record) # <<<<<<<<<<<<<< + * try: + * self.gui_logger(formatted_message) +*/ + __pyx_t_2 = __pyx_v_gui_formatter; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_record}; + __pyx_t_11 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_format, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + } + __pyx_v_formatted_message = __pyx_t_11; + __pyx_t_11 = 0; + + /* "loggerModule.py":384 + * ) + * formatted_message = gui_formatter.format(record) + * try: # <<<<<<<<<<<<<< + * self.gui_logger(formatted_message) + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + /*try:*/ { + + /* "loggerModule.py":385 + * formatted_message = gui_formatter.format(record) + * try: + * self.gui_logger(formatted_message) # <<<<<<<<<<<<<< + * except Exception: + * # +*/ + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_formatted_message}; + __pyx_t_11 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_gui_logger, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 385, __pyx_L8_error) + __Pyx_GOTREF(__pyx_t_11); + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "loggerModule.py":384 + * ) + * formatted_message = gui_formatter.format(record) + * try: # <<<<<<<<<<<<<< + * self.gui_logger(formatted_message) + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L13_try_end; + __pyx_L8_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "loggerModule.py":386 + * try: + * self.gui_logger(formatted_message) + * except Exception: # <<<<<<<<<<<<<< + * # + * pass +*/ + __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_16) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L9_exception_handled; + } + goto __pyx_L10_except_error; + + /* "loggerModule.py":384 + * ) + * formatted_message = gui_formatter.format(record) + * try: # <<<<<<<<<<<<<< + * self.gui_logger(formatted_message) + * except Exception: +*/ + __pyx_L10_except_error:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + goto __pyx_L1_error; + __pyx_L9_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + __pyx_L13_try_end:; + } + + /* "loggerModule.py":378 + * + * # ( ) + * if self.gui_logger and level >= self.gui_log_level: # <<<<<<<<<<<<<< + * gui_formatter = logging.Formatter( + * fmt="[%(asctime)s] %(message)s", +*/ + } + + /* "loggerModule.py":361 + * pass + * + * def log(self, message, level=logging.INFO, exc_info=False): # <<<<<<<<<<<<<< + * """ """ + * if exc_info: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("loggerModule.Logger.log", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_caller_frame); + __Pyx_XDECREF(__pyx_v_record); + __Pyx_XDECREF(__pyx_v_gui_formatter); + __Pyx_XDECREF(__pyx_v_formatted_message); + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":390 + * pass + * + * def set_gui_logger(self, gui_logger, gui_log_level=None): # <<<<<<<<<<<<<< + * """ + * . +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_13set_gui_logger(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_12set_gui_logger, "\n \353\241\234\352\267\270 \354\275\234\353\260\261 \355\225\250\354\210\230\353\245\274 \354\204\244\354\240\225\355\225\251\353\213\210\353\213\244.\n \354\204\240\355\203\235\354\240\201\354\234\274\353\241\234 \354\275\234\353\260\261 \353\241\234\352\267\270 \353\240\210\353\262\250\353\217\204 \353\263\200\352\262\275\355\225\240 \354\210\230 \354\236\210\354\212\265\353\213\210\353\213\244.\n "); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_13set_gui_logger = {"set_gui_logger", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_13set_gui_logger, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_12set_gui_logger}; +static PyObject *__pyx_pw_12loggerModule_6Logger_13set_gui_logger(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_gui_logger = 0; + PyObject *__pyx_v_gui_log_level = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_gui_logger (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_gui_logger,&__pyx_mstate_global->__pyx_n_u_gui_log_level,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 390, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 390, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 390, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 390, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_gui_logger", 0) < 0) __PYX_ERR(0, 390, __pyx_L3_error) + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_None)); + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_gui_logger", 0, 2, 3, i); __PYX_ERR(0, 390, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 390, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 390, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 390, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[2]) values[2] = __Pyx_NewRef(((PyObject *)Py_None)); + } + __pyx_v_self = values[0]; + __pyx_v_gui_logger = values[1]; + __pyx_v_gui_log_level = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_gui_logger", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 390, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.set_gui_logger", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_12set_gui_logger(__pyx_self, __pyx_v_self, __pyx_v_gui_logger, __pyx_v_gui_log_level); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_12set_gui_logger(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_gui_logger, PyObject *__pyx_v_gui_log_level) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_gui_logger", 0); + + /* "loggerModule.py":395 + * . + * """ + * self.gui_logger = gui_logger # <<<<<<<<<<<<<< + * + * if gui_log_level is not None: +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_logger, __pyx_v_gui_logger) < 0) __PYX_ERR(0, 395, __pyx_L1_error) + + /* "loggerModule.py":397 + * self.gui_logger = gui_logger + * + * if gui_log_level is not None: # <<<<<<<<<<<<<< + * self.gui_log_level = gui_log_level + * +*/ + __pyx_t_1 = (__pyx_v_gui_log_level != Py_None); + if (__pyx_t_1) { + + /* "loggerModule.py":398 + * + * if gui_log_level is not None: + * self.gui_log_level = gui_log_level # <<<<<<<<<<<<<< + * + * def set_gui_log_level(self, level): +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_log_level, __pyx_v_gui_log_level) < 0) __PYX_ERR(0, 398, __pyx_L1_error) + + /* "loggerModule.py":397 + * self.gui_logger = gui_logger + * + * if gui_log_level is not None: # <<<<<<<<<<<<<< + * self.gui_log_level = gui_log_level + * +*/ + } + + /* "loggerModule.py":390 + * pass + * + * def set_gui_logger(self, gui_logger, gui_log_level=None): # <<<<<<<<<<<<<< + * """ + * . +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("loggerModule.Logger.set_gui_logger", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":400 + * self.gui_log_level = gui_log_level + * + * def set_gui_log_level(self, level): # <<<<<<<<<<<<<< + * """ """ + * self.gui_log_level = level +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_15set_gui_log_level(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_14set_gui_log_level, "\354\275\234\353\260\261 \353\241\234\352\267\270 \353\240\210\353\262\250\354\235\204 \353\217\231\354\240\201\354\234\274\353\241\234 \353\263\200\352\262\275\355\225\251\353\213\210\353\213\244"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_15set_gui_log_level = {"set_gui_log_level", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_15set_gui_log_level, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_14set_gui_log_level}; +static PyObject *__pyx_pw_12loggerModule_6Logger_15set_gui_log_level(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_level = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_gui_log_level (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_level,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 400, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 400, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 400, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_gui_log_level", 0) < 0) __PYX_ERR(0, 400, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_gui_log_level", 1, 2, 2, i); __PYX_ERR(0, 400, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 400, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 400, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_level = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_gui_log_level", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 400, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.set_gui_log_level", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_14set_gui_log_level(__pyx_self, __pyx_v_self, __pyx_v_level); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_14set_gui_log_level(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_level) { + PyObject *__pyx_v_level_name = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6[3]; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_gui_log_level", 0); + + /* "loggerModule.py":402 + * def set_gui_log_level(self, level): + * """ """ + * self.gui_log_level = level # <<<<<<<<<<<<<< + * level_name = get_level_name(level) + * self.logger.info(f" {level_name} ") +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_log_level, __pyx_v_level) < 0) __PYX_ERR(0, 402, __pyx_L1_error) + + /* "loggerModule.py":403 + * """ """ + * self.gui_log_level = level + * level_name = get_level_name(level) # <<<<<<<<<<<<<< + * self.logger.info(f" {level_name} ") + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_level_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_level}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_level_name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":404 + * self.gui_log_level = level + * level_name = get_level_name(level) + * self.logger.info(f" {level_name} ") # <<<<<<<<<<<<<< + * + * def set_file_log_level(self, level): +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_level_name, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_6[1] = __pyx_t_5; + __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u__6; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 9, 65535 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5)); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_info, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":400 + * self.gui_log_level = gui_log_level + * + * def set_gui_log_level(self, level): # <<<<<<<<<<<<<< + * """ """ + * self.gui_log_level = level +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.set_gui_log_level", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_level_name); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":406 + * self.logger.info(f" {level_name} ") + * + * def set_file_log_level(self, level): # <<<<<<<<<<<<<< + * """ """ + * self.file_log_level = level +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_17set_file_log_level(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_16set_file_log_level, "\355\214\214\354\235\274 \353\241\234\352\267\270 \353\240\210\353\262\250\354\235\204 \353\217\231\354\240\201\354\234\274\353\241\234 \353\263\200\352\262\275\355\225\251\353\213\210\353\213\244"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_17set_file_log_level = {"set_file_log_level", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_17set_file_log_level, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_16set_file_log_level}; +static PyObject *__pyx_pw_12loggerModule_6Logger_17set_file_log_level(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_level = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_file_log_level (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_level,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 406, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 406, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 406, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_file_log_level", 0) < 0) __PYX_ERR(0, 406, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_file_log_level", 1, 2, 2, i); __PYX_ERR(0, 406, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 406, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 406, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_level = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_file_log_level", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 406, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.set_file_log_level", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_16set_file_log_level(__pyx_self, __pyx_v_self, __pyx_v_level); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_16set_file_log_level(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_level) { + PyObject *__pyx_v_handler = NULL; + PyObject *__pyx_v_level_name = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10[3]; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_file_log_level", 0); + + /* "loggerModule.py":408 + * def set_file_log_level(self, level): + * """ """ + * self.file_log_level = level # <<<<<<<<<<<<<< + * self.logger.setLevel(level) + * for handler in self.logger.handlers: +*/ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_file_log_level, __pyx_v_level) < 0) __PYX_ERR(0, 408, __pyx_L1_error) + + /* "loggerModule.py":409 + * """ """ + * self.file_log_level = level + * self.logger.setLevel(level) # <<<<<<<<<<<<<< + * for handler in self.logger.handlers: + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_level}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setLevel, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":410 + * self.file_log_level = level + * self.logger.setLevel(level) + * for handler in self.logger.handlers: # <<<<<<<<<<<<<< + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): + * handler.setLevel(level) +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_handlers); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 410, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 410, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_5); + ++__pyx_t_5; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 410, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); + #endif + ++__pyx_t_5; + } + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error) + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 410, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_handler, __pyx_t_3); + __pyx_t_3 = 0; + + /* "loggerModule.py":411 + * self.logger.setLevel(level) + * for handler in self.logger.handlers: + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): # <<<<<<<<<<<<<< + * handler.setLevel(level) + * level_name = get_level_name(level) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_FileHandler); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_TimedRotatingFileHandler); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyObject_IsInstance(__pyx_v_handler, __pyx_t_2); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = PyObject_IsInstance(__pyx_v_handler, __pyx_t_3); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_7) { + + /* "loggerModule.py":412 + * for handler in self.logger.handlers: + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): + * handler.setLevel(level) # <<<<<<<<<<<<<< + * level_name = get_level_name(level) + * self.logger.info(f" {level_name} ") +*/ + __pyx_t_3 = __pyx_v_handler; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_level}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_setLevel, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":411 + * self.logger.setLevel(level) + * for handler in self.logger.handlers: + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): # <<<<<<<<<<<<<< + * handler.setLevel(level) + * level_name = get_level_name(level) +*/ + } + + /* "loggerModule.py":410 + * self.file_log_level = level + * self.logger.setLevel(level) + * for handler in self.logger.handlers: # <<<<<<<<<<<<<< + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): + * handler.setLevel(level) +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":413 + * if isinstance(handler, (logging.FileHandler, TimedRotatingFileHandler)): + * handler.setLevel(level) + * level_name = get_level_name(level) # <<<<<<<<<<<<<< + * self.logger.info(f" {level_name} ") + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_level_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_level}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_level_name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":414 + * handler.setLevel(level) + * level_name = get_level_name(level) + * self.logger.info(f" {level_name} ") # <<<<<<<<<<<<<< + * + * def get_log_levels(self): +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_level_name, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u__7; + __pyx_t_10[1] = __pyx_t_9; + __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__6; + __pyx_t_11 = __Pyx_PyUnicode_Join(__pyx_t_10, 3, 10 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 9, 65535 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9)); + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_11}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_info, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":406 + * self.logger.info(f" {level_name} ") + * + * def set_file_log_level(self, level): # <<<<<<<<<<<<<< + * """ """ + * self.file_log_level = level +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("loggerModule.Logger.set_file_log_level", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_handler); + __Pyx_XDECREF(__pyx_v_level_name); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":416 + * self.logger.info(f" {level_name} ") + * + * def get_log_levels(self): # <<<<<<<<<<<<<< + * """ """ + * return { +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_19get_log_levels(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_18get_log_levels, "\355\230\204\354\236\254 \353\241\234\352\267\270 \353\240\210\353\262\250 \354\240\225\353\263\264 \353\260\230\355\231\230"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_19get_log_levels = {"get_log_levels", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_19get_log_levels, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_18get_log_levels}; +static PyObject *__pyx_pw_12loggerModule_6Logger_19get_log_levels(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_log_levels (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 416, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 416, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_log_levels", 0) < 0) __PYX_ERR(0, 416, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_log_levels", 1, 1, 1, i); __PYX_ERR(0, 416, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 416, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_log_levels", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 416, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.get_log_levels", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_18get_log_levels(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_18get_log_levels(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_log_levels", 0); + + /* "loggerModule.py":418 + * def get_log_levels(self): + * """ """ + * return { # <<<<<<<<<<<<<< + * "file_level": get_level_name(self.file_log_level), + * "gui_level": get_level_name(self.gui_log_level), +*/ + __Pyx_XDECREF(__pyx_r); + + /* "loggerModule.py":419 + * """ """ + * return { + * "file_level": get_level_name(self.file_log_level), # <<<<<<<<<<<<<< + * "gui_level": get_level_name(self.gui_log_level), + * "logger_level": get_level_name(self.logger.level) +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_level_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_file_log_level); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_file_level, __pyx_t_2) < 0) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":420 + * return { + * "file_level": get_level_name(self.file_log_level), + * "gui_level": get_level_name(self.gui_log_level), # <<<<<<<<<<<<<< + * "logger_level": get_level_name(self.logger.level) + * } +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_get_level_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_gui_log_level); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_gui_level, __pyx_t_2) < 0) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":421 + * "file_level": get_level_name(self.file_log_level), + * "gui_level": get_level_name(self.gui_log_level), + * "logger_level": get_level_name(self.logger.level) # <<<<<<<<<<<<<< + * } + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_level_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_logger); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_level); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_logger_level, __pyx_t_2) < 0) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "loggerModule.py":416 + * self.logger.info(f" {level_name} ") + * + * def get_log_levels(self): # <<<<<<<<<<<<<< + * """ """ + * return { +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.get_log_levels", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":424 + * } + * + * def get_log_info(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_21get_log_info(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_20get_log_info, "\353\241\234\352\267\270 \355\214\214\354\235\274 \354\240\225\353\263\264 \353\260\230\355\231\230"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_21get_log_info = {"get_log_info", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_21get_log_info, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_20get_log_info}; +static PyObject *__pyx_pw_12loggerModule_6Logger_21get_log_info(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_log_info (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 424, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 424, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_log_info", 0) < 0) __PYX_ERR(0, 424, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_log_info", 1, 1, 1, i); __PYX_ERR(0, 424, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 424, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_log_info", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 424, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.get_log_info", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_20get_log_info(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_12loggerModule_6Logger_12get_log_info_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "loggerModule.py":428 + * try: + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) + * total_size = sum(f.stat().st_size for f in log_files) # <<<<<<<<<<<<<< + * + * return { +*/ + +static PyObject *__pyx_pf_12loggerModule_6Logger_12get_log_info_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *)__pyx_tp_new_12loggerModule___pyx_scope_struct_1_genexpr(__pyx_mstate_global->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 428, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_12loggerModule_6Logger_12get_log_info_2generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_Logger_get_log_info_locals_genex, __pyx_mstate_global->__pyx_n_u_loggerModule); if (unlikely(!gen)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("loggerModule.Logger.get_log_info.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_12loggerModule_6Logger_12get_log_info_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 428, __pyx_L1_error) + } + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 428, __pyx_L1_error) } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 428, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_2); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_f); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_f, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_4 = __pyx_cur_scope->__pyx_v_f; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_stat, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_st_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 428, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":424 + * } + * + * def get_log_info(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + +static PyObject *__pyx_pf_12loggerModule_6Logger_20get_log_info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_v_log_files = NULL; + PyObject *__pyx_v_total_size = NULL; + PyObject *__pyx_gb_12loggerModule_6Logger_12get_log_info_2generator = 0; + PyObject *__pyx_8genexpr1__pyx_v_f = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_log_info", 0); + + /* "loggerModule.py":426 + * def get_log_info(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) + * total_size = sum(f.stat().st_size for f in log_files) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "loggerModule.py":427 + * """ """ + * try: + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) # <<<<<<<<<<<<<< + * total_size = sum(f.stat().st_size for f in log_files) + * +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_dir); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 427, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_base_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 427, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 427, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_ConcatInPlace(__pyx_t_8, __pyx_mstate_global->__pyx_kp_u_log_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 427, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_glob, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 427, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_6 = __Pyx_PySequence_ListKeepNew(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 427, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_log_files = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + + /* "loggerModule.py":428 + * try: + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) + * total_size = sum(f.stat().st_size for f in log_files) # <<<<<<<<<<<<<< + * + * return { +*/ + __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_builtin_sum); + __pyx_t_7 = __pyx_builtin_sum; + __pyx_t_5 = __pyx_pf_12loggerModule_6Logger_12get_log_info_genexpr(NULL, __pyx_v_log_files); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 428, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 428, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_total_size = __pyx_t_6; + __pyx_t_6 = 0; + + /* "loggerModule.py":430 + * total_size = sum(f.stat().st_size for f in log_files) + * + * return { # <<<<<<<<<<<<<< + * "log_dir": str(self.log_dir), + * "total_files": len(log_files), +*/ + __Pyx_XDECREF(__pyx_r); + + /* "loggerModule.py":431 + * + * return { + * "log_dir": str(self.log_dir), # <<<<<<<<<<<<<< + * "total_files": len(log_files), + * "total_size_mb": total_size / (1024 * 1024), +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_dir); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_Unicode(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_log_dir, __pyx_t_5) < 0) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":432 + * return { + * "log_dir": str(self.log_dir), + * "total_files": len(log_files), # <<<<<<<<<<<<<< + * "total_size_mb": total_size / (1024 * 1024), + * "max_days": self.max_days, +*/ + __pyx_t_10 = __Pyx_PyList_GET_SIZE(__pyx_v_log_files); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 432, __pyx_L3_error) + __pyx_t_5 = PyLong_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 432, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_total_files, __pyx_t_5) < 0) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":433 + * "log_dir": str(self.log_dir), + * "total_files": len(log_files), + * "total_size_mb": total_size / (1024 * 1024), # <<<<<<<<<<<<<< + * "max_days": self.max_days, + * "files": [f.name for f in log_files] +*/ + __pyx_t_5 = __Pyx_PyLong_TrueDivideObjC(__pyx_v_total_size, __pyx_mstate_global->__pyx_int_1048576, 0x100000, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 433, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_total_size_mb, __pyx_t_5) < 0) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":434 + * "total_files": len(log_files), + * "total_size_mb": total_size / (1024 * 1024), + * "max_days": self.max_days, # <<<<<<<<<<<<<< + * "files": [f.name for f in log_files] + * } +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_max_days); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 434, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_max_days, __pyx_t_5) < 0) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + { /* enter inner scope */ + + /* "loggerModule.py":435 + * "total_size_mb": total_size / (1024 * 1024), + * "max_days": self.max_days, + * "files": [f.name for f in log_files] # <<<<<<<<<<<<<< + * } + * except Exception: +*/ + __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 435, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __pyx_v_log_files; __Pyx_INCREF(__pyx_t_7); + __pyx_t_10 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 435, __pyx_L11_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_10); + ++__pyx_t_10; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 435, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_f, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_8genexpr1__pyx_v_f, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 435, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 435, __pyx_L11_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_f); __pyx_8genexpr1__pyx_v_f = 0; + goto __pyx_L15_exit_scope; + __pyx_L11_error:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_f); __pyx_8genexpr1__pyx_v_f = 0; + goto __pyx_L3_error; + __pyx_L15_exit_scope:; + } /* exit inner scope */ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_files, __pyx_t_5) < 0) __PYX_ERR(0, 431, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L7_try_return; + + /* "loggerModule.py":426 + * def get_log_info(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) + * total_size = sum(f.stat().st_size for f in log_files) +*/ + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "loggerModule.py":437 + * "files": [f.name for f in log_files] + * } + * except Exception: # <<<<<<<<<<<<<< + * return {"error": " "} + * +*/ + __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_11) { + __Pyx_AddTraceback("loggerModule.Logger.get_log_info", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 437, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_7); + + /* "loggerModule.py":438 + * } + * except Exception: + * return {"error": " "} # <<<<<<<<<<<<<< + * + * def force_cleanup(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 438, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_error, __pyx_mstate_global->__pyx_kp_u__8) < 0) __PYX_ERR(0, 438, __pyx_L5_except_error) + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + + /* "loggerModule.py":426 + * def get_log_info(self): + * """ """ + * try: # <<<<<<<<<<<<<< + * log_files = list(self.log_dir.glob(f"{self.log_base_name}*.log")) + * total_size = sum(f.stat().st_size for f in log_files) +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L7_try_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + } + + /* "loggerModule.py":424 + * } + * + * def get_log_info(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("loggerModule.Logger.get_log_info", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_log_files); + __Pyx_XDECREF(__pyx_v_total_size); + __Pyx_XDECREF(__pyx_gb_12loggerModule_6Logger_12get_log_info_2generator); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_f); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":440 + * return {"error": " "} + * + * def force_cleanup(self): # <<<<<<<<<<<<<< + * """ """ + * self._cleanup_old_logs() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_23force_cleanup(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_22force_cleanup, "\354\210\230\353\217\231 \354\240\225\353\246\254 \354\213\244\355\226\211"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_23force_cleanup = {"force_cleanup", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_23force_cleanup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_22force_cleanup}; +static PyObject *__pyx_pw_12loggerModule_6Logger_23force_cleanup(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("force_cleanup (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 440, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 440, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "force_cleanup", 0) < 0) __PYX_ERR(0, 440, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("force_cleanup", 1, 1, 1, i); __PYX_ERR(0, 440, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 440, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("force_cleanup", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 440, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.Logger.force_cleanup", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_22force_cleanup(__pyx_self, __pyx_v_self); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_22force_cleanup(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("force_cleanup", 0); + + /* "loggerModule.py":442 + * def force_cleanup(self): + * """ """ + * self._cleanup_old_logs() # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_2 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_cleanup_old_logs, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":440 + * return {"error": " "} + * + * def force_cleanup(self): # <<<<<<<<<<<<<< + * """ """ + * self._cleanup_old_logs() +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("loggerModule.Logger.force_cleanup", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":445 + * + * # + * def debug(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """DEBUG """ + * if args: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_25debug(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_24debug, "DEBUG \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_25debug = {"debug", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_25debug, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_24debug}; +static PyObject *__pyx_pw_12loggerModule_6Logger_25debug(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("debug (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 2, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 445, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 445, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 445, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 2) ? kwd_pos_args : 2; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "debug", 1) < 0) __PYX_ERR(0, 445, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("debug", 0, 2, 2, i); __PYX_ERR(0, 445, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 445, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 445, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("debug", 0, 2, 2, __pyx_nargs); __PYX_ERR(0, 445, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.Logger.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_24debug(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_24debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("debug", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":447 + * def debug(self, message, *args, **kwargs): + * """DEBUG """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) +*/ + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 447, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":448 + * """DEBUG """ + * if args: + * message = message % args # <<<<<<<<<<<<<< + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) + * +*/ + __pyx_t_2 = PyNumber_Remainder(__pyx_v_message, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":447 + * def debug(self, message, *args, **kwargs): + * """DEBUG """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) +*/ + } + + /* "loggerModule.py":449 + * if args: + * message = message % args + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) # <<<<<<<<<<<<<< + * + * def info(self, message, *args, **kwargs): +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DEBUG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_exc_info, Py_False); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_message}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_level, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 449, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exc_info, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 449, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":445 + * + * # + * def debug(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """DEBUG """ + * if args: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":451 + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) + * + * def info(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """INFO """ + * if args: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_27info(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_26info, "INFO \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_27info = {"info", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_27info, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_26info}; +static PyObject *__pyx_pw_12loggerModule_6Logger_27info(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("info (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 2, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 451, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 451, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 451, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 2) ? kwd_pos_args : 2; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "info", 1) < 0) __PYX_ERR(0, 451, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("info", 0, 2, 2, i); __PYX_ERR(0, 451, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 451, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 451, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("info", 0, 2, 2, __pyx_nargs); __PYX_ERR(0, 451, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.Logger.info", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_26info(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_26info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("info", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":453 + * def info(self, message, *args, **kwargs): + * """INFO """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) +*/ + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 453, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":454 + * """INFO """ + * if args: + * message = message % args # <<<<<<<<<<<<<< + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) + * +*/ + __pyx_t_2 = PyNumber_Remainder(__pyx_v_message, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":453 + * def info(self, message, *args, **kwargs): + * """INFO """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) +*/ + } + + /* "loggerModule.py":455 + * if args: + * message = message % args + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) # <<<<<<<<<<<<<< + * + * def warning(self, message, *args, **kwargs): +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INFO); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_exc_info, Py_False); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_message}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_level, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 455, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exc_info, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 455, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":451 + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) + * + * def info(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """INFO """ + * if args: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.info", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":457 + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) + * + * def warning(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """WARNING """ + * if args: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_29warning(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_28warning, "WARNING \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_29warning = {"warning", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_29warning, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_28warning}; +static PyObject *__pyx_pw_12loggerModule_6Logger_29warning(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("warning (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 2, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 457, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 457, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 457, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 2) ? kwd_pos_args : 2; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "warning", 1) < 0) __PYX_ERR(0, 457, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("warning", 0, 2, 2, i); __PYX_ERR(0, 457, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 457, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 457, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("warning", 0, 2, 2, __pyx_nargs); __PYX_ERR(0, 457, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.Logger.warning", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_28warning(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_28warning(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("warning", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":459 + * def warning(self, message, *args, **kwargs): + * """WARNING """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) +*/ + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 459, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":460 + * """WARNING """ + * if args: + * message = message % args # <<<<<<<<<<<<<< + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) + * +*/ + __pyx_t_2 = PyNumber_Remainder(__pyx_v_message, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":459 + * def warning(self, message, *args, **kwargs): + * """WARNING """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) +*/ + } + + /* "loggerModule.py":461 + * if args: + * message = message % args + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) # <<<<<<<<<<<<<< + * + * def error(self, message, *args, **kwargs): +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WARNING); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_exc_info, Py_False); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_message}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_level, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 461, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exc_info, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 461, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":457 + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) + * + * def warning(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """WARNING """ + * if args: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.warning", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":463 + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) + * + * def error(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """ERROR """ + * if args: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_31error(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_30error, "ERROR \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_31error = {"error", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_31error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_30error}; +static PyObject *__pyx_pw_12loggerModule_6Logger_31error(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("error (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 2, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 463, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 463, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 463, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 2) ? kwd_pos_args : 2; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "error", 1) < 0) __PYX_ERR(0, 463, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("error", 0, 2, 2, i); __PYX_ERR(0, 463, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 463, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 463, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("error", 0, 2, 2, __pyx_nargs); __PYX_ERR(0, 463, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.Logger.error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_30error(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_30error(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("error", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":465 + * def error(self, message, *args, **kwargs): + * """ERROR """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) +*/ + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 465, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":466 + * """ERROR """ + * if args: + * message = message % args # <<<<<<<<<<<<<< + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) + * +*/ + __pyx_t_2 = PyNumber_Remainder(__pyx_v_message, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":465 + * def error(self, message, *args, **kwargs): + * """ERROR """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) +*/ + } + + /* "loggerModule.py":467 + * if args: + * message = message % args + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) # <<<<<<<<<<<<<< + * + * def critical(self, message, *args, **kwargs): +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ERROR); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_exc_info, Py_False); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_message}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_level, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 467, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exc_info, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 467, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":463 + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) + * + * def error(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """ERROR """ + * if args: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":469 + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) + * + * def critical(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """CRITICAL """ + * if args: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_33critical(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_32critical, "CRITICAL \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_33critical = {"critical", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_33critical, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_32critical}; +static PyObject *__pyx_pw_12loggerModule_6Logger_33critical(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("critical (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 2, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 469, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 469, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 469, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 2) ? kwd_pos_args : 2; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "critical", 1) < 0) __PYX_ERR(0, 469, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("critical", 0, 2, 2, i); __PYX_ERR(0, 469, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 469, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 469, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("critical", 0, 2, 2, __pyx_nargs); __PYX_ERR(0, 469, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.Logger.critical", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_32critical(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_32critical(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("critical", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":471 + * def critical(self, message, *args, **kwargs): + * """CRITICAL """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) +*/ + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 471, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":472 + * """CRITICAL """ + * if args: + * message = message % args # <<<<<<<<<<<<<< + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) + * +*/ + __pyx_t_2 = PyNumber_Remainder(__pyx_v_message, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":471 + * def critical(self, message, *args, **kwargs): + * """CRITICAL """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) +*/ + } + + /* "loggerModule.py":473 + * if args: + * message = message % args + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) # <<<<<<<<<<<<<< + * + * def exception(self, message, *args, **kwargs): +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_CRITICAL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItemDefault(__pyx_v_kwargs, __pyx_mstate_global->__pyx_n_u_exc_info, Py_False); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_message}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_level, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 473, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exc_info, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":469 + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) + * + * def critical(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """CRITICAL """ + * if args: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.Logger.critical", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":475 + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) + * + * def exception(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """ERROR """ + * if args: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_6Logger_35exception(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6Logger_34exception, "ERROR \353\240\210\353\262\250\353\241\234 \354\230\210\354\231\270 \354\240\225\353\263\264\354\231\200 \355\225\250\352\273\230 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_6Logger_35exception = {"exception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_6Logger_35exception, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6Logger_34exception}; +static PyObject *__pyx_pw_12loggerModule_6Logger_35exception(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_message = 0; + PyObject *__pyx_v_args = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exception (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 2, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_message,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 475, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 475, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 475, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 2) ? kwd_pos_args : 2; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "exception", 1) < 0) __PYX_ERR(0, 475, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("exception", 0, 2, 2, i); __PYX_ERR(0, 475, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 475, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 475, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_message = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("exception", 0, 2, 2, __pyx_nargs); __PYX_ERR(0, 475, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.Logger.exception", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6Logger_34exception(__pyx_self, __pyx_v_self, __pyx_v_message, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6Logger_34exception(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_message, PyObject *__pyx_v_args, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("exception", 0); + __Pyx_INCREF(__pyx_v_message); + + /* "loggerModule.py":477 + * def exception(self, message, *args, **kwargs): + * """ERROR """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.ERROR, exc_info=True) +*/ + __pyx_t_1 = (__Pyx_PyTuple_GET_SIZE(__pyx_v_args) != 0); + if (unlikely(((!CYTHON_ASSUME_SAFE_MACROS) && __pyx_t_1 < 0))) __PYX_ERR(0, 477, __pyx_L1_error) + if (__pyx_t_1) { + + /* "loggerModule.py":478 + * """ERROR """ + * if args: + * message = message % args # <<<<<<<<<<<<<< + * self.log(message, level=logging.ERROR, exc_info=True) + * +*/ + __pyx_t_2 = PyNumber_Remainder(__pyx_v_message, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_message, __pyx_t_2); + __pyx_t_2 = 0; + + /* "loggerModule.py":477 + * def exception(self, message, *args, **kwargs): + * """ERROR """ + * if args: # <<<<<<<<<<<<<< + * message = message % args + * self.log(message, level=logging.ERROR, exc_info=True) +*/ + } + + /* "loggerModule.py":479 + * if args: + * message = message % args + * self.log(message, level=logging.ERROR, exc_info=True) # <<<<<<<<<<<<<< + * + * # +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ERROR); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_3, __pyx_v_message}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_level, __pyx_t_5, __pyx_t_4, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 479, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_exc_info, Py_True, __pyx_t_4, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_2 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":475 + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) + * + * def exception(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """ERROR """ + * if args: +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.Logger.exception", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":484 + * _default_logger = None + * + * def get_default_logger(): # <<<<<<<<<<<<<< + * """ """ + * global _default_logger +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_3get_default_logger(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_2get_default_logger, "\352\270\260\353\263\270 \353\241\234\352\261\260 \354\235\270\354\212\244\355\204\264\354\212\244 \353\260\230\355\231\230"); +static PyMethodDef __pyx_mdef_12loggerModule_3get_default_logger = {"get_default_logger", (PyCFunction)__pyx_pw_12loggerModule_3get_default_logger, METH_NOARGS, __pyx_doc_12loggerModule_2get_default_logger}; +static PyObject *__pyx_pw_12loggerModule_3get_default_logger(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_default_logger (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_12loggerModule_2get_default_logger(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_2get_default_logger(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_default_logger", 0); + + /* "loggerModule.py":487 + * """ """ + * global _default_logger + * if _default_logger is None: # <<<<<<<<<<<<<< + * _default_logger = Logger(log_file="logs/default.log") + * return _default_logger +*/ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_default_logger); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 == Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "loggerModule.py":488 + * global _default_logger + * if _default_logger is None: + * _default_logger = Logger(log_file="logs/default.log") # <<<<<<<<<<<<<< + * return _default_logger + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Logger_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, NULL}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_log_file, __pyx_mstate_global->__pyx_kp_u_logs_default_log, __pyx_t_6, __pyx_callargs+1, 0) < 0) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_default_logger, __pyx_t_1) < 0) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":487 + * """ """ + * global _default_logger + * if _default_logger is None: # <<<<<<<<<<<<<< + * _default_logger = Logger(log_file="logs/default.log") + * return _default_logger +*/ + } + + /* "loggerModule.py":489 + * if _default_logger is None: + * _default_logger = Logger(log_file="logs/default.log") + * return _default_logger # <<<<<<<<<<<<<< + * + * def set_default_logger(logger): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_default_logger); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "loggerModule.py":484 + * _default_logger = None + * + * def get_default_logger(): # <<<<<<<<<<<<<< + * """ """ + * global _default_logger +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("loggerModule.get_default_logger", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":491 + * return _default_logger + * + * def set_default_logger(logger): # <<<<<<<<<<<<<< + * """ """ + * global _default_logger +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_5set_default_logger(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_4set_default_logger, "\352\270\260\353\263\270 \353\241\234\352\261\260 \354\204\244\354\240\225"); +static PyMethodDef __pyx_mdef_12loggerModule_5set_default_logger = {"set_default_logger", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_5set_default_logger, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_4set_default_logger}; +static PyObject *__pyx_pw_12loggerModule_5set_default_logger(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_logger = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_default_logger (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_logger,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 491, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 491, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_default_logger", 0) < 0) __PYX_ERR(0, 491, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_default_logger", 1, 1, 1, i); __PYX_ERR(0, 491, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 491, __pyx_L3_error) + } + __pyx_v_logger = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_default_logger", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 491, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("loggerModule.set_default_logger", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_4set_default_logger(__pyx_self, __pyx_v_logger); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_4set_default_logger(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_logger) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_default_logger", 0); + + /* "loggerModule.py":494 + * """ """ + * global _default_logger + * _default_logger = logger # <<<<<<<<<<<<<< + * + * # - +*/ + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_default_logger, __pyx_v_logger) < 0) __PYX_ERR(0, 494, __pyx_L1_error) + + /* "loggerModule.py":491 + * return _default_logger + * + * def set_default_logger(logger): # <<<<<<<<<<<<<< + * """ """ + * global _default_logger +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("loggerModule.set_default_logger", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":497 + * + * # - + * def debug(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - DEBUG """ + * get_default_logger().debug(msg, *args, **kwargs) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_7debug(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_6debug, "\355\216\270\354\235\230 \355\225\250\354\210\230 - DEBUG \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_7debug = {"debug", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_7debug, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_6debug}; +static PyObject *__pyx_pw_12loggerModule_7debug(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("debug (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_msg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 497, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 497, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "debug", 1) < 0) __PYX_ERR(0, 497, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("debug", 0, 1, 1, i); __PYX_ERR(0, 497, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 497, __pyx_L3_error) + } + __pyx_v_msg = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("debug", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 497, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_6debug(__pyx_self, __pyx_v_msg, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_6debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("debug", 0); + + /* "loggerModule.py":499 + * def debug(msg, *args, **kwargs): + * """ - DEBUG """ + * get_default_logger().debug(msg, *args, **kwargs) # <<<<<<<<<<<<<< + * + * def info(msg, *args, **kwargs): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_default_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_debug); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg) != (0)) __PYX_ERR(0, 499, __pyx_L1_error); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":497 + * + * # - + * def debug(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - DEBUG """ + * get_default_logger().debug(msg, *args, **kwargs) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":501 + * get_default_logger().debug(msg, *args, **kwargs) + * + * def info(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - INFO """ + * get_default_logger().info(msg, *args, **kwargs) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_9info(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_8info, "\355\216\270\354\235\230 \355\225\250\354\210\230 - INFO \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_9info = {"info", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_9info, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_8info}; +static PyObject *__pyx_pw_12loggerModule_9info(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("info (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_msg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 501, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 501, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "info", 1) < 0) __PYX_ERR(0, 501, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("info", 0, 1, 1, i); __PYX_ERR(0, 501, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 501, __pyx_L3_error) + } + __pyx_v_msg = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("info", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 501, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.info", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_8info(__pyx_self, __pyx_v_msg, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_8info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("info", 0); + + /* "loggerModule.py":503 + * def info(msg, *args, **kwargs): + * """ - INFO """ + * get_default_logger().info(msg, *args, **kwargs) # <<<<<<<<<<<<<< + * + * def warning(msg, *args, **kwargs): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_default_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg) != (0)) __PYX_ERR(0, 503, __pyx_L1_error); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":501 + * get_default_logger().debug(msg, *args, **kwargs) + * + * def info(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - INFO """ + * get_default_logger().info(msg, *args, **kwargs) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.info", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":505 + * get_default_logger().info(msg, *args, **kwargs) + * + * def warning(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - WARNING """ + * get_default_logger().warning(msg, *args, **kwargs) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_11warning(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_10warning, "\355\216\270\354\235\230 \355\225\250\354\210\230 - WARNING \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_11warning = {"warning", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_11warning, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_10warning}; +static PyObject *__pyx_pw_12loggerModule_11warning(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("warning (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_msg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 505, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 505, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "warning", 1) < 0) __PYX_ERR(0, 505, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("warning", 0, 1, 1, i); __PYX_ERR(0, 505, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 505, __pyx_L3_error) + } + __pyx_v_msg = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("warning", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 505, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.warning", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_10warning(__pyx_self, __pyx_v_msg, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_10warning(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("warning", 0); + + /* "loggerModule.py":507 + * def warning(msg, *args, **kwargs): + * """ - WARNING """ + * get_default_logger().warning(msg, *args, **kwargs) # <<<<<<<<<<<<<< + * + * def error(msg, *args, **kwargs): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_default_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_warning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg) != (0)) __PYX_ERR(0, 507, __pyx_L1_error); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":505 + * get_default_logger().info(msg, *args, **kwargs) + * + * def warning(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - WARNING """ + * get_default_logger().warning(msg, *args, **kwargs) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.warning", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":509 + * get_default_logger().warning(msg, *args, **kwargs) + * + * def error(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - ERROR """ + * get_default_logger().error(msg, *args, **kwargs) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_13error(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_12error, "\355\216\270\354\235\230 \355\225\250\354\210\230 - ERROR \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_13error = {"error", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_13error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_12error}; +static PyObject *__pyx_pw_12loggerModule_13error(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("error (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_msg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 509, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 509, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "error", 1) < 0) __PYX_ERR(0, 509, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("error", 0, 1, 1, i); __PYX_ERR(0, 509, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 509, __pyx_L3_error) + } + __pyx_v_msg = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("error", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 509, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_12error(__pyx_self, __pyx_v_msg, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_12error(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("error", 0); + + /* "loggerModule.py":511 + * def error(msg, *args, **kwargs): + * """ - ERROR """ + * get_default_logger().error(msg, *args, **kwargs) # <<<<<<<<<<<<<< + * + * def critical(msg, *args, **kwargs): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_default_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg) != (0)) __PYX_ERR(0, 511, __pyx_L1_error); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":509 + * get_default_logger().warning(msg, *args, **kwargs) + * + * def error(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - ERROR """ + * get_default_logger().error(msg, *args, **kwargs) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":513 + * get_default_logger().error(msg, *args, **kwargs) + * + * def critical(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - CRITICAL """ + * get_default_logger().critical(msg, *args, **kwargs) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_15critical(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_14critical, "\355\216\270\354\235\230 \355\225\250\354\210\230 - CRITICAL \353\240\210\353\262\250 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_15critical = {"critical", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_15critical, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_14critical}; +static PyObject *__pyx_pw_12loggerModule_15critical(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("critical (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_msg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 513, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 513, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "critical", 1) < 0) __PYX_ERR(0, 513, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("critical", 0, 1, 1, i); __PYX_ERR(0, 513, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 513, __pyx_L3_error) + } + __pyx_v_msg = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("critical", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 513, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.critical", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_14critical(__pyx_self, __pyx_v_msg, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_14critical(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("critical", 0); + + /* "loggerModule.py":515 + * def critical(msg, *args, **kwargs): + * """ - CRITICAL """ + * get_default_logger().critical(msg, *args, **kwargs) # <<<<<<<<<<<<<< + * + * def exception(msg, *args, **kwargs): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_default_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_critical); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":513 + * get_default_logger().error(msg, *args, **kwargs) + * + * def critical(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - CRITICAL """ + * get_default_logger().critical(msg, *args, **kwargs) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.critical", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":517 + * get_default_logger().critical(msg, *args, **kwargs) + * + * def exception(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - """ + * get_default_logger().exception(msg, *args, **kwargs) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_17exception(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_16exception, "\355\216\270\354\235\230 \355\225\250\354\210\230 - \354\230\210\354\231\270 \354\240\225\353\263\264\354\231\200 \355\225\250\352\273\230 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_17exception = {"exception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_17exception, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_16exception}; +static PyObject *__pyx_pw_12loggerModule_17exception(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exception (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_msg,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 517, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 517, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "exception", 1) < 0) __PYX_ERR(0, 517, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("exception", 0, 1, 1, i); __PYX_ERR(0, 517, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 517, __pyx_L3_error) + } + __pyx_v_msg = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("exception", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 517, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.exception", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_16exception(__pyx_self, __pyx_v_msg, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_16exception(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_msg, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("exception", 0); + + /* "loggerModule.py":519 + * def exception(msg, *args, **kwargs): + * """ - """ + * get_default_logger().exception(msg, *args, **kwargs) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_default_logger); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg) != (0)) __PYX_ERR(0, 519, __pyx_L1_error); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "loggerModule.py":517 + * get_default_logger().critical(msg, *args, **kwargs) + * + * def exception(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - """ + * get_default_logger().exception(msg, *args, **kwargs) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("loggerModule.exception", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":526 + * """JSON """ + * + * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * super().__init__(*args, **kwargs) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_12loggerModule_16StructuredLogger_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_16StructuredLogger_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_args = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_args)) { + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_args); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 526, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + default: + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 526, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__init__", 1) < 0) __PYX_ERR(0, 526, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, i); __PYX_ERR(0, 526, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 526, __pyx_L3_error) + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, __pyx_nargs); __PYX_ERR(0, 526, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("loggerModule.StructuredLogger.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_16StructuredLogger___init__(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_args); + __Pyx_DECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "loggerModule.py":527 + * + * def __init__(self, *args, **kwargs): + * super().__init__(*args, **kwargs) # <<<<<<<<<<<<<< + * + * def log_structured(self, event, level=logging.INFO, **context): +*/ + __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_builtin_super); + __pyx_t_3 = __pyx_builtin_super; + __pyx_t_4 = __Pyx_CyFunction_GetClassObj(__pyx_self); + if (!__pyx_t_4) { PyErr_SetString(PyExc_RuntimeError, "super(): empty __class__ cell"); __PYX_ERR(0, 527, __pyx_L1_error) } + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_4, __pyx_v_self}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_v_args, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":526 + * """JSON """ + * + * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * super().__init__(*args, **kwargs) + * +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("loggerModule.StructuredLogger.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":529 + * super().__init__(*args, **kwargs) + * + * def log_structured(self, event, level=logging.INFO, **context): # <<<<<<<<<<<<<< + * """ """ + * import json +*/ + +static PyObject *__pyx_pf_12loggerModule_22__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 529, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 529, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None) != (0)) __PYX_ERR(0, 529, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("loggerModule.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_3log_structured(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_16StructuredLogger_2log_structured, "\352\265\254\354\241\260\355\231\224\353\220\234 \353\241\234\352\267\270 \352\270\260\353\241\235"); +static PyMethodDef __pyx_mdef_12loggerModule_16StructuredLogger_3log_structured = {"log_structured", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_16StructuredLogger_3log_structured, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_16StructuredLogger_2log_structured}; +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_3log_structured(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_event = 0; + PyObject *__pyx_v_level = 0; + PyObject *__pyx_v_context = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("log_structured (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_context = PyDict_New(); if (unlikely(!__pyx_v_context)) return NULL; + __Pyx_GOTREF(__pyx_v_context); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_event,&__pyx_mstate_global->__pyx_n_u_level,0}; + struct __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 529, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 529, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 529, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 529, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_context, values, kwd_pos_args, __pyx_kwds_len, "log_structured", 1) < 0) __PYX_ERR(0, 529, __pyx_L3_error) + if (!values[2]) values[2] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("log_structured", 0, 2, 3, i); __PYX_ERR(0, 529, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 529, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 529, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 529, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[2]) values[2] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + } + __pyx_v_self = values[0]; + __pyx_v_event = values[1]; + __pyx_v_level = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("log_structured", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 529, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_context); __pyx_v_context = 0; + __Pyx_AddTraceback("loggerModule.StructuredLogger.log_structured", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_16StructuredLogger_2log_structured(__pyx_self, __pyx_v_self, __pyx_v_event, __pyx_v_level, __pyx_v_context); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_context); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger_2log_structured(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_event, PyObject *__pyx_v_level, PyObject *__pyx_v_context) { + PyObject *__pyx_v_json = NULL; + PyObject *__pyx_v_log_data = NULL; + PyObject *__pyx_v_message = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("log_structured", 0); + + /* "loggerModule.py":531 + * def log_structured(self, event, level=logging.INFO, **context): + * """ """ + * import json # <<<<<<<<<<<<<< + * + * log_data = { +*/ + __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_json, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_json = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":534 + * + * log_data = { + * "timestamp": datetime.now().isoformat(), # <<<<<<<<<<<<<< + * "event": event, + * "level": get_level_name(level), +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_now); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_isoformat, __pyx_callargs+__pyx_t_9, (1-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_timestamp, __pyx_t_3) < 0) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":535 + * log_data = { + * "timestamp": datetime.now().isoformat(), + * "event": event, # <<<<<<<<<<<<<< + * "level": get_level_name(level), + * **context +*/ + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_event, __pyx_v_event) < 0) __PYX_ERR(0, 534, __pyx_L1_error) + + /* "loggerModule.py":536 + * "timestamp": datetime.now().isoformat(), + * "event": event, + * "level": get_level_name(level), # <<<<<<<<<<<<<< + * **context + * } +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_level_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_level}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_level, __pyx_t_3) < 0) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = 0; + + /* "loggerModule.py":537 + * "event": event, + * "level": get_level_name(level), + * **context # <<<<<<<<<<<<<< + * } + * +*/ + if (unlikely(PyDict_Update(__pyx_t_1, __pyx_v_context) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_context); + __PYX_ERR(0, 537, __pyx_L1_error) + } + __pyx_v_log_data = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "loggerModule.py":540 + * } + * + * message = json.dumps(log_data, ensure_ascii=False, separators=(',', ':')) # <<<<<<<<<<<<<< + * self.log(message, level) + * +*/ + __pyx_t_2 = __pyx_v_json; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_2, __pyx_v_log_data}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_ensure_ascii, Py_False, __pyx_t_3, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 540, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_separators, __pyx_mstate_global->__pyx_tuple[2], __pyx_t_3, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 540, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_VectorcallMethod_CallFromBuilder(__pyx_mstate_global->__pyx_n_u_dumps, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_message = __pyx_t_1; + __pyx_t_1 = 0; + + /* "loggerModule.py":541 + * + * message = json.dumps(log_data, ensure_ascii=False, separators=(',', ':')) + * self.log(message, level) # <<<<<<<<<<<<<< + * + * def log_performance(self, operation, duration, **context): +*/ + __pyx_t_3 = __pyx_v_self; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_message, __pyx_v_level}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_log_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 541, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":529 + * super().__init__(*args, **kwargs) + * + * def log_structured(self, event, level=logging.INFO, **context): # <<<<<<<<<<<<<< + * """ """ + * import json +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("loggerModule.StructuredLogger.log_structured", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_json); + __Pyx_XDECREF(__pyx_v_log_data); + __Pyx_XDECREF(__pyx_v_message); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":543 + * self.log(message, level) + * + * def log_performance(self, operation, duration, **context): # <<<<<<<<<<<<<< + * """ """ + * self.log_structured( +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_5log_performance(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_16StructuredLogger_4log_performance, "\354\204\261\353\212\245 \353\241\234\352\267\270 \352\270\260\353\241\235"); +static PyMethodDef __pyx_mdef_12loggerModule_16StructuredLogger_5log_performance = {"log_performance", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_16StructuredLogger_5log_performance, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_16StructuredLogger_4log_performance}; +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_5log_performance(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_operation = 0; + PyObject *__pyx_v_duration = 0; + PyObject *__pyx_v_context = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("log_performance (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_context = PyDict_New(); if (unlikely(!__pyx_v_context)) return NULL; + __Pyx_GOTREF(__pyx_v_context); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_operation,&__pyx_mstate_global->__pyx_n_u_duration,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 543, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_context, values, kwd_pos_args, __pyx_kwds_len, "log_performance", 1) < 0) __PYX_ERR(0, 543, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("log_performance", 1, 3, 3, i); __PYX_ERR(0, 543, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 543, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 543, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 543, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_operation = values[1]; + __pyx_v_duration = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("log_performance", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 543, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_context); __pyx_v_context = 0; + __Pyx_AddTraceback("loggerModule.StructuredLogger.log_performance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_16StructuredLogger_4log_performance(__pyx_self, __pyx_v_self, __pyx_v_operation, __pyx_v_duration, __pyx_v_context); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_context); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger_4log_performance(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_operation, PyObject *__pyx_v_duration, PyObject *__pyx_v_context) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("log_performance", 0); + + /* "loggerModule.py":545 + * def log_performance(self, operation, duration, **context): + * """ """ + * self.log_structured( # <<<<<<<<<<<<<< + * "performance", + * level=logging.INFO, +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_structured); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "loggerModule.py":547 + * self.log_structured( + * "performance", + * level=logging.INFO, # <<<<<<<<<<<<<< + * operation=operation, + * duration_ms=round(duration * 1000, 2), +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_INFO); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_level, __pyx_t_7) < 0) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":548 + * "performance", + * level=logging.INFO, + * operation=operation, # <<<<<<<<<<<<<< + * duration_ms=round(duration * 1000, 2), + * **context +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_operation, __pyx_v_operation) < 0) __PYX_ERR(0, 547, __pyx_L1_error) + + /* "loggerModule.py":549 + * level=logging.INFO, + * operation=operation, + * duration_ms=round(duration * 1000, 2), # <<<<<<<<<<<<<< + * **context + * ) +*/ + __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_builtin_round); + __pyx_t_8 = __pyx_builtin_round; + __pyx_t_9 = __Pyx_PyLong_MultiplyObjC(__pyx_v_duration, __pyx_mstate_global->__pyx_int_1000, 0x3E8, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_9, __pyx_mstate_global->__pyx_int_2}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_10, (3-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_duration_ms, __pyx_t_7) < 0) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "loggerModule.py":550 + * operation=operation, + * duration_ms=round(duration * 1000, 2), + * **context # <<<<<<<<<<<<<< + * ) + * +*/ + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_context) < 0) __PYX_ERR(0, 550, __pyx_L1_error) + __pyx_t_10 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_10 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_performance}; + __pyx_t_1 = __Pyx_PyObject_FastCallDict(__pyx_t_3, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":543 + * self.log(message, level) + * + * def log_performance(self, operation, duration, **context): # <<<<<<<<<<<<<< + * """ """ + * self.log_structured( +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("loggerModule.StructuredLogger.log_performance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "loggerModule.py":553 + * ) + * + * def log_error_with_context(self, error, **context): # <<<<<<<<<<<<<< + * """ """ + * self.log_structured( +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_7log_error_with_context(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_12loggerModule_16StructuredLogger_6log_error_with_context, "\354\227\220\353\237\254\354\231\200 \354\273\250\355\205\215\354\212\244\355\212\270\353\245\274 \355\225\250\352\273\230 \353\241\234\352\267\270"); +static PyMethodDef __pyx_mdef_12loggerModule_16StructuredLogger_7log_error_with_context = {"log_error_with_context", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12loggerModule_16StructuredLogger_7log_error_with_context, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12loggerModule_16StructuredLogger_6log_error_with_context}; +static PyObject *__pyx_pw_12loggerModule_16StructuredLogger_7log_error_with_context(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_error = 0; + PyObject *__pyx_v_context = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("log_error_with_context (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_context = PyDict_New(); if (unlikely(!__pyx_v_context)) return NULL; + __Pyx_GOTREF(__pyx_v_context); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_error,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 553, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 553, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 553, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_context, values, kwd_pos_args, __pyx_kwds_len, "log_error_with_context", 1) < 0) __PYX_ERR(0, 553, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("log_error_with_context", 1, 2, 2, i); __PYX_ERR(0, 553, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 553, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 553, __pyx_L3_error) + } + __pyx_v_self = values[0]; + __pyx_v_error = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("log_error_with_context", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 553, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_context); __pyx_v_context = 0; + __Pyx_AddTraceback("loggerModule.StructuredLogger.log_error_with_context", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_12loggerModule_16StructuredLogger_6log_error_with_context(__pyx_self, __pyx_v_self, __pyx_v_error, __pyx_v_context); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_DECREF(__pyx_v_context); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12loggerModule_16StructuredLogger_6log_error_with_context(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_error, PyObject *__pyx_v_context) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("log_error_with_context", 0); + + /* "loggerModule.py":555 + * def log_error_with_context(self, error, **context): + * """ """ + * self.log_structured( # <<<<<<<<<<<<<< + * "error", + * level=logging.ERROR, +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_log_structured); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "loggerModule.py":557 + * self.log_structured( + * "error", + * level=logging.ERROR, # <<<<<<<<<<<<<< + * error_type=type(error).__name__, + * error_message=str(error), +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ERROR); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_level, __pyx_t_7) < 0) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":558 + * "error", + * level=logging.ERROR, + * error_type=type(error).__name__, # <<<<<<<<<<<<<< + * error_message=str(error), + * **context +*/ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_error)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 558, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_error_type, __pyx_t_7) < 0) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "loggerModule.py":559 + * level=logging.ERROR, + * error_type=type(error).__name__, + * error_message=str(error), # <<<<<<<<<<<<<< + * **context + * ) +*/ + __pyx_t_7 = __Pyx_PyObject_Unicode(__pyx_v_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_error_message, __pyx_t_7) < 0) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "loggerModule.py":560 + * error_type=type(error).__name__, + * error_message=str(error), + * **context # <<<<<<<<<<<<<< + * ) +*/ + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_context) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_error}; + __pyx_t_1 = __Pyx_PyObject_FastCallDict(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "loggerModule.py":553 + * ) + * + * def log_error_with_context(self, error, **context): # <<<<<<<<<<<<<< + * """ """ + * self.log_structured( +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("loggerModule.StructuredLogger.log_error_with_context", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ + +static PyObject *__pyx_tp_new_12loggerModule___pyx_defaults(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_12loggerModule___pyx_defaults(PyObject *o) { + struct __pyx_defaults *p = (struct __pyx_defaults *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_12loggerModule___pyx_defaults) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->arg0); + Py_CLEAR(p->arg1); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_12loggerModule___pyx_defaults(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_defaults *p = (struct __pyx_defaults *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->arg0) { + e = (*v)(p->arg0, a); if (e) return e; + } + if (p->arg1) { + e = (*v)(p->arg1, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_12loggerModule___pyx_defaults(PyObject *o) { + PyObject* tmp; + struct __pyx_defaults *p = (struct __pyx_defaults *)o; + tmp = ((PyObject*)p->arg0); + p->arg0 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->arg1); + p->arg1 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_12loggerModule___pyx_defaults_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_12loggerModule___pyx_defaults}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_12loggerModule___pyx_defaults}, + {Py_tp_clear, (void *)__pyx_tp_clear_12loggerModule___pyx_defaults}, + {Py_tp_new, (void *)__pyx_tp_new_12loggerModule___pyx_defaults}, + {0, 0}, +}; +static PyType_Spec __pyx_type_12loggerModule___pyx_defaults_spec = { + "loggerModule.__pyx_defaults", + sizeof(struct __pyx_defaults), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_12loggerModule___pyx_defaults_slots, +}; +#else + +static PyTypeObject __pyx_type_12loggerModule___pyx_defaults = { + PyVarObject_HEAD_INIT(0, 0) + "loggerModule.""__pyx_defaults", /*tp_name*/ + sizeof(struct __pyx_defaults), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_12loggerModule___pyx_defaults, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_12loggerModule___pyx_defaults, /*tp_traverse*/ + __pyx_tp_clear_12loggerModule___pyx_defaults, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_12loggerModule___pyx_defaults, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_12loggerModule___pyx_defaults1(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_12loggerModule___pyx_defaults1(PyObject *o) { + struct __pyx_defaults1 *p = (struct __pyx_defaults1 *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_12loggerModule___pyx_defaults1) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->arg0); + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_12loggerModule___pyx_defaults1(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_defaults1 *p = (struct __pyx_defaults1 *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->arg0) { + e = (*v)(p->arg0, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_12loggerModule___pyx_defaults1(PyObject *o) { + PyObject* tmp; + struct __pyx_defaults1 *p = (struct __pyx_defaults1 *)o; + tmp = ((PyObject*)p->arg0); + p->arg0 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_12loggerModule___pyx_defaults1_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_12loggerModule___pyx_defaults1}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_12loggerModule___pyx_defaults1}, + {Py_tp_clear, (void *)__pyx_tp_clear_12loggerModule___pyx_defaults1}, + {Py_tp_new, (void *)__pyx_tp_new_12loggerModule___pyx_defaults1}, + {0, 0}, +}; +static PyType_Spec __pyx_type_12loggerModule___pyx_defaults1_spec = { + "loggerModule.__pyx_defaults1", + sizeof(struct __pyx_defaults1), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_12loggerModule___pyx_defaults1_slots, +}; +#else + +static PyTypeObject __pyx_type_12loggerModule___pyx_defaults1 = { + PyVarObject_HEAD_INIT(0, 0) + "loggerModule.""__pyx_defaults1", /*tp_name*/ + sizeof(struct __pyx_defaults1), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_12loggerModule___pyx_defaults1, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_12loggerModule___pyx_defaults1, /*tp_traverse*/ + __pyx_tp_clear_12loggerModule___pyx_defaults1, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_12loggerModule___pyx_defaults1, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_12loggerModule___pyx_scope_struct___start_cleanup_thread(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct___start_cleanup_thread > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_12loggerModule___pyx_scope_struct___start_cleanup_thread[--__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct___start_cleanup_thread]; + memset(o, 0, sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_12loggerModule___pyx_scope_struct___start_cleanup_thread(PyObject *o) { + struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *p = (struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_12loggerModule___pyx_scope_struct___start_cleanup_thread) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_self); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct___start_cleanup_thread < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread)))) { + __pyx_mstate_global->__pyx_freelist_12loggerModule___pyx_scope_struct___start_cleanup_thread[__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct___start_cleanup_thread++] = ((struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_12loggerModule___pyx_scope_struct___start_cleanup_thread(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *p = (struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(p->__pyx_v_self, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_12loggerModule___pyx_scope_struct___start_cleanup_thread(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *p = (struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread *)o; + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_12loggerModule___pyx_scope_struct___start_cleanup_thread}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_12loggerModule___pyx_scope_struct___start_cleanup_thread}, + {Py_tp_clear, (void *)__pyx_tp_clear_12loggerModule___pyx_scope_struct___start_cleanup_thread}, + {Py_tp_new, (void *)__pyx_tp_new_12loggerModule___pyx_scope_struct___start_cleanup_thread}, + {0, 0}, +}; +static PyType_Spec __pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread_spec = { + "loggerModule.__pyx_scope_struct___start_cleanup_thread", + sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread_slots, +}; +#else + +static PyTypeObject __pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread = { + PyVarObject_HEAD_INIT(0, 0) + "loggerModule.""__pyx_scope_struct___start_cleanup_thread", /*tp_name*/ + sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct___start_cleanup_thread), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_12loggerModule___pyx_scope_struct___start_cleanup_thread, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_12loggerModule___pyx_scope_struct___start_cleanup_thread, /*tp_traverse*/ + __pyx_tp_clear_12loggerModule___pyx_scope_struct___start_cleanup_thread, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_12loggerModule___pyx_scope_struct___start_cleanup_thread, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_12loggerModule___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct_1_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_12loggerModule___pyx_scope_struct_1_genexpr[--__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_12loggerModule___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_12loggerModule___pyx_scope_struct_1_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_f); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct_1_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr)))) { + __pyx_mstate_global->__pyx_freelist_12loggerModule___pyx_scope_struct_1_genexpr[__pyx_mstate_global->__pyx_freecount_12loggerModule___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_12loggerModule___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_f) { + e = (*v)(p->__pyx_v_f, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_12loggerModule___pyx_scope_struct_1_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_12loggerModule___pyx_scope_struct_1_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_12loggerModule___pyx_scope_struct_1_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_12loggerModule___pyx_scope_struct_1_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_12loggerModule___pyx_scope_struct_1_genexpr_spec = { + "loggerModule.__pyx_scope_struct_1_genexpr", + sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_12loggerModule___pyx_scope_struct_1_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_12loggerModule___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "loggerModule.""__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_12loggerModule___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_12loggerModule___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_12loggerModule___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_12loggerModule___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_12loggerModule___pyx_defaults_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults)) __PYX_ERR(0, 198, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_12loggerModule___pyx_defaults_spec, __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults) < 0) __PYX_ERR(0, 198, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults = &__pyx_type_12loggerModule___pyx_defaults; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults) < 0) __PYX_ERR(0, 198, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults->tp_dictoffset && __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_12loggerModule___pyx_defaults1_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1)) __PYX_ERR(0, 361, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_12loggerModule___pyx_defaults1_spec, __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1) < 0) __PYX_ERR(0, 361, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1 = &__pyx_type_12loggerModule___pyx_defaults1; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1) < 0) __PYX_ERR(0, 361, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1->tp_dictoffset && __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_defaults1->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread)) __PYX_ERR(0, 307, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread_spec, __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread) < 0) __PYX_ERR(0, 307, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread = &__pyx_type_12loggerModule___pyx_scope_struct___start_cleanup_thread; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread) < 0) __PYX_ERR(0, 307, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread->tp_dictoffset && __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct___start_cleanup_thread->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_12loggerModule___pyx_scope_struct_1_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr)) __PYX_ERR(0, 428, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_12loggerModule___pyx_scope_struct_1_genexpr_spec, __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 428, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr = &__pyx_type_12loggerModule___pyx_scope_struct_1_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 428, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_12loggerModule___pyx_scope_struct_1_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_loggerModule(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_loggerModule}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, Py_MOD_GIL_USED}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "loggerModule", + __pyx_k_CLI_Logger_logging_DEBUG_loggin, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit_loggerModule(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_loggerModule(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_loggerModule(PyObject *__pyx_pyinit_module) +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'loggerModule' has already been imported. Re-initialisation is not supported."); + return -1; + } + #else + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "loggerModule" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + +__Pyx_RefNannySetupContext("PyInit_loggerModule", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED) + if (__pyx_CommonTypesMetaclass_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + if (__pyx_module_is_main_loggerModule) { + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "loggerModule")) { + if (unlikely((PyDict_SetItemString(modules, "loggerModule", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + (void)__Pyx_modinit_function_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_import_code(__pyx_mstate); + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + (void)__Pyx_modinit_function_import_code(__pyx_mstate); + /*--- Execution code ---*/ + + /* "loggerModule.py":28 + * ``` + * """ + * import re # <<<<<<<<<<<<<< + * import logging + * from logging.handlers import TimedRotatingFileHandler +*/ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_re, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_re, __pyx_t_2) < 0) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":29 + * """ + * import re + * import logging # <<<<<<<<<<<<<< + * from logging.handlers import TimedRotatingFileHandler + * import os +*/ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_logging, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_logging, __pyx_t_2) < 0) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":30 + * import re + * import logging + * from logging.handlers import TimedRotatingFileHandler # <<<<<<<<<<<<<< + * import os + * import time +*/ + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_TimedRotatingFileHandler); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_logging_handlers, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_TimedRotatingFileHandler); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TimedRotatingFileHandler, __pyx_t_2) < 0) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":31 + * import logging + * from logging.handlers import TimedRotatingFileHandler + * import os # <<<<<<<<<<<<<< + * import time + * import threading +*/ + __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_os, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_os, __pyx_t_3) < 0) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":32 + * from logging.handlers import TimedRotatingFileHandler + * import os + * import time # <<<<<<<<<<<<<< + * import threading + * from datetime import datetime, timedelta +*/ + __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_time, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_time, __pyx_t_3) < 0) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":33 + * import os + * import time + * import threading # <<<<<<<<<<<<<< + * from datetime import datetime, timedelta + * from pathlib import Path +*/ + __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_threading, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_3) < 0) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":34 + * import time + * import threading + * from datetime import datetime, timedelta # <<<<<<<<<<<<<< + * from pathlib import Path + * import traceback +*/ + __pyx_t_3 = __Pyx_PyList_Pack(2, __pyx_mstate_global->__pyx_n_u_datetime, __pyx_mstate_global->__pyx_n_u_timedelta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_datetime, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_datetime, __pyx_t_3) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_timedelta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_timedelta, __pyx_t_3) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":35 + * import threading + * from datetime import datetime, timedelta + * from pathlib import Path # <<<<<<<<<<<<<< + * import traceback + * +*/ + __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_pathlib, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Path, __pyx_t_2) < 0) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":36 + * from datetime import datetime, timedelta + * from pathlib import Path + * import traceback # <<<<<<<<<<<<<< + * + * # ( ) +*/ + __pyx_t_3 = __Pyx_ImportDottedModule(__pyx_mstate_global->__pyx_n_u_traceback, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_traceback, __pyx_t_3) < 0) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":39 + * + * # ( ) + * def get_level_name(level): # <<<<<<<<<<<<<< + * """ ( )""" + * level_names = { +*/ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_1get_level_name, 0, __pyx_mstate_global->__pyx_n_u_get_level_name, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_level_name, __pyx_t_3) < 0) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":52 + * + * + * class WindowsSafeRotatingFileHandler(logging.Handler): # <<<<<<<<<<<<<< + * """ + * Windows +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Handler); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_2, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_2, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_kp_u_Windows_RotatingFileHandler_Win); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2 != __pyx_t_3) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_3) < 0))) __PYX_ERR(0, 52, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "loggerModule.py":64 + * """ + * + * def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): # <<<<<<<<<<<<<< + * super().__init__() + * self.baseFilename = os.path.abspath(filename) +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_1__init__, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_3, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + PyList_Append(__pyx_t_3, __pyx_t_6); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[3]); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_6) < 0) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":74 + * self._open_file() + * + * def _open_file(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_3_open_file, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_4, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_open_file, __pyx_t_6) < 0) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":86 + * self.stream = None + * + * def _close_file(self): # <<<<<<<<<<<<<< + * """ """ + * if self.stream: +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_5_close_file, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_5, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_close_file, __pyx_t_6) < 0) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":96 + * self.stream = None + * + * def _should_rollover(self): # <<<<<<<<<<<<<< + * """ """ + * if self.stream is None: +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_7_should_rollover, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_6, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_should_rollover, __pyx_t_6) < 0) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":108 + * return False + * + * def _do_rollover(self): # <<<<<<<<<<<<<< + * """ - Windows """ + * self._close_file() +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_9_do_rollover, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_7, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_do_rollover, __pyx_t_6) < 0) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":143 + * self._open_file() + * + * def _cleanup_old_backups(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_11_cleanup_old_backups, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_8, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_cleanup_old_backups, __pyx_t_6) < 0) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":171 + * pass + * + * def emit(self, record): # <<<<<<<<<<<<<< + * """ """ + * with self._lock: +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_13emit, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_e, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_emit, __pyx_t_6) < 0) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":190 + * self.handleError(record) + * + * def close(self): # <<<<<<<<<<<<<< + * """ """ + * with self._lock: +*/ + __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_30WindowsSafeRotatingFileHandler_15close, 0, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_c, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + PyList_Append(__pyx_t_3, __pyx_t_6); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_close, __pyx_t_6) < 0) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "loggerModule.py":52 + * + * + * class WindowsSafeRotatingFileHandler(logging.Handler): # <<<<<<<<<<<<<< + * """ + * Windows +*/ + __pyx_t_6 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_2, __pyx_t_2, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_CyFunction_InitClassCell(__pyx_t_3, __pyx_t_6) < 0) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WindowsSafeRotatingFileHandler_2, __pyx_t_6) < 0) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":196 + * super().close() + * + * class Logger: # <<<<<<<<<<<<<< + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", +*/ + __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_mstate_global->__pyx_empty_tuple, __pyx_mstate_global->__pyx_n_u_Logger_3, __pyx_mstate_global->__pyx_n_u_Logger_3, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "loggerModule.py":198 + * class Logger: + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", # <<<<<<<<<<<<<< + * file_log_level=logging.DEBUG, gui_log_level=logging.INFO, + * max_days=3, cleanup_interval=3600): +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_1__init__, 0, __pyx_mstate_global->__pyx_n_u_Logger___init, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_12loggerModule___pyx_defaults)) __PYX_ERR(0, 198, __pyx_L1_error) + + /* "loggerModule.py":199 + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", + * file_log_level=logging.DEBUG, gui_log_level=logging.INFO, # <<<<<<<<<<<<<< + * max_days=3, cleanup_interval=3600): + * """ +*/ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DEBUG); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_4)->arg0 = __pyx_t_6; + __Pyx_GIVEREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_INFO); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_4)->arg1 = __pyx_t_5; + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_12loggerModule_18__defaults__); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_4) < 0) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":271 + * self._start_cleanup_thread() + * + * def _add_console_handler(self, level): # <<<<<<<<<<<<<< + * """ """ + * console_handler = logging.StreamHandler() +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_3_add_console_handler, 0, __pyx_mstate_global->__pyx_n_u_Logger__add_console_handler, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_add_console_handler, __pyx_t_4) < 0) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":281 + * self.logger.addHandler(console_handler) + * + * def _add_file_handler(self, log_file, level): # <<<<<<<<<<<<<< + * """ + (Windows )""" + * # .log .log +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_5_add_file_handler, 0, __pyx_mstate_global->__pyx_n_u_Logger__add_file_handler, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_add_file_handler, __pyx_t_4) < 0) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":307 + * self.file_handler = file_handler + * + * def _start_cleanup_thread(self): # <<<<<<<<<<<<<< + * """ """ + * def cleanup_worker(): +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_7_start_cleanup_thread, 0, __pyx_mstate_global->__pyx_n_u_Logger__start_cleanup_thread, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_start_cleanup_thread, __pyx_t_4) < 0) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":321 + * cleanup_thread.start() + * + * def _cleanup_old_logs(self): # <<<<<<<<<<<<<< + * """ (> max_days) 10 """ + * cutoff_date = datetime.now() - timedelta(days=self.max_days) +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_9_cleanup_old_logs, 0, __pyx_mstate_global->__pyx_n_u_Logger__cleanup_old_logs, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_cleanup_old_logs, __pyx_t_4) < 0) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":361 + * pass + * + * def log(self, message, level=logging.INFO, exc_info=False): # <<<<<<<<<<<<<< + * """ """ + * if exc_info: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_11log, 0, __pyx_mstate_global->__pyx_n_u_Logger_log, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_12loggerModule___pyx_defaults1)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_INFO); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_t_4)->arg0 = __pyx_t_6; + __Pyx_GIVEREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_12loggerModule_20__defaults__); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_log_4, __pyx_t_4) < 0) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":390 + * pass + * + * def set_gui_logger(self, gui_logger, gui_log_level=None): # <<<<<<<<<<<<<< + * """ + * . +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_13set_gui_logger, 0, __pyx_mstate_global->__pyx_n_u_Logger_set_gui_logger, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[4]); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_gui_logger, __pyx_t_4) < 0) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":400 + * self.gui_log_level = gui_log_level + * + * def set_gui_log_level(self, level): # <<<<<<<<<<<<<< + * """ """ + * self.gui_log_level = level +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_15set_gui_log_level, 0, __pyx_mstate_global->__pyx_n_u_Logger_set_gui_log_level, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_gui_log_level, __pyx_t_4) < 0) __PYX_ERR(0, 400, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":406 + * self.logger.info(f" {level_name} ") + * + * def set_file_log_level(self, level): # <<<<<<<<<<<<<< + * """ """ + * self.file_log_level = level +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_17set_file_log_level, 0, __pyx_mstate_global->__pyx_n_u_Logger_set_file_log_level, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_file_log_level, __pyx_t_4) < 0) __PYX_ERR(0, 406, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":416 + * self.logger.info(f" {level_name} ") + * + * def get_log_levels(self): # <<<<<<<<<<<<<< + * """ """ + * return { +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_19get_log_levels, 0, __pyx_mstate_global->__pyx_n_u_Logger_get_log_levels, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_log_levels, __pyx_t_4) < 0) __PYX_ERR(0, 416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":424 + * } + * + * def get_log_info(self): # <<<<<<<<<<<<<< + * """ """ + * try: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_21get_log_info, 0, __pyx_mstate_global->__pyx_n_u_Logger_get_log_info, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_log_info, __pyx_t_4) < 0) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":440 + * return {"error": " "} + * + * def force_cleanup(self): # <<<<<<<<<<<<<< + * """ """ + * self._cleanup_old_logs() +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_23force_cleanup, 0, __pyx_mstate_global->__pyx_n_u_Logger_force_cleanup, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_force_cleanup, __pyx_t_4) < 0) __PYX_ERR(0, 440, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":445 + * + * # + * def debug(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """DEBUG """ + * if args: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_25debug, 0, __pyx_mstate_global->__pyx_n_u_Logger_debug, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 445, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_debug, __pyx_t_4) < 0) __PYX_ERR(0, 445, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":451 + * self.log(message, level=logging.DEBUG, exc_info=kwargs.get('exc_info', False)) + * + * def info(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """INFO """ + * if args: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_27info, 0, __pyx_mstate_global->__pyx_n_u_Logger_info, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_4) < 0) __PYX_ERR(0, 451, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":457 + * self.log(message, level=logging.INFO, exc_info=kwargs.get('exc_info', False)) + * + * def warning(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """WARNING """ + * if args: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_29warning, 0, __pyx_mstate_global->__pyx_n_u_Logger_warning, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_warning, __pyx_t_4) < 0) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":463 + * self.log(message, level=logging.WARNING, exc_info=kwargs.get('exc_info', False)) + * + * def error(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """ERROR """ + * if args: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_31error, 0, __pyx_mstate_global->__pyx_n_u_Logger_error, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_error, __pyx_t_4) < 0) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":469 + * self.log(message, level=logging.ERROR, exc_info=kwargs.get('exc_info', False)) + * + * def critical(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """CRITICAL """ + * if args: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_33critical, 0, __pyx_mstate_global->__pyx_n_u_Logger_critical, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_critical, __pyx_t_4) < 0) __PYX_ERR(0, 469, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":475 + * self.log(message, level=logging.CRITICAL, exc_info=kwargs.get('exc_info', False)) + * + * def exception(self, message, *args, **kwargs): # <<<<<<<<<<<<<< + * """ERROR """ + * if args: +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_6Logger_35exception, 0, __pyx_mstate_global->__pyx_n_u_Logger_exception, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_exception, __pyx_t_4) < 0) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "loggerModule.py":196 + * super().close() + * + * class Logger: # <<<<<<<<<<<<<< + * + * def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", +*/ + __pyx_t_4 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_mstate_global->__pyx_n_u_Logger_3, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Logger_3, __pyx_t_4) < 0) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":482 + * + * # + * _default_logger = None # <<<<<<<<<<<<<< + * + * def get_default_logger(): +*/ + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_default_logger, Py_None) < 0) __PYX_ERR(0, 482, __pyx_L1_error) + + /* "loggerModule.py":484 + * _default_logger = None + * + * def get_default_logger(): # <<<<<<<<<<<<<< + * """ """ + * global _default_logger +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_3get_default_logger, 0, __pyx_mstate_global->__pyx_n_u_get_default_logger, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_default_logger, __pyx_t_2) < 0) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":491 + * return _default_logger + * + * def set_default_logger(logger): # <<<<<<<<<<<<<< + * """ """ + * global _default_logger +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_5set_default_logger, 0, __pyx_mstate_global->__pyx_n_u_set_default_logger, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_set_default_logger, __pyx_t_2) < 0) __PYX_ERR(0, 491, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":497 + * + * # - + * def debug(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - DEBUG """ + * get_default_logger().debug(msg, *args, **kwargs) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_7debug, 0, __pyx_mstate_global->__pyx_n_u_debug, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_debug, __pyx_t_2) < 0) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":501 + * get_default_logger().debug(msg, *args, **kwargs) + * + * def info(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - INFO """ + * get_default_logger().info(msg, *args, **kwargs) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_9info, 0, __pyx_mstate_global->__pyx_n_u_info, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_2) < 0) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":505 + * get_default_logger().info(msg, *args, **kwargs) + * + * def warning(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - WARNING """ + * get_default_logger().warning(msg, *args, **kwargs) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_11warning, 0, __pyx_mstate_global->__pyx_n_u_warning, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_warning, __pyx_t_2) < 0) __PYX_ERR(0, 505, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":509 + * get_default_logger().warning(msg, *args, **kwargs) + * + * def error(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - ERROR """ + * get_default_logger().error(msg, *args, **kwargs) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_13error, 0, __pyx_mstate_global->__pyx_n_u_error, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_error, __pyx_t_2) < 0) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":513 + * get_default_logger().error(msg, *args, **kwargs) + * + * def critical(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - CRITICAL """ + * get_default_logger().critical(msg, *args, **kwargs) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_15critical, 0, __pyx_mstate_global->__pyx_n_u_critical, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_critical, __pyx_t_2) < 0) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":517 + * get_default_logger().critical(msg, *args, **kwargs) + * + * def exception(msg, *args, **kwargs): # <<<<<<<<<<<<<< + * """ - """ + * get_default_logger().exception(msg, *args, **kwargs) +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_17exception, 0, __pyx_mstate_global->__pyx_n_u_exception, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_exception, __pyx_t_2) < 0) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":523 + * + * # + * class StructuredLogger(Logger): # <<<<<<<<<<<<<< + * """JSON """ + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Logger_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_6, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_StructuredLogger, __pyx_mstate_global->__pyx_n_u_StructuredLogger, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_kp_u_JSON); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2 != __pyx_t_4) { + if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 523, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "loggerModule.py":526 + * """JSON """ + * + * def __init__(self, *args, **kwargs): # <<<<<<<<<<<<<< + * super().__init__(*args, **kwargs) + * +*/ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_16StructuredLogger_1__init__, 0, __pyx_mstate_global->__pyx_n_u_StructuredLogger___init, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + PyList_Append(__pyx_t_4, __pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_3) < 0) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":529 + * super().__init__(*args, **kwargs) + * + * def log_structured(self, event, level=logging.INFO, **context): # <<<<<<<<<<<<<< + * """ """ + * import json +*/ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_16StructuredLogger_3log_structured, 0, __pyx_mstate_global->__pyx_n_u_StructuredLogger_log_structured, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_12loggerModule___pyx_defaults1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_logging); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_INFO); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_t_3)->arg0 = __pyx_t_8; + __Pyx_GIVEREF(__pyx_t_8); + __pyx_t_8 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_3, __pyx_pf_12loggerModule_22__defaults__); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log_structured, __pyx_t_3) < 0) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":543 + * self.log(message, level) + * + * def log_performance(self, operation, duration, **context): # <<<<<<<<<<<<<< + * """ """ + * self.log_structured( +*/ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_16StructuredLogger_5log_performance, 0, __pyx_mstate_global->__pyx_n_u_StructuredLogger_log_performance, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log_performance, __pyx_t_3) < 0) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":553 + * ) + * + * def log_error_with_context(self, error, **context): # <<<<<<<<<<<<<< + * """ """ + * self.log_structured( +*/ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_12loggerModule_16StructuredLogger_7log_error_with_context, 0, __pyx_mstate_global->__pyx_n_u_StructuredLogger_log_error_with, NULL, __pyx_mstate_global->__pyx_n_u_loggerModule, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 553, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log_error_with_context, __pyx_t_3) < 0) __PYX_ERR(0, 553, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "loggerModule.py":523 + * + * # + * class StructuredLogger(Logger): # <<<<<<<<<<<<<< + * """JSON """ + * +*/ + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_StructuredLogger, __pyx_t_2, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_CyFunction_InitClassCell(__pyx_t_4, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_StructuredLogger, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "loggerModule.py":1 + * """ # <<<<<<<<<<<<<< + * /CLI Logger - / + * +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init loggerModule", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init loggerModule"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ + +typedef struct { + const char *s; +#if 1115 <= 65535 + const unsigned short n; +#elif 1115 / 2 < INT_MAX + const unsigned int n; +#elif 1115 / 2 < LONG_MAX + const unsigned long n; +#else + const Py_ssize_t n; +#endif +#if 1 <= 31 + const unsigned int encoding : 5; +#elif 1 <= 255 + const unsigned char encoding; +#elif 1 <= 65535 + const unsigned short encoding; +#else + const Py_ssize_t encoding; +#endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; +} __Pyx_StringTabEntry; +static const char * const __pyx_string_tab_encodings[] = { 0 }; +static const __Pyx_StringTabEntry __pyx_string_tab[] = { + {__pyx_k_, sizeof(__pyx_k_), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_ */ + {__pyx_k_CRITICAL, sizeof(__pyx_k_CRITICAL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CRITICAL */ + {__pyx_k_DEBUG, sizeof(__pyx_k_DEBUG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DEBUG */ + {__pyx_k_ERROR, sizeof(__pyx_k_ERROR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ERROR */ + {__pyx_k_Edit_PartTimer_log, sizeof(__pyx_k_Edit_PartTimer_log), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Edit_PartTimer_log */ + {__pyx_k_Edit_PartTimer_log_log, sizeof(__pyx_k_Edit_PartTimer_log_log), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Edit_PartTimer_log_log */ + {__pyx_k_FileHandler, sizeof(__pyx_k_FileHandler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_FileHandler */ + {__pyx_k_Formatter, sizeof(__pyx_k_Formatter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Formatter */ + {__pyx_k_H_M_S, sizeof(__pyx_k_H_M_S), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_H_M_S */ + {__pyx_k_Handler, sizeof(__pyx_k_Handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Handler */ + {__pyx_k_INFO, sizeof(__pyx_k_INFO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_INFO */ + {__pyx_k_JSON, sizeof(__pyx_k_JSON), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_JSON */ + {__pyx_k_Level, sizeof(__pyx_k_Level), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Level */ + {__pyx_k_Lock, sizeof(__pyx_k_Lock), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Lock */ + {__pyx_k_Logger, sizeof(__pyx_k_Logger), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Logger */ + {__pyx_k_Logger_2, sizeof(__pyx_k_Logger_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Logger_2 */ + {__pyx_k_Logger_3, sizeof(__pyx_k_Logger_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_3 */ + {__pyx_k_Logger___init, sizeof(__pyx_k_Logger___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger___init */ + {__pyx_k_Logger__add_console_handler, sizeof(__pyx_k_Logger__add_console_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger__add_console_handler */ + {__pyx_k_Logger__add_file_handler, sizeof(__pyx_k_Logger__add_file_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger__add_file_handler */ + {__pyx_k_Logger__cleanup_old_logs, sizeof(__pyx_k_Logger__cleanup_old_logs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger__cleanup_old_logs */ + {__pyx_k_Logger__cleanup_old_logs_locals, sizeof(__pyx_k_Logger__cleanup_old_logs_locals), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger__cleanup_old_logs_locals */ + {__pyx_k_Logger__start_cleanup_thread, sizeof(__pyx_k_Logger__start_cleanup_thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger__start_cleanup_thread */ + {__pyx_k_Logger__start_cleanup_thread_loc, sizeof(__pyx_k_Logger__start_cleanup_thread_loc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger__start_cleanup_thread_loc */ + {__pyx_k_Logger_critical, sizeof(__pyx_k_Logger_critical), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_critical */ + {__pyx_k_Logger_debug, sizeof(__pyx_k_Logger_debug), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_debug */ + {__pyx_k_Logger_error, sizeof(__pyx_k_Logger_error), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_error */ + {__pyx_k_Logger_exception, sizeof(__pyx_k_Logger_exception), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_exception */ + {__pyx_k_Logger_force_cleanup, sizeof(__pyx_k_Logger_force_cleanup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_force_cleanup */ + {__pyx_k_Logger_get_log_info, sizeof(__pyx_k_Logger_get_log_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_get_log_info */ + {__pyx_k_Logger_get_log_info_locals_genex, sizeof(__pyx_k_Logger_get_log_info_locals_genex), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_get_log_info_locals_genex */ + {__pyx_k_Logger_get_log_levels, sizeof(__pyx_k_Logger_get_log_levels), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_get_log_levels */ + {__pyx_k_Logger_info, sizeof(__pyx_k_Logger_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_info */ + {__pyx_k_Logger_log, sizeof(__pyx_k_Logger_log), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_log */ + {__pyx_k_Logger_set_file_log_level, sizeof(__pyx_k_Logger_set_file_log_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_set_file_log_level */ + {__pyx_k_Logger_set_gui_log_level, sizeof(__pyx_k_Logger_set_gui_log_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_set_gui_log_level */ + {__pyx_k_Logger_set_gui_logger, sizeof(__pyx_k_Logger_set_gui_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_set_gui_logger */ + {__pyx_k_Logger_warning, sizeof(__pyx_k_Logger_warning), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Logger_warning */ + {__pyx_k_NOTSET, sizeof(__pyx_k_NOTSET), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NOTSET */ + {__pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OSError */ + {__pyx_k_Path, sizeof(__pyx_k_Path), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Path */ + {__pyx_k_StreamHandler, sizeof(__pyx_k_StreamHandler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_StreamHandler */ + {__pyx_k_StructuredLogger, sizeof(__pyx_k_StructuredLogger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_StructuredLogger */ + {__pyx_k_StructuredLogger___init, sizeof(__pyx_k_StructuredLogger___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_StructuredLogger___init */ + {__pyx_k_StructuredLogger_log_error_with, sizeof(__pyx_k_StructuredLogger_log_error_with), 0, 1, 1}, /* PyObject cname: __pyx_n_u_StructuredLogger_log_error_with */ + {__pyx_k_StructuredLogger_log_performance, sizeof(__pyx_k_StructuredLogger_log_performance), 0, 1, 1}, /* PyObject cname: __pyx_n_u_StructuredLogger_log_performance */ + {__pyx_k_StructuredLogger_log_structured, sizeof(__pyx_k_StructuredLogger_log_structured), 0, 1, 1}, /* PyObject cname: __pyx_n_u_StructuredLogger_log_structured */ + {__pyx_k_Thread, sizeof(__pyx_k_Thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Thread */ + {__pyx_k_TimedRotatingFileHandler, sizeof(__pyx_k_TimedRotatingFileHandler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TimedRotatingFileHandler */ + {__pyx_k_WARNING, sizeof(__pyx_k_WARNING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WARNING */ + {__pyx_k_WindowsSafeRotatingFileHandler, sizeof(__pyx_k_WindowsSafeRotatingFileHandler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler */ + {__pyx_k_WindowsSafeRotatingFileHandler_2, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_2 */ + {__pyx_k_WindowsSafeRotatingFileHandler_3, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_3 */ + {__pyx_k_WindowsSafeRotatingFileHandler_4, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_4), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_4 */ + {__pyx_k_WindowsSafeRotatingFileHandler_5, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_5), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_5 */ + {__pyx_k_WindowsSafeRotatingFileHandler_6, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_6), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_6 */ + {__pyx_k_WindowsSafeRotatingFileHandler_7, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_7), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_7 */ + {__pyx_k_WindowsSafeRotatingFileHandler_8, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_8), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_8 */ + {__pyx_k_WindowsSafeRotatingFileHandler_c, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_c), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_c */ + {__pyx_k_WindowsSafeRotatingFileHandler_e, sizeof(__pyx_k_WindowsSafeRotatingFileHandler_e), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WindowsSafeRotatingFileHandler_e */ + {__pyx_k_Windows_RotatingFileHandler_Win, sizeof(__pyx_k_Windows_RotatingFileHandler_Win), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Windows_RotatingFileHandler_Win */ + {__pyx_k_Y_m_d, sizeof(__pyx_k_Y_m_d), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Y_m_d */ + {__pyx_k_Y_m_d__H_M_S, sizeof(__pyx_k_Y_m_d__H_M_S), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Y_m_d__H_M_S */ + {__pyx_k__10, sizeof(__pyx_k__10), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__10 */ + {__pyx_k__11, sizeof(__pyx_k__11), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__11 */ + {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 1}, /* PyObject cname: __pyx_n_u__2 */ + {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */ + {__pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__4 */ + {__pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__5 */ + {__pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__6 */ + {__pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__7 */ + {__pyx_k__8, sizeof(__pyx_k__8), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__8 */ + {__pyx_k__9, sizeof(__pyx_k__9), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__9 */ + {__pyx_k_a, sizeof(__pyx_k_a), 0, 1, 1}, /* PyObject cname: __pyx_n_u_a */ + {__pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 1, 1}, /* PyObject cname: __pyx_n_u_abspath */ + {__pyx_k_actual_log_file, sizeof(__pyx_k_actual_log_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_actual_log_file */ + {__pyx_k_addHandler, sizeof(__pyx_k_addHandler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_addHandler */ + {__pyx_k_add_console_handler, sizeof(__pyx_k_add_console_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_add_console_handler */ + {__pyx_k_add_file_handler, sizeof(__pyx_k_add_file_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_add_file_handler */ + {__pyx_k_append, sizeof(__pyx_k_append), 0, 1, 1}, /* PyObject cname: __pyx_n_u_append */ + {__pyx_k_args, sizeof(__pyx_k_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_args */ + {__pyx_k_asctime_s_levelname_s_message_s, sizeof(__pyx_k_asctime_s_levelname_s_message_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_asctime_s_levelname_s_message_s */ + {__pyx_k_asctime_s_message_s, sizeof(__pyx_k_asctime_s_message_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_asctime_s_message_s */ + {__pyx_k_asctime_s_threadName_s_levelnam, sizeof(__pyx_k_asctime_s_threadName_s_levelnam), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_asctime_s_threadName_s_levelnam */ + {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */ + {__pyx_k_backupCount, sizeof(__pyx_k_backupCount), 0, 1, 1}, /* PyObject cname: __pyx_n_u_backupCount */ + {__pyx_k_backup_files, sizeof(__pyx_k_backup_files), 0, 1, 1}, /* PyObject cname: __pyx_n_u_backup_files */ + {__pyx_k_backup_name, sizeof(__pyx_k_backup_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_backup_name */ + {__pyx_k_base, sizeof(__pyx_k_base), 0, 1, 1}, /* PyObject cname: __pyx_n_u_base */ + {__pyx_k_baseFilename, sizeof(__pyx_k_baseFilename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_baseFilename */ + {__pyx_k_base_dir, sizeof(__pyx_k_base_dir), 0, 1, 1}, /* PyObject cname: __pyx_n_u_base_dir */ + {__pyx_k_base_name, sizeof(__pyx_k_base_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_base_name */ + {__pyx_k_basename, sizeof(__pyx_k_basename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_basename */ + {__pyx_k_by_day, sizeof(__pyx_k_by_day), 0, 1, 1}, /* PyObject cname: __pyx_n_u_by_day */ + {__pyx_k_caller_frame, sizeof(__pyx_k_caller_frame), 0, 1, 1}, /* PyObject cname: __pyx_n_u_caller_frame */ + {__pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_class_getitem */ + {__pyx_k_cleanup_interval, sizeof(__pyx_k_cleanup_interval), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cleanup_interval */ + {__pyx_k_cleanup_old_backups, sizeof(__pyx_k_cleanup_old_backups), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cleanup_old_backups */ + {__pyx_k_cleanup_old_logs, sizeof(__pyx_k_cleanup_old_logs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cleanup_old_logs */ + {__pyx_k_cleanup_thread, sizeof(__pyx_k_cleanup_thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cleanup_thread */ + {__pyx_k_cleanup_worker, sizeof(__pyx_k_cleanup_worker), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cleanup_worker */ + {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */ + {__pyx_k_close, sizeof(__pyx_k_close), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close */ + {__pyx_k_close_file, sizeof(__pyx_k_close_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close_file */ + {__pyx_k_co_filename, sizeof(__pyx_k_co_filename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_co_filename */ + {__pyx_k_co_name, sizeof(__pyx_k_co_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_co_name */ + {__pyx_k_collections, sizeof(__pyx_k_collections), 0, 1, 1}, /* PyObject cname: __pyx_n_u_collections */ + {__pyx_k_console_handler, sizeof(__pyx_k_console_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_console_handler */ + {__pyx_k_context, sizeof(__pyx_k_context), 0, 1, 1}, /* PyObject cname: __pyx_n_u_context */ + {__pyx_k_copy2, sizeof(__pyx_k_copy2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_copy2 */ + {__pyx_k_critical, sizeof(__pyx_k_critical), 0, 1, 1}, /* PyObject cname: __pyx_n_u_critical */ + {__pyx_k_currentframe, sizeof(__pyx_k_currentframe), 0, 1, 1}, /* PyObject cname: __pyx_n_u_currentframe */ + {__pyx_k_cutoff_date, sizeof(__pyx_k_cutoff_date), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cutoff_date */ + {__pyx_k_daemon, sizeof(__pyx_k_daemon), 0, 1, 1}, /* PyObject cname: __pyx_n_u_daemon */ + {__pyx_k_datefmt, sizeof(__pyx_k_datefmt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_datefmt */ + {__pyx_k_datetime, sizeof(__pyx_k_datetime), 0, 1, 1}, /* PyObject cname: __pyx_n_u_datetime */ + {__pyx_k_day_key, sizeof(__pyx_k_day_key), 0, 1, 1}, /* PyObject cname: __pyx_n_u_day_key */ + {__pyx_k_days, sizeof(__pyx_k_days), 0, 1, 1}, /* PyObject cname: __pyx_n_u_days */ + {__pyx_k_debug, sizeof(__pyx_k_debug), 0, 1, 1}, /* PyObject cname: __pyx_n_u_debug */ + {__pyx_k_default_logger, sizeof(__pyx_k_default_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_default_logger */ + {__pyx_k_defaultdict, sizeof(__pyx_k_defaultdict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_defaultdict */ + {__pyx_k_detailed_format, sizeof(__pyx_k_detailed_format), 0, 1, 1}, /* PyObject cname: __pyx_n_u_detailed_format */ + {__pyx_k_dirname, sizeof(__pyx_k_dirname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dirname */ + {__pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_disable */ + {__pyx_k_do_rollover, sizeof(__pyx_k_do_rollover), 0, 1, 1}, /* PyObject cname: __pyx_n_u_do_rollover */ + {__pyx_k_doc, sizeof(__pyx_k_doc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_doc */ + {__pyx_k_dumps, sizeof(__pyx_k_dumps), 0, 1, 1}, /* PyObject cname: __pyx_n_u_dumps */ + {__pyx_k_duration, sizeof(__pyx_k_duration), 0, 1, 1}, /* PyObject cname: __pyx_n_u_duration */ + {__pyx_k_duration_ms, sizeof(__pyx_k_duration_ms), 0, 1, 1}, /* PyObject cname: __pyx_n_u_duration_ms */ + {__pyx_k_e, sizeof(__pyx_k_e), 0, 1, 1}, /* PyObject cname: __pyx_n_u_e */ + {__pyx_k_emit, sizeof(__pyx_k_emit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_emit */ + {__pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_enable */ + {__pyx_k_encoding, sizeof(__pyx_k_encoding), 0, 1, 1}, /* PyObject cname: __pyx_n_u_encoding */ + {__pyx_k_endswith, sizeof(__pyx_k_endswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_endswith */ + {__pyx_k_ensure_ascii, sizeof(__pyx_k_ensure_ascii), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ensure_ascii */ + {__pyx_k_enter, sizeof(__pyx_k_enter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enter */ + {__pyx_k_error, sizeof(__pyx_k_error), 0, 1, 1}, /* PyObject cname: __pyx_n_u_error */ + {__pyx_k_error_message, sizeof(__pyx_k_error_message), 0, 1, 1}, /* PyObject cname: __pyx_n_u_error_message */ + {__pyx_k_error_type, sizeof(__pyx_k_error_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_error_type */ + {__pyx_k_event, sizeof(__pyx_k_event), 0, 1, 1}, /* PyObject cname: __pyx_n_u_event */ + {__pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exc_info */ + {__pyx_k_exception, sizeof(__pyx_k_exception), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exception */ + {__pyx_k_exist_ok, sizeof(__pyx_k_exist_ok), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exist_ok */ + {__pyx_k_exists, sizeof(__pyx_k_exists), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exists */ + {__pyx_k_exit, sizeof(__pyx_k_exit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exit */ + {__pyx_k_ext, sizeof(__pyx_k_ext), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ext */ + {__pyx_k_f, sizeof(__pyx_k_f), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f */ + {__pyx_k_f_back, sizeof(__pyx_k_f_back), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f_back */ + {__pyx_k_f_code, sizeof(__pyx_k_f_code), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f_code */ + {__pyx_k_f_lineno, sizeof(__pyx_k_f_lineno), 0, 1, 1}, /* PyObject cname: __pyx_n_u_f_lineno */ + {__pyx_k_file, sizeof(__pyx_k_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file */ + {__pyx_k_file_handler, sizeof(__pyx_k_file_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file_handler */ + {__pyx_k_file_level, sizeof(__pyx_k_file_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file_level */ + {__pyx_k_file_log_level, sizeof(__pyx_k_file_log_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file_log_level */ + {__pyx_k_file_mtime, sizeof(__pyx_k_file_mtime), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file_mtime */ + {__pyx_k_file_path, sizeof(__pyx_k_file_path), 0, 1, 1}, /* PyObject cname: __pyx_n_u_file_path */ + {__pyx_k_filename, sizeof(__pyx_k_filename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_filename */ + {__pyx_k_files, sizeof(__pyx_k_files), 0, 1, 1}, /* PyObject cname: __pyx_n_u_files */ + {__pyx_k_flush, sizeof(__pyx_k_flush), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flush */ + {__pyx_k_fmt, sizeof(__pyx_k_fmt), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fmt */ + {__pyx_k_force_cleanup, sizeof(__pyx_k_force_cleanup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_force_cleanup */ + {__pyx_k_format, sizeof(__pyx_k_format), 0, 1, 1}, /* PyObject cname: __pyx_n_u_format */ + {__pyx_k_format_exc, sizeof(__pyx_k_format_exc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_format_exc */ + {__pyx_k_formatted_message, sizeof(__pyx_k_formatted_message), 0, 1, 1}, /* PyObject cname: __pyx_n_u_formatted_message */ + {__pyx_k_formatter, sizeof(__pyx_k_formatter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_formatter */ + {__pyx_k_fromtimestamp, sizeof(__pyx_k_fromtimestamp), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fromtimestamp */ + {__pyx_k_full_path, sizeof(__pyx_k_full_path), 0, 1, 1}, /* PyObject cname: __pyx_n_u_full_path */ + {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */ + {__pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_gc */ + {__pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_genexpr */ + {__pyx_k_get, sizeof(__pyx_k_get), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get */ + {__pyx_k_getLogger, sizeof(__pyx_k_getLogger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getLogger */ + {__pyx_k_get_default_logger, sizeof(__pyx_k_get_default_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_default_logger */ + {__pyx_k_get_level_name, sizeof(__pyx_k_get_level_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_level_name */ + {__pyx_k_get_log_info, sizeof(__pyx_k_get_log_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_log_info */ + {__pyx_k_get_log_levels, sizeof(__pyx_k_get_log_levels), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_log_levels */ + {__pyx_k_getmtime, sizeof(__pyx_k_getmtime), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getmtime */ + {__pyx_k_getpid, sizeof(__pyx_k_getpid), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getpid */ + {__pyx_k_glob, sizeof(__pyx_k_glob), 0, 1, 1}, /* PyObject cname: __pyx_n_u_glob */ + {__pyx_k_gui_formatter, sizeof(__pyx_k_gui_formatter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gui_formatter */ + {__pyx_k_gui_level, sizeof(__pyx_k_gui_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gui_level */ + {__pyx_k_gui_log_level, sizeof(__pyx_k_gui_log_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gui_log_level */ + {__pyx_k_gui_logger, sizeof(__pyx_k_gui_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_gui_logger */ + {__pyx_k_handle, sizeof(__pyx_k_handle), 0, 1, 1}, /* PyObject cname: __pyx_n_u_handle */ + {__pyx_k_handleError, sizeof(__pyx_k_handleError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_handleError */ + {__pyx_k_handler, sizeof(__pyx_k_handler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_handler */ + {__pyx_k_handlers, sizeof(__pyx_k_handlers), 0, 1, 1}, /* PyObject cname: __pyx_n_u_handlers */ + {__pyx_k_info, sizeof(__pyx_k_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_info */ + {__pyx_k_init, sizeof(__pyx_k_init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init */ + {__pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_initializing */ + {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */ + {__pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_isenabled */ + {__pyx_k_isoformat, sizeof(__pyx_k_isoformat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_isoformat */ + {__pyx_k_items, sizeof(__pyx_k_items), 0, 1, 1}, /* PyObject cname: __pyx_n_u_items */ + {__pyx_k_join, sizeof(__pyx_k_join), 0, 1, 1}, /* PyObject cname: __pyx_n_u_join */ + {__pyx_k_json, sizeof(__pyx_k_json), 0, 1, 1}, /* PyObject cname: __pyx_n_u_json */ + {__pyx_k_key, sizeof(__pyx_k_key), 0, 1, 1}, /* PyObject cname: __pyx_n_u_key */ + {__pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kwargs */ + {__pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lambda */ + {__pyx_k_level, sizeof(__pyx_k_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_level */ + {__pyx_k_level_name, sizeof(__pyx_k_level_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_level_name */ + {__pyx_k_level_names, sizeof(__pyx_k_level_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_level_names */ + {__pyx_k_listdir, sizeof(__pyx_k_listdir), 0, 1, 1}, /* PyObject cname: __pyx_n_u_listdir */ + {__pyx_k_lock, sizeof(__pyx_k_lock), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lock */ + {__pyx_k_log, sizeof(__pyx_k_log), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_log */ + {__pyx_k_log_2, sizeof(__pyx_k_log_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_log_2 */ + {__pyx_k_log_3, sizeof(__pyx_k_log_3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_log_3 */ + {__pyx_k_log_4, sizeof(__pyx_k_log_4), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_4 */ + {__pyx_k_log_base_name, sizeof(__pyx_k_log_base_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_base_name */ + {__pyx_k_log_data, sizeof(__pyx_k_log_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_data */ + {__pyx_k_log_dir, sizeof(__pyx_k_log_dir), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_dir */ + {__pyx_k_log_error_with_context, sizeof(__pyx_k_log_error_with_context), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_error_with_context */ + {__pyx_k_log_file, sizeof(__pyx_k_log_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_file */ + {__pyx_k_log_files, sizeof(__pyx_k_log_files), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_files */ + {__pyx_k_log_pattern, sizeof(__pyx_k_log_pattern), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_pattern */ + {__pyx_k_log_performance, sizeof(__pyx_k_log_performance), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_performance */ + {__pyx_k_log_structured, sizeof(__pyx_k_log_structured), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log_structured */ + {__pyx_k_logger, sizeof(__pyx_k_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_logger */ + {__pyx_k_loggerModule, sizeof(__pyx_k_loggerModule), 0, 1, 1}, /* PyObject cname: __pyx_n_u_loggerModule */ + {__pyx_k_loggerModule_py, sizeof(__pyx_k_loggerModule_py), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_loggerModule_py */ + {__pyx_k_logger_level, sizeof(__pyx_k_logger_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_logger_level */ + {__pyx_k_logger_name, sizeof(__pyx_k_logger_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_logger_name */ + {__pyx_k_logging, sizeof(__pyx_k_logging), 0, 1, 1}, /* PyObject cname: __pyx_n_u_logging */ + {__pyx_k_logging_handlers, sizeof(__pyx_k_logging_handlers), 0, 1, 1}, /* PyObject cname: __pyx_n_u_logging_handlers */ + {__pyx_k_logs_default_log, sizeof(__pyx_k_logs_default_log), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_logs_default_log */ + {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */ + {__pyx_k_makeRecord, sizeof(__pyx_k_makeRecord), 0, 1, 1}, /* PyObject cname: __pyx_n_u_makeRecord */ + {__pyx_k_makedirs, sizeof(__pyx_k_makedirs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_makedirs */ + {__pyx_k_maxBytes, sizeof(__pyx_k_maxBytes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxBytes */ + {__pyx_k_max_days, sizeof(__pyx_k_max_days), 0, 1, 1}, /* PyObject cname: __pyx_n_u_max_days */ + {__pyx_k_message, sizeof(__pyx_k_message), 0, 1, 1}, /* PyObject cname: __pyx_n_u_message */ + {__pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 1, 1}, /* PyObject cname: __pyx_n_u_metaclass */ + {__pyx_k_mkdir, sizeof(__pyx_k_mkdir), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mkdir */ + {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */ + {__pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mro_entries */ + {__pyx_k_msg, sizeof(__pyx_k_msg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_msg */ + {__pyx_k_mtime, sizeof(__pyx_k_mtime), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mtime */ + {__pyx_k_mtime_2, sizeof(__pyx_k_mtime_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mtime_2 */ + {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */ + {__pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name_2 */ + {__pyx_k_name_without_ext, sizeof(__pyx_k_name_without_ext), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name_without_ext */ + {__pyx_k_next, sizeof(__pyx_k_next), 0, 1, 1}, /* PyObject cname: __pyx_n_u_next */ + {__pyx_k_now, sizeof(__pyx_k_now), 0, 1, 1}, /* PyObject cname: __pyx_n_u_now */ + {__pyx_k_open, sizeof(__pyx_k_open), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open */ + {__pyx_k_open_file, sizeof(__pyx_k_open_file), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open_file */ + {__pyx_k_operation, sizeof(__pyx_k_operation), 0, 1, 1}, /* PyObject cname: __pyx_n_u_operation */ + {__pyx_k_os, sizeof(__pyx_k_os), 0, 1, 1}, /* PyObject cname: __pyx_n_u_os */ + {__pyx_k_parent, sizeof(__pyx_k_parent), 0, 1, 1}, /* PyObject cname: __pyx_n_u_parent */ + {__pyx_k_parents, sizeof(__pyx_k_parents), 0, 1, 1}, /* PyObject cname: __pyx_n_u_parents */ + {__pyx_k_path, sizeof(__pyx_k_path), 0, 1, 1}, /* PyObject cname: __pyx_n_u_path */ + {__pyx_k_pathlib, sizeof(__pyx_k_pathlib), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pathlib */ + {__pyx_k_performance, sizeof(__pyx_k_performance), 0, 1, 1}, /* PyObject cname: __pyx_n_u_performance */ + {__pyx_k_pid, sizeof(__pyx_k_pid), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pid */ + {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */ + {__pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prepare */ + {__pyx_k_print, sizeof(__pyx_k_print), 0, 1, 1}, /* PyObject cname: __pyx_n_u_print */ + {__pyx_k_propagate, sizeof(__pyx_k_propagate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_propagate */ + {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */ + {__pyx_k_re, sizeof(__pyx_k_re), 0, 1, 1}, /* PyObject cname: __pyx_n_u_re */ + {__pyx_k_record, sizeof(__pyx_k_record), 0, 1, 1}, /* PyObject cname: __pyx_n_u_record */ + {__pyx_k_remove, sizeof(__pyx_k_remove), 0, 1, 1}, /* PyObject cname: __pyx_n_u_remove */ + {__pyx_k_removeHandler, sizeof(__pyx_k_removeHandler), 0, 1, 1}, /* PyObject cname: __pyx_n_u_removeHandler */ + {__pyx_k_rename, sizeof(__pyx_k_rename), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rename */ + {__pyx_k_reverse, sizeof(__pyx_k_reverse), 0, 1, 1}, /* PyObject cname: __pyx_n_u_reverse */ + {__pyx_k_round, sizeof(__pyx_k_round), 0, 1, 1}, /* PyObject cname: __pyx_n_u_round */ + {__pyx_k_seek, sizeof(__pyx_k_seek), 0, 1, 1}, /* PyObject cname: __pyx_n_u_seek */ + {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */ + {__pyx_k_send, sizeof(__pyx_k_send), 0, 1, 1}, /* PyObject cname: __pyx_n_u_send */ + {__pyx_k_separators, sizeof(__pyx_k_separators), 0, 1, 1}, /* PyObject cname: __pyx_n_u_separators */ + {__pyx_k_setFormatter, sizeof(__pyx_k_setFormatter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setFormatter */ + {__pyx_k_setLevel, sizeof(__pyx_k_setLevel), 0, 1, 1}, /* PyObject cname: __pyx_n_u_setLevel */ + {__pyx_k_set_default_logger, sizeof(__pyx_k_set_default_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_default_logger */ + {__pyx_k_set_file_log_level, sizeof(__pyx_k_set_file_log_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_file_log_level */ + {__pyx_k_set_gui_log_level, sizeof(__pyx_k_set_gui_log_level), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_gui_log_level */ + {__pyx_k_set_gui_logger, sizeof(__pyx_k_set_gui_logger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_gui_logger */ + {__pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_name */ + {__pyx_k_should_rollover, sizeof(__pyx_k_should_rollover), 0, 1, 1}, /* PyObject cname: __pyx_n_u_should_rollover */ + {__pyx_k_shutil, sizeof(__pyx_k_shutil), 0, 1, 1}, /* PyObject cname: __pyx_n_u_shutil */ + {__pyx_k_simple_format, sizeof(__pyx_k_simple_format), 0, 1, 1}, /* PyObject cname: __pyx_n_u_simple_format */ + {__pyx_k_size, sizeof(__pyx_k_size), 0, 1, 1}, /* PyObject cname: __pyx_n_u_size */ + {__pyx_k_sleep, sizeof(__pyx_k_sleep), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sleep */ + {__pyx_k_sort, sizeof(__pyx_k_sort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sort */ + {__pyx_k_spec, sizeof(__pyx_k_spec), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spec */ + {__pyx_k_splitext, sizeof(__pyx_k_splitext), 0, 1, 1}, /* PyObject cname: __pyx_n_u_splitext */ + {__pyx_k_st_mtime, sizeof(__pyx_k_st_mtime), 0, 1, 1}, /* PyObject cname: __pyx_n_u_st_mtime */ + {__pyx_k_st_size, sizeof(__pyx_k_st_size), 0, 1, 1}, /* PyObject cname: __pyx_n_u_st_size */ + {__pyx_k_start, sizeof(__pyx_k_start), 0, 1, 1}, /* PyObject cname: __pyx_n_u_start */ + {__pyx_k_start_cleanup_thread, sizeof(__pyx_k_start_cleanup_thread), 0, 1, 1}, /* PyObject cname: __pyx_n_u_start_cleanup_thread */ + {__pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startswith */ + {__pyx_k_stat, sizeof(__pyx_k_stat), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stat */ + {__pyx_k_stderr, sizeof(__pyx_k_stderr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stderr */ + {__pyx_k_stem, sizeof(__pyx_k_stem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stem */ + {__pyx_k_stream, sizeof(__pyx_k_stream), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream */ + {__pyx_k_strftime, sizeof(__pyx_k_strftime), 0, 1, 1}, /* PyObject cname: __pyx_n_u_strftime */ + {__pyx_k_sum, sizeof(__pyx_k_sum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sum */ + {__pyx_k_super, sizeof(__pyx_k_super), 0, 1, 1}, /* PyObject cname: __pyx_n_u_super */ + {__pyx_k_sys, sizeof(__pyx_k_sys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sys */ + {__pyx_k_target, sizeof(__pyx_k_target), 0, 1, 1}, /* PyObject cname: __pyx_n_u_target */ + {__pyx_k_tell, sizeof(__pyx_k_tell), 0, 1, 1}, /* PyObject cname: __pyx_n_u_tell */ + {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */ + {__pyx_k_threading, sizeof(__pyx_k_threading), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading */ + {__pyx_k_throw, sizeof(__pyx_k_throw), 0, 1, 1}, /* PyObject cname: __pyx_n_u_throw */ + {__pyx_k_time, sizeof(__pyx_k_time), 0, 1, 1}, /* PyObject cname: __pyx_n_u_time */ + {__pyx_k_timedelta, sizeof(__pyx_k_timedelta), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timedelta */ + {__pyx_k_timestamp, sizeof(__pyx_k_timestamp), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timestamp */ + {__pyx_k_total_files, sizeof(__pyx_k_total_files), 0, 1, 1}, /* PyObject cname: __pyx_n_u_total_files */ + {__pyx_k_total_size, sizeof(__pyx_k_total_size), 0, 1, 1}, /* PyObject cname: __pyx_n_u_total_size */ + {__pyx_k_total_size_mb, sizeof(__pyx_k_total_size_mb), 0, 1, 1}, /* PyObject cname: __pyx_n_u_total_size_mb */ + {__pyx_k_traceback, sizeof(__pyx_k_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_traceback */ + {__pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 1, 1}, /* PyObject cname: __pyx_n_u_unlink */ + {__pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_utf_8 */ + {__pyx_k_value, sizeof(__pyx_k_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value */ + {__pyx_k_w, sizeof(__pyx_k_w), 0, 1, 1}, /* PyObject cname: __pyx_n_u_w */ + {__pyx_k_warning, sizeof(__pyx_k_warning), 0, 1, 1}, /* PyObject cname: __pyx_n_u_warning */ + {__pyx_k_write, sizeof(__pyx_k_write), 0, 1, 1}, /* PyObject cname: __pyx_n_u_write */ + {__pyx_k_x, sizeof(__pyx_k_x), 0, 1, 1}, /* PyObject cname: __pyx_n_u_x */ + {0, 0, 0, 0, 0} +}; +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); + +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_super = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_super); if (!__pyx_builtin_super) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_open); if (!__pyx_builtin_open) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_print); if (!__pyx_builtin_print) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_OSError); if (!__pyx_builtin_OSError) __PYX_ERR(0, 122, __pyx_L1_error) + __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_sum); if (!__pyx_builtin_sum) __PYX_ERR(0, 428, __pyx_L1_error) + __pyx_builtin_round = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_round); if (!__pyx_builtin_round) __PYX_ERR(0, 549, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "loggerModule.py":102 + * try: + * # + * self.stream.seek(0, 2) # # <<<<<<<<<<<<<< + * size = self.stream.tell() + * return size >= self.maxBytes +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + + /* "loggerModule.py":128 + * shutil.copy2(self.baseFilename, backup_name) + * # ( ) + * with open(self.baseFilename, 'w', encoding=self.encoding) as f: # <<<<<<<<<<<<<< + * pass + * except Exception: +*/ + __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + + /* "loggerModule.py":229 + * # + * if log_file.endswith('.log'): + * base_name = log_file[:-4] # <<<<<<<<<<<<<< + * ext = '.log' + * else: +*/ + __pyx_mstate_global->__pyx_slice[0] = PySlice_New(Py_None, __pyx_mstate_global->__pyx_int_neg_4, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[0])) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + + /* "loggerModule.py":251 + * + * # ( ) + * for handler in self.logger.handlers[:]: # <<<<<<<<<<<<<< + * self.logger.removeHandler(handler) + * +*/ + __pyx_mstate_global->__pyx_slice[1] = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[1])) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[1]); + + /* "loggerModule.py":354 + * # + * items.sort(key=lambda x: x[1], reverse=True) + * for (log_file, _mtime) in items[5:]: # <<<<<<<<<<<<<< + * try: + * if log_file.exists(): +*/ + __pyx_mstate_global->__pyx_slice[2] = PySlice_New(__pyx_mstate_global->__pyx_int_5, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[2])) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[2]); + + /* "loggerModule.py":540 + * } + * + * message = json.dumps(log_data, ensure_ascii=False, separators=(',', ':')) # <<<<<<<<<<<<<< + * self.log(message, level) + * +*/ + __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_kp_u__9, __pyx_mstate_global->__pyx_kp_u__10); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + + /* "loggerModule.py":64 + * """ + * + * def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): # <<<<<<<<<<<<<< + * super().__init__() + * self.baseFilename = os.path.abspath(filename) +*/ + __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(3, ((PyObject*)__pyx_mstate_global->__pyx_int_10485760), ((PyObject*)__pyx_mstate_global->__pyx_int_50), ((PyObject*)__pyx_mstate_global->__pyx_kp_u_utf_8)); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + + /* "loggerModule.py":390 + * pass + * + * def set_gui_logger(self, gui_logger, gui_log_level=None): # <<<<<<<<<<<<<< + * """ + * . +*/ + __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_mstate->__pyx_umethod_PyDict_Type_get.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_get.method_name = &__pyx_mstate->__pyx_n_u_get; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_2 = PyLong_FromLong(2); if (unlikely(!__pyx_mstate->__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_3 = PyLong_FromLong(3); if (unlikely(!__pyx_mstate->__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_5 = PyLong_FromLong(5); if (unlikely(!__pyx_mstate->__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_50 = PyLong_FromLong(50); if (unlikely(!__pyx_mstate->__pyx_int_50)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_1000 = PyLong_FromLong(1000); if (unlikely(!__pyx_mstate->__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_3600 = PyLong_FromLong(3600); if (unlikely(!__pyx_mstate->__pyx_int_3600)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_1048576 = PyLong_FromLong(1048576L); if (unlikely(!__pyx_mstate->__pyx_int_1048576)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_10485760 = PyLong_FromLong(10485760L); if (unlikely(!__pyx_mstate->__pyx_int_10485760)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_neg_4 = PyLong_FromLong(-4); if (unlikely(!__pyx_mstate->__pyx_int_neg_4)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +\ + typedef struct { + unsigned int argcount : 4; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 4; + unsigned int flags : 10; + unsigned int first_line : 10; + unsigned int line_table_length : 13; + } __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 162, 8}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_x}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_lambda, __pyx_k_AQa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 309, 34}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_e}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_cleanup_worker, __pyx_k_at1_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 353, 8}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_x}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_lambda, __pyx_k_Qaq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 428, 2}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_f}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_k_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 39, 64}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_level_names}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_get_level_name, __pyx_k_y_xq_wa_z_xq_d_7_Ja, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 64, 82}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_filename, __pyx_mstate->__pyx_n_u_maxBytes, __pyx_mstate->__pyx_n_u_backupCount, __pyx_mstate->__pyx_n_u_encoding}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_init, __pyx_k_88H_Ry_Be81A_L_O1_L_Ja_IYe1_Kq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 74, 90}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_e, __pyx_mstate->__pyx_n_u_sys}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_open_file, __pyx_k_A_iq_xq_IQ_at_y_A_A_4_DBe3a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 86, 40}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_close_file, __pyx_k_A_4q_G6_G6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 96, 64}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_size}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_should_rollover, __pyx_k_A_4xs_1_uAS_4we1_5_4q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 108, 182}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_timestamp, __pyx_mstate->__pyx_n_u_base, __pyx_mstate->__pyx_n_u_ext, __pyx_mstate->__pyx_n_u_backup_name, __pyx_mstate->__pyx_n_u_shutil, __pyx_mstate->__pyx_n_u_f, __pyx_mstate->__pyx_n_u_e, __pyx_mstate->__pyx_n_u_sys}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_do_rollover, __pyx_k_A_L_Biq_y_Q_D_r_gQd_gQd_fAT_oU_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 143, 192}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_base_dir, __pyx_mstate->__pyx_n_u_base_name, __pyx_mstate->__pyx_n_u_name_without_ext, __pyx_mstate->__pyx_n_u_ext, __pyx_mstate->__pyx_n_u_backup_files, __pyx_mstate->__pyx_n_u_f, __pyx_mstate->__pyx_n_u_full_path, __pyx_mstate->__pyx_n_u_mtime, __pyx_mstate->__pyx_n_u_file_path, __pyx_mstate->__pyx_n_u__2}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_cleanup_old_backups, __pyx_k_A_r_hat1_y_Q_fBe9AQ_1_Rxq_1Kq_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 171, 101}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_record, __pyx_mstate->__pyx_n_u_msg}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_emit, __pyx_k_A_4_Q_4xs_1_4q_gQa_vQd_A_vQ_L, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 190, 23}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_close, __pyx_k_A_A_RvQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 198, 333}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_gui_logger, __pyx_mstate->__pyx_n_u_log_file, __pyx_mstate->__pyx_n_u_logger_name, __pyx_mstate->__pyx_n_u_file_log_level, __pyx_mstate->__pyx_n_u_gui_log_level, __pyx_mstate->__pyx_n_u_max_days, __pyx_mstate->__pyx_n_u_cleanup_interval, __pyx_mstate->__pyx_n_u_pid, __pyx_mstate->__pyx_n_u_base_name, __pyx_mstate->__pyx_n_u_ext, __pyx_mstate->__pyx_n_u_handler}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_init, __pyx_k_K1_WA_Q_N_a_Q_L_Kt1IQ_T_1_HF_86, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 271, 67}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_console_handler, __pyx_mstate->__pyx_n_u_formatter}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_add_console_handler, __pyx_k_A_q_y_G_Q_F_WL_A_AQ_G_aq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 281, 137}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_log_file, __pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_base_name, __pyx_mstate->__pyx_n_u__2, __pyx_mstate->__pyx_n_u_file_handler, __pyx_mstate->__pyx_n_u_formatter}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_add_file_handler, __pyx_k_A_4xy_t2U_1A_z_1_5Q_q_Q_IQa_G_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 307, 32}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_cleanup_worker, __pyx_mstate->__pyx_n_u_cleanup_worker, __pyx_mstate->__pyx_n_u_cleanup_thread}; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_start_cleanup_thread, __pyx_k_A_1A_fA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 321, 262}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_cutoff_date, __pyx_mstate->__pyx_n_u_log_pattern, __pyx_mstate->__pyx_n_u_files, __pyx_mstate->__pyx_n_u_log_file, __pyx_mstate->__pyx_n_u_file_mtime, __pyx_mstate->__pyx_n_u_mtime, __pyx_mstate->__pyx_n_u_defaultdict, __pyx_mstate->__pyx_n_u_by_day, __pyx_mstate->__pyx_n_u_day_key, __pyx_mstate->__pyx_n_u_items, __pyx_mstate->__pyx_n_u_mtime_2}; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_cleanup_old_logs, __pyx_k_A_hd_Ry_d_b_D_L_HE_86_Bd_a_X_1HE, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 361, 173}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_exc_info, __pyx_mstate->__pyx_n_u_caller_frame, __pyx_mstate->__pyx_n_u_record, __pyx_mstate->__pyx_n_u_gui_formatter, __pyx_mstate->__pyx_n_u_formatted_message}; + __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_log_4, __pyx_k_q_1_b_Ky_1_wm2Q_WKq_wg_9F_G1_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 390, 31}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_gui_logger, __pyx_mstate->__pyx_n_u_gui_log_level}; + __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_set_gui_logger, __pyx_k_N, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 400, 34}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_level_name}; + __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_set_gui_log_level, __pyx_k_A_Q_1A_G5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 406, 80}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_handler, __pyx_mstate->__pyx_n_u_level_name}; + __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_set_file_log_level, __pyx_k_A_a_G9AQ_Kt7_z_G_y_1A_G5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 416, 40}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_get_log_levels, __pyx_k_A_Q_q_A_N_4wa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 424, 101}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_log_files, __pyx_mstate->__pyx_n_u_total_size, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_f}; + __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_get_log_info, __pyx_k_A_AT_ar_T_IQ_3at1_s_1_HA_D_6_U_I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 440, 10}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_force_cleanup, __pyx_k_A_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 445, 43}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_debug, __pyx_k_A_1_hb_D_xy_d_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 451, 43}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_info, __pyx_k_A_1_hb_D_wivT_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 457, 44}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_warning, __pyx_k_A_1_hb_D_z_A_QR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 463, 43}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_error, __pyx_k_A_1_hb_D_xy_d_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 469, 44}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_critical, __pyx_k_A_1_hb_D_6_QlRS, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 475, 35}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_message, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_exception, __pyx_k_A_1_hb_D_xy, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 0, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 484, 31}; + PyObject* const varnames[] = {0}; + __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_get_default_logger, __pyx_k_s_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 491, 10}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_logger}; + __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_set_default_logger, __pyx_k_a_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 497, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_debug, __pyx_k_b_avXQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 501, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_info, __pyx_k_b_QfHA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 505, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_warning, __pyx_k_b_xq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 509, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_error, __pyx_k_b_avXQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 513, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_critical, __pyx_k_b, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 517, 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_exception, __pyx_k_b_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 526, 15}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs}; + __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_Ry, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 529, 79}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_event, __pyx_mstate->__pyx_n_u_level, __pyx_mstate->__pyx_n_u_context, __pyx_mstate->__pyx_n_u_json, __pyx_mstate->__pyx_n_u_log_data, __pyx_mstate->__pyx_n_u_message}; + __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_log_structured, __pyx_k_1_Rz_Q_1A_fAZ_G_uA_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 543, 42}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_operation, __pyx_mstate->__pyx_n_u_duration, __pyx_mstate->__pyx_n_u_context}; + __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_log_performance, __pyx_k_A_O1_a_Qir_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 553, 42}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_error, __pyx_mstate->__pyx_n_u_context}; + __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_loggerModule_py, __pyx_mstate->__pyx_n_u_log_error_with_context, __pyx_k_A_O1_t1F_Qa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* TupleAndListFromArray */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; irecursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; + PyObject *kwdefs; + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + if ( + co->co_kwonlyargcount == 0 && + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); + kwdefs = PyFunction_GET_KW_DEFAULTS(func); + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, _nargs, NULL); + } + #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL + return PyObject_Vectorcall(func, args, _nargs, NULL); + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* UnpackUnboundCMethod */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywords */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + Py_ssize_t pos = 0; + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while (PyDict_Next(kwds, &pos, &key, NULL)) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); + #endif + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + } + __Pyx_END_CRITICAL_SECTION(); + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyObjectCall2Args */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* CallUnboundCMethod1 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + int flag = cfunc->flag; + if (flag == METH_O) { + return __Pyx_CallCFunction(cfunc, self, arg); + } else if (flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, &arg, 1); + } else if (flag == (METH_FASTCALL | METH_KEYWORDS)) { + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, &arg, 1, NULL); + } + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod1(&tmp_cfunc, self, arg); + } +#endif + PyObject* result = __Pyx__CallUnboundCMethod1(cfunc, self, arg); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ + PyObject *result = NULL; + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + } else +#endif + { + result = __Pyx_PyObject_Call2Args(cfunc->method, self, arg); + } + return result; +} + +/* dict_getitem_default */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); + if ((1)); +#else + if (PyBytes_CheckExact(key) || PyUnicode_CheckExact(key) || PyLong_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } +#endif + else { + if (default_value == Py_None) + value = __Pyx_CallUnboundCMethod1(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_get, d, key); + else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_get, d, key, default_value); + } + return value; +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* PyObjectSetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); + return PyObject_SetAttr(obj, attr_name, value); +} +#endif + +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (level == -1) { + const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); + if (package_sep != (0)) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level); + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + return module; +} + +/* ImportDottedModule */ +static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { + PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; + Py_ssize_t size; + if (unlikely(PyErr_Occurred())) { + PyErr_Clear(); + } +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(parts_tuple); +#else + size = PyTuple_Size(parts_tuple); + if (size < 0) goto bad; +#endif + if (likely(size == count)) { + partial_name = name; + } else { + slice = PySequence_GetSlice(parts_tuple, 0, count); + if (unlikely(!slice)) + goto bad; + sep = PyUnicode_FromStringAndSize(".", 1); + if (unlikely(!sep)) + goto bad; + partial_name = PyUnicode_Join(sep, slice); + } + PyErr_Format( + PyExc_ModuleNotFoundError, + "No module named '%U'", partial_name); +bad: + Py_XDECREF(sep); + Py_XDECREF(slice); + Py_XDECREF(partial_name); + return NULL; +} +static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { + PyObject *imported_module; +#if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + return NULL; + imported_module = __Pyx_PyDict_GetItemStr(modules, name); + Py_XINCREF(imported_module); +#else + imported_module = PyImport_GetModule(name); +#endif + return imported_module; +} +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { + Py_ssize_t i, nparts; +#if CYTHON_ASSUME_SAFE_SIZE + nparts = PyTuple_GET_SIZE(parts_tuple); +#else + nparts = PyTuple_Size(parts_tuple); + if (nparts < 0) return NULL; +#endif + for (i=1; i < nparts && module; i++) { + PyObject *part, *submodule; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + part = PyTuple_GET_ITEM(parts_tuple, i); +#else + part = __Pyx_PySequence_ITEM(parts_tuple, i); + if (!part) return NULL; +#endif + submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(part); +#endif + Py_DECREF(module); + module = submodule; + } + if (unlikely(!module)) { + return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); + } + return module; +} +static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { + PyObject *imported_module; + PyObject *module = __Pyx_Import(name, NULL, 0); + if (!parts_tuple || unlikely(!module)) + return module; + imported_module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(imported_module)) { + Py_DECREF(module); + return imported_module; + } + PyErr_Clear(); + return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); +} +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *module = __Pyx__ImportDottedModule_Lookup(name); + if (likely(module)) { + PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_mstate_global->__pyx_n_u_spec); + if (likely(spec)) { + PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_mstate_global->__pyx_n_u_initializing); + if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { + Py_DECREF(spec); + spec = NULL; + } + Py_XDECREF(unsafe); + } + if (likely(!spec)) { + PyErr_Clear(); + return module; + } + Py_DECREF(spec); + Py_DECREF(module); + } else if (PyErr_Occurred()) { + PyErr_Clear(); + } +#endif + return __Pyx__ImportDottedModule(name, parts_tuple); +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; + } + return 0; +} + +/* UnpackItemEndCheck */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } + return __Pyx_IterFinish(); +} + +/* PyObjectLookupSpecial */ +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) { + PyObject *res; + PyTypeObject *tp = Py_TYPE(obj); + res = _PyType_Lookup(tp, attr_name); + if (likely(res)) { + descrgetfunc f = Py_TYPE(res)->tp_descr_get; + if (!f) { + Py_INCREF(res); + } else { + res = f(res, obj, (PyObject *)tp); + } + } else if (with_error) { + PyErr_SetObject(PyExc_AttributeError, attr_name); + } + return res; +} +#endif + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!j)) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_PyList_GetItemRef(o, n); + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} + +/* LimitedApiGetTypeDict */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + +/* SetItemOnTypeDict */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +/* FixUpExtensionType */ +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif // CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + } + memb++; + } + } +#endif // !CYTHON_COMPILING_IN_LIMITED_API + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; +} + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/* dict_setdefault */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, + int is_safe_type) { + PyObject* value; + CYTHON_MAYBE_UNUSED_VAR(is_safe_type); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* FetchCommonType */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); +#else + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromMetaclass(metaclass, abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CommonTypesMetaclass */ +PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | +#endif + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} + +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* PyMethodNew */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + Py_INCREF(key); + Py_INCREF(value); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_dict_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); + } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif +} +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +/* PyObjectVectorCallMethodKwBuilder */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + PyObject *result; + PyObject *obj = PyObject_GetAttr(args[0], name); + if (unlikely(!obj)) + return NULL; + result = __Pyx_Object_Vectorcall_CallFromBuilder(obj, args+1, nargsf-1, kwnames); + Py_DECREF(obj); + return result; +} +#endif + +/* SliceTupleAndList */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) { + Py_ssize_t start = *_start, stop = *_stop, length = *_length; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + else if (stop > length) + stop = length; + *_length = stop - start; + *_start = start; + *_stop = stop; +} +static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length = PyTuple_GET_SIZE(src); + __Pyx_crop_slice(&start, &stop, &length); + return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length); +} +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice_locked( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length = PyList_GET_SIZE(src); + __Pyx_crop_slice(&start, &stop, &length); + if (length <= 0) { + return PyList_New(0); + } + return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length); +} +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(src); + result = __Pyx_PyList_GetSlice_locked(src, start, stop); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +#endif // CYTHON_COMPILING_IN_CPYTHON + +/* SliceObject */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { + __Pyx_TypeName obj_type_name; +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) +#endif + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyLong_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyLong_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); +bad: + return NULL; +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* RaiseClosureNameError */ +static void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +/* UnicodeConcatInPlace */ +# if CYTHON_COMPILING_IN_CPYTHON +static int +__Pyx_unicode_modifiable(PyObject *unicode) +{ + if (Py_REFCNT(unicode) != 1) + return 0; + if (!PyUnicode_CheckExact(unicode)) + return 0; + if (PyUnicode_CHECK_INTERNED(unicode)) + return 0; + return 1; +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_ConcatInPlaceImpl(PyObject **p_left, PyObject *right + #if CYTHON_REFNANNY + , void* __pyx_refnanny + #endif + ) { + PyObject *left = *p_left; + Py_ssize_t left_len, right_len, new_len; + if (unlikely(__Pyx_PyUnicode_READY(left) == -1)) + return NULL; + if (unlikely(__Pyx_PyUnicode_READY(right) == -1)) + return NULL; + left_len = PyUnicode_GET_LENGTH(left); + if (left_len == 0) { + Py_INCREF(right); + return right; + } + right_len = PyUnicode_GET_LENGTH(right); + if (right_len == 0) { + Py_INCREF(left); + return left; + } + if (unlikely(left_len > PY_SSIZE_T_MAX - right_len)) { + PyErr_SetString(PyExc_OverflowError, + "strings are too large to concat"); + return NULL; + } + new_len = left_len + right_len; + if (__Pyx_unicode_modifiable(left) + && PyUnicode_CheckExact(right) + && PyUnicode_KIND(right) <= PyUnicode_KIND(left) + && !(PyUnicode_IS_ASCII(left) && !PyUnicode_IS_ASCII(right))) { + int ret; + __Pyx_GIVEREF(*p_left); + ret = PyUnicode_Resize(p_left, new_len); + __Pyx_GOTREF(*p_left); + if (unlikely(ret != 0)) + return NULL; + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(*p_left, left_len, right, 0, right_len) < 0)) return NULL; + #else + _PyUnicode_FastCopyCharacters(*p_left, left_len, right, 0, right_len); + #endif + __Pyx_INCREF(*p_left); + __Pyx_GIVEREF(*p_left); + return *p_left; + } else { + return __Pyx_PyUnicode_Concat(left, right); + } + } +#endif + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__4); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, "cannot import name %S", name); + } + return value; +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod1 */ +#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C0000) +static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { + PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); + Py_DECREF(method); + return result; +} +#endif +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + PyObject *args[2] = {obj, arg}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_Call2Args(method, obj, arg); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); +#endif +} + +/* append */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { + if (likely(PyList_CheckExact(L))) { + if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; + } else { + PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_mstate_global->__pyx_n_u_append, x); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); + } + return 0; +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { + PyObject *runerr = NULL; + Py_ssize_t key_value; + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index)); + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, + "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); + __Pyx_DECREF_TypeName(index_type_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { + __Pyx_TypeName obj_type_name; + if (likely(PyType_Check(obj))) { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem); + if (!meth) { + PyErr_Clear(); + } else { + PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); + Py_DECREF(meth); + return result; + } + } + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { + PyTypeObject *tp = Py_TYPE(obj); + PyMappingMethods *mm = tp->tp_as_mapping; + PySequenceMethods *sm = tp->tp_as_sequence; + if (likely(mm && mm->mp_subscript)) { + return mm->mp_subscript(obj, key); + } + if (likely(sm && sm->sq_item)) { + return __Pyx_PyObject_GetIndex(obj, key); + } + return __Pyx_PyObject_GetItem_Slow(obj, key); +} +#endif + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* UnpackTupleError */ +static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { + if (t == Py_None) { + __Pyx_RaiseNoneNotIterableError(); + } else { + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return; + #endif + if (size < index) { + __Pyx_RaiseNeedMoreValuesError(size); + } else { + __Pyx_RaiseTooManyValuesError(index); + } + } +} + +/* UnpackTuple2 */ +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { + if (likely(is_tuple || PyTuple_Check(tuple))) { + Py_ssize_t size; + if (has_known_size) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + size = __Pyx_PyTuple_GET_SIZE(tuple); + if (likely(size == 2)) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + if (size >= 0) { + __Pyx_UnpackTupleError(tuple, 2); + } + return -1; + } else { + return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); + } +} +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { + PyObject *value1 = NULL, *value2 = NULL; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = __Pyx_PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; +#else + value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); + value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); +#endif + if (decref_tuple) { + Py_DECREF(tuple); + } + *pvalue1 = value1; + *pvalue2 = value2; + return 0; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +bad: + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; +#endif +} +static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, + int has_known_size, int decref_tuple) { + Py_ssize_t index; + PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; + iternextfunc iternext; + iter = PyObject_GetIter(tuple); + if (unlikely(!iter)) goto bad; + if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } + iternext = __Pyx_PyObject_GetIterNextFunc(iter); + value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } + value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } + if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; + Py_DECREF(iter); + *pvalue1 = value1; + *pvalue2 = value2; + return 0; +unpacking_failed: + if (!has_known_size && __Pyx_IterFinish() == 0) + __Pyx_RaiseNeedMoreValuesError(index); +bad: + Py_XDECREF(iter); + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; +} + +/* dict_iter */ +#if CYTHON_COMPILING_IN_PYPY +#include +#endif +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_source_is_dict) { + is_dict = is_dict || likely(PyDict_CheckExact(iterable)); + *p_source_is_dict = is_dict; + if (is_dict) { +#if !CYTHON_COMPILING_IN_PYPY + *p_orig_length = PyDict_Size(iterable); + Py_INCREF(iterable); + return iterable; +#else + static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; + PyObject **pp = NULL; + if (method_name) { + const char *name = PyUnicode_AsUTF8(method_name); + if (strcmp(name, "iteritems") == 0) pp = &py_items; + else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; + else if (strcmp(name, "itervalues") == 0) pp = &py_values; + if (pp) { + if (!*pp) { + *pp = PyUnicode_FromString(name + 4); + if (!*pp) + return NULL; + } + method_name = *pp; + } + } +#endif + } + *p_orig_length = 0; + if (method_name) { + PyObject* iter; + iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); + if (!iterable) + return NULL; +#if !CYTHON_COMPILING_IN_PYPY + if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) + return iterable; +#endif + iter = PyObject_GetIter(iterable); + Py_DECREF(iterable); + return iter; + } + return PyObject_GetIter(iterable); +} +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; + } + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; + } + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { + return -1; + } + Py_INCREF(key); + Py_INCREF(value); + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); + #else + if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { + Py_DECREF(value); + Py_DECREF(tuple); + return -1; + } + if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { + Py_DECREF(tuple); + return -1; + } + #endif + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; + } + } + return 1; +} +#endif +static CYTHON_INLINE int __Pyx_dict_iter_next( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { + PyObject* next_item; +#if !CYTHON_COMPILING_IN_PYPY + if (source_is_dict) { + int result; +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(iter_obj); +#endif + result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); +#endif + return result; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) return -1; + #endif + if (unlikely(pos >= tuple_size)) return 0; + *ppos = pos + 1; + #if CYTHON_ASSUME_SAFE_MACROS + next_item = PyTuple_GET_ITEM(iter_obj, pos); + #else + next_item = PyTuple_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #endif + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(list_size < 0)) return -1; + #endif + if (unlikely(pos >= list_size)) return 0; + *ppos = pos + 1; + #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + next_item = PyList_GetItemRef(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #elif CYTHON_ASSUME_SAFE_MACROS + next_item = PyList_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + #else + next_item = PyList_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + Py_INCREF(next_item); + #endif + } else +#endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); + } + } + if (pitem) { + *pitem = next_item; + } else if (pkey && pvalue) { + if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) + return -1; + } else if (pkey) { + *pkey = next_item; + } else { + *pvalue = next_item; + } + return 1; +} + +/* RaiseUnboundLocalError */ +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc, *new_exc; + __Pyx_PyThreadState_declare + int is_async_stopiteration = 0; + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + __Pyx_PyThreadState_assign + cur_exc = __Pyx_PyErr_CurrentExceptionType(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else { + return; + } + } + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(tb); + new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + "generator raised StopIteration"); + if (!new_exc) { + Py_XDECREF(val); + return; + } + PyException_SetCause(new_exc, val); // steals ref to val + PyErr_SetObject(PyExc_RuntimeError, new_exc); +} + +/* PyLongBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_Fallback___Pyx_PyLong_TrueDivideObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceTrueDivide : PyNumber_TrueDivide)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_TrueDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a, x; + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + } + if (likely(__Pyx_PyLong_IsCompact(op1))) { + a = __Pyx_PyLong_CompactValue(op1); + } else { + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT && 1 * PyLong_SHIFT < 53) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT && 1 * PyLong_SHIFT < 53) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT && 2 * PyLong_SHIFT < 53) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT && 2 * PyLong_SHIFT < 53) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT && 3 * PyLong_SHIFT < 53) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT && 3 * PyLong_SHIFT < 53) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_true_divide(op1, op2); + } + } + if ((8 * sizeof(long) <= 53 || likely(labs(a) <= ((PY_LONG_LONG)1 << 53))) + || __Pyx_PyLong_DigitCount(op1) <= 52 / PyLong_SHIFT) { + return PyFloat_FromDouble((double)a / (double)b); + } + return PyLong_Type.tp_as_number->nb_true_divide(op1, op2); + return PyLong_FromLong(x); + +} +#endif +static PyObject* __Pyx_Float___Pyx_PyLong_TrueDivideObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; + + result = ((double)a) / (double)b; + return PyFloat_FromDouble(result); +} +static CYTHON_INLINE PyObject* __Pyx_PyLong_TrueDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_TrueDivideObjC(op1, op2, intval, inplace, zerodivision_check); + } + #endif + if (PyFloat_CheckExact(op1)) { + return __Pyx_Float___Pyx_PyLong_TrueDivideObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_TrueDivideObjC(op1, op2, inplace); +} +#endif + +/* RaiseMappingExpected */ +static void __Pyx_RaiseMappingExpectedError(PyObject* arg) { + __Pyx_TypeName arg_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(arg)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not a mapping", arg_type_name); + __Pyx_DECREF_TypeName(arg_type_name); +} + +/* PyLongBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_Fallback___Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceMultiply : PyNumber_Multiply)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return __Pyx_NewRef(op1); + } + if (likely(__Pyx_PyLong_IsCompact(op1))) { + a = __Pyx_PyLong_CompactValue(op1); + } else { + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT+30) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT+30) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT+30) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT+30) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT+30) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT+30) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT+30) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT+30) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT+30) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT+30) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT+30) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT+30) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + #endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_multiply(op1, op2); + } + } + CYTHON_UNUSED_VAR(a); + CYTHON_UNUSED_VAR(b); + #ifdef HAVE_LONG_LONG + lla = a; + goto long_long; + #else + return PyLong_Type.tp_as_number->nb_multiply(op1, op2); + #endif + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla * llb; + return PyLong_FromLongLong(llx); +#endif + return __Pyx_Fallback___Pyx_PyLong_MultiplyObjC(op1, op2, inplace); + + +} +#endif +static PyObject* __Pyx_Float___Pyx_PyLong_MultiplyObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; + + result = ((double)a) * (double)b; + return PyFloat_FromDouble(result); +} +static CYTHON_INLINE PyObject* __Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_MultiplyObjC(op1, op2, intval, inplace, zerodivision_check); + } + #endif + if (PyFloat_CheckExact(op1)) { + return __Pyx_Float___Pyx_PyLong_MultiplyObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_MultiplyObjC(op1, op2, inplace); +} +#endif + +/* MergeKeywords */ +static int __Pyx_MergeKeywords_dict(PyObject *kwdict, PyObject *source_dict) { + Py_ssize_t len1, len2; + len2 = PyDict_Size(source_dict); + if (unlikely(len2 == -1)) return -1; + if (len2 == 0) { + return 0; + } + len1 = PyDict_Size(kwdict); + if (unlikely(len1 == -1)) return -1; + if (len1 > 0) { + PyObject *key, *smaller_dict, *larger_dict; + Py_ssize_t ppos = 0; + int duplicates_found = 0; + if (len1 <= len2) { + smaller_dict = kwdict; + larger_dict = source_dict; + } else { + smaller_dict = source_dict; + larger_dict = kwdict; + } + __Pyx_BEGIN_CRITICAL_SECTION(smaller_dict); + while (PyDict_Next(smaller_dict, &ppos, &key, NULL)) { + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_INCREF(key); + #endif + if (unlikely(PyDict_Contains(larger_dict, key))) { + __Pyx_RaiseDoubleKeywordsError("function", key); + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_DECREF(key); + #endif + duplicates_found = 1; + break; + }; + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_DECREF(key); + #endif + } + __Pyx_END_CRITICAL_SECTION(); + if (unlikely(duplicates_found)) + return -1; + } + return PyDict_Update(kwdict, source_dict); +} +static int __Pyx_MergeKeywords_any(PyObject *kwdict, PyObject *source_mapping) { + PyObject *iter, *key = NULL, *value = NULL; + int source_is_dict, result; + Py_ssize_t orig_length, ppos = 0; + iter = __Pyx_dict_iterator(source_mapping, 0, __pyx_mstate_global->__pyx_n_u_items, &orig_length, &source_is_dict); + if (unlikely(!iter)) { + PyObject *args; + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) goto bad; + PyErr_Clear(); + args = PyTuple_Pack(1, source_mapping); + if (likely(args)) { + PyObject *fallback = PyObject_Call((PyObject*)&PyDict_Type, args, NULL); + Py_DECREF(args); + if (likely(fallback)) { + result = __Pyx_MergeKeywords_dict(kwdict, fallback); + Py_DECREF(fallback); + return result; + } + } + if (unlikely(!iter)) goto bad; + } + while (1) { + result = __Pyx_dict_iter_next(iter, orig_length, &ppos, &key, &value, NULL, source_is_dict); + if (unlikely(result < 0)) goto bad; + if (!result) break; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + { + int inserted = PyDict_SetDefaultRef(kwdict, key, value, NULL); + if (unlikely(inserted != 0)) { + if (inserted == 1) __Pyx_RaiseDoubleKeywordsError("function", key); + result = -1; + } + } + #else + if (unlikely(PyDict_Contains(kwdict, key))) { + __Pyx_RaiseDoubleKeywordsError("function", key); + result = -1; + } else { + result = PyDict_SetItem(kwdict, key, value); + } + #endif + Py_DECREF(key); + Py_DECREF(value); + if (unlikely(result < 0)) goto bad; + } + Py_XDECREF(iter); + return 0; +bad: + Py_XDECREF(iter); + return -1; +} +static CYTHON_INLINE int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping) { + assert(PyDict_Check(kwdict)); + if (likely(PyDict_Check(source_mapping))) { + return __Pyx_MergeKeywords_dict(kwdict, source_mapping); + } else { + return __Pyx_MergeKeywords_any(kwdict, source_mapping); + } +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* ListPack */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { + va_list va; + PyObject *l = PyList_New(n); + va_start(va, n); + if (unlikely(!l)) goto end; + for (Py_ssize_t i=0; i__pyx_n_u_mro_entries); + if (!meth && PyErr_Occurred()) { + goto error; + } + if (!meth) { + if (new_bases) { + if (PyList_Append(new_bases, base) < 0) { + goto error; + } + } + continue; + } + new_base = __Pyx_PyObject_CallOneArg(meth, bases); + Py_DECREF(meth); + if (!new_base) { + goto error; + } + if (!PyTuple_Check(new_base)) { + PyErr_SetString(PyExc_TypeError, + "__mro_entries__ must return a tuple"); + Py_DECREF(new_base); + goto error; + } + if (!new_bases) { + if (!(new_bases = PyList_New(i))) { + goto error; + } + for (j = 0; j < i; j++) { + PyObject *base_from_list; +#if CYTHON_ASSUME_SAFE_MACROS + base_from_list = PyTuple_GET_ITEM(bases, j); + PyList_SET_ITEM(new_bases, j, base_from_list); + Py_INCREF(base_from_list); +#else + base_from_list = PyTuple_GetItem(bases, j); + if (!base_from_list) goto error; + Py_INCREF(base_from_list); + if (PyList_SetItem(new_bases, j, base_from_list) < 0) goto error; +#endif + } + } +#if CYTHON_ASSUME_SAFE_SIZE + j = PyList_GET_SIZE(new_bases); +#else + j = PyList_Size(new_bases); + if (j < 0) goto error; +#endif + if (PyList_SetSlice(new_bases, j, j, new_base) < 0) { + goto error; + } + Py_DECREF(new_base); + } + if (!new_bases) { + Py_INCREF(bases); + return bases; + } + result = PyList_AsTuple(new_bases); + Py_DECREF(new_bases); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(base); +#endif + return result; +error: + Py_XDECREF(new_bases); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(base); +#endif + return NULL; +} + +/* CalculateMetaclass */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases; +#if CYTHON_ASSUME_SAFE_SIZE + nbases = PyTuple_GET_SIZE(bases); +#else + nbases = PyTuple_Size(bases); + if (nbases < 0) return NULL; +#endif + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; +#if CYTHON_ASSUME_SAFE_MACROS + PyObject *tmp = PyTuple_GET_ITEM(bases, i); +#else + PyObject *tmp = PyTuple_GetItem(bases, i); + if (!tmp) return NULL; +#endif + tmptype = Py_TYPE(tmp); + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { + metaclass = &PyType_Type; + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +/* Py3ClassCreate */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_mstate_global->__pyx_n_u_prepare); + if (prep) { + PyObject *pargs[3] = {NULL, name, bases}; + ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); + Py_DECREF(prep); + } else { + if (unlikely(PyErr_Occurred())) + return NULL; + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result; + PyObject *owned_metaclass = NULL; + PyObject *margs[4] = {NULL, name, bases, dict}; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_mstate_global->__pyx_n_u_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); + Py_XDECREF(owned_metaclass); + return result; +} + +/* CyFunctionClassCell */ +static int __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj) { + Py_ssize_t i, count = __Pyx_PyList_GET_SIZE(cyfunctions); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(count < 0)) return -1; + #endif + for (i = 0; i < count; i++) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + PyList_GET_ITEM(cyfunctions, i); +#else + __Pyx_PySequence_ITEM(cyfunctions, i); + if (unlikely(!m)) + return -1; +#endif + __Pyx_CyFunction_SetClassObj(m, classobj); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + Py_DECREF((PyObject*)m); +#endif + } + return 0; +} + +/* CLineInTraceback */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback)) + Py_XINCREF(use_cline); + __Pyx_END_CRITICAL_SECTION(); + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_INCREF(use_cline); + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + Py_XDECREF(use_cline); + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { + return NULL; + } + code_object = code_cache->entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + code_cache->entries = entries; + code_cache->max_count = 64; + code_cache->count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_INCREF(code_object); + Py_DECREF(tmp); + return; + } + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + code_cache->entries = entries; + code_cache->max_count = new_max; + } + for (i=code_cache->count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + code_cache->count++; + Py_INCREF(code_object); +} +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + } + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} +#endif + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__11); + } + goto done; +} +#endif + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (long) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (long) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (int) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} + +/* IterNextPlain */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { + if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) + __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); + return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, iterator, NULL); + return result; +#else + (void)__Pyx_GetBuiltinName; // only for early limited API + iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); + assert(iternext); + return iternext(iterator); +#endif +} + +/* ReturnWithStopIteration */ +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { + if (value == Py_None) { + if (async || !iternext) + PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); + return; + } + __Pyx__ReturnWithStopIteration(value, async); +} +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { +#if CYTHON_COMPILING_IN_CPYTHON + __Pyx_PyThreadState_declare +#endif + PyObject *exc; + PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; +#if CYTHON_COMPILING_IN_CPYTHON + if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { + if (PY_VERSION_HEX >= (0x030e00A1)) { + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + } else { + PyObject *args_tuple = PyTuple_New(1); + if (unlikely(!args_tuple)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args_tuple, 0, value); + exc = PyObject_Call(exc_type, args_tuple, NULL); + Py_DECREF(args_tuple); + } + if (unlikely(!exc)) return; + } else { + Py_INCREF(value); + exc = value; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + #if CYTHON_USE_EXC_INFO_STACK + if (!__pyx_tstate->exc_info->exc_value) + #else + if (!__pyx_tstate->exc_type) + #endif + { + Py_INCREF(exc_type); + __Pyx_ErrRestore(exc_type, exc, NULL); + return; + } + #endif +#else + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + if (unlikely(!exc)) return; +#endif + PyErr_SetObject(exc_type, exc); + Py_DECREF(exc); +} + +/* CoroutineBase */ +#if !CYTHON_COMPILING_IN_LIMITED_API +#include +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#endif // CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void +__Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { +#if CYTHON_USE_AM_SEND + gen->yieldfrom_am_send = NULL; +#endif + Py_CLEAR(gen->yieldfrom); +} +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + CYTHON_UNUSED_VAR(__pyx_tstate); + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } + else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); + if (unlikely(!value)) goto limited_api_failure; + #else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + #endif + Py_DECREF(ev); + } + else if (unlikely(PyTuple_Check(ev))) { + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) { + Py_XDECREF(tb); + Py_DECREF(ev); + Py_DECREF(et); + return -1; + } + #endif + if (tuple_size >= 1) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#elif CYTHON_ASSUME_SAFE_MACROS + value = PySequence_ITEM(ev, 0); +#else + value = PySequence_GetItem(ev, 0); + if (!value) goto limited_api_failure; +#endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); +#else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); +#endif + Py_DECREF(ev); +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!value)) return -1; +#endif + *pvalue = value; + return 0; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS + limited_api_failure: + Py_XDECREF(et); + Py_XDECREF(tb); + Py_XDECREF(ev); + return -1; +#endif +} +static CYTHON_INLINE +__Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { + if (*retval) { + return PYGEN_NEXT; + } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { + return PYGEN_RETURN; + } else { + return PYGEN_ERROR; + } +} +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_CLEAR(exc_state->exc_value); +#else + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); +#endif +} +#define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) +static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) { + const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { + msg = "coroutine already executing"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { + msg = "async generator already executing"; + #endif + } else { + msg = "generator already executing"; + } + PyErr_SetString(PyExc_ValueError, msg); +} +static void __Pyx_Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) { + CYTHON_MAYBE_UNUSED_VAR(gen); + CYTHON_MAYBE_UNUSED_VAR(closing); + #ifdef __Pyx_Coroutine_USED + if (!closing && __Pyx_Coroutine_Check(gen)) { + PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); + } else + #endif + if (value) { + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(gen)) + PyErr_SetNone(PyExc_StopAsyncIteration); + else + #endif + PyErr_SetNone(PyExc_StopIteration); + } +} +static +__Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { + __Pyx_PyThreadState_declare + PyThreadState *tstate; + __Pyx_ExcInfoStruct *exc_state; + PyObject *retval; + assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running + if (unlikely(self->resume_label == -1)) { + __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + return PYGEN_ERROR; + } +#if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + tstate = __pyx_tstate; +#else + tstate = __Pyx_PyThreadState_Current; +#endif + exc_state = &self->gi_exc_state; + if (exc_state->exc_value) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #elif PY_VERSION_HEX >= 0x030B00a4 + exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; + #else + exc_tb = exc_state->exc_traceback; + #endif + if (exc_tb) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + assert(f->f_back == NULL); + #if PY_VERSION_HEX >= 0x030B00A1 + f->f_back = PyThreadState_GetFrame(tstate); + #else + Py_XINCREF(tstate->frame); + f->f_back = tstate->frame; + #endif + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + Py_DECREF(exc_tb); + #endif + } + #endif + } +#if CYTHON_USE_EXC_INFO_STACK + exc_state->previous_item = tstate->exc_info; + tstate->exc_info = exc_state; +#else + if (exc_state->exc_type) { + __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(exc_state); + __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } +#endif + retval = self->body(self, tstate, value); +#if CYTHON_USE_EXC_INFO_STACK + exc_state = &self->gi_exc_state; + tstate->exc_info = exc_state->previous_item; + exc_state->previous_item = NULL; + __Pyx_Coroutine_ResetFrameBackpointer(exc_state); +#endif + *result = retval; + if (self->resume_label == -1) { + return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; + } + return PYGEN_NEXT; +} +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(exc_state); +#else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 + if (!exc_state->exc_value) return; + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #else + exc_tb = exc_state->exc_traceback; + #endif + if (likely(exc_tb)) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif + } +#endif +} +#define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ + ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) +static PyObject * +__Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { + CYTHON_MAYBE_UNUSED_VAR(gen); + if (likely(result == PYGEN_RETURN)) { + int is_async = 0; + #ifdef __Pyx_AsyncGen_USED + is_async = __Pyx_AsyncGen_CheckExact(gen); + #endif + __Pyx_ReturnWithStopIteration(retval, is_async, iternext); + Py_XDECREF(retval); + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE +PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) { +#if PY_VERSION_HEX <= 0x030A00A1 + return _PyGen_Send(gen, arg); +#else + PyObject *result; + if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) { + if (PyAsyncGen_CheckExact(gen)) { + assert(result == Py_None); + PyErr_SetNone(PyExc_StopAsyncIteration); + } + else if (result == Py_None) { + PyErr_SetNone(PyExc_StopIteration); + } + else { +#if PY_VERSION_HEX < 0x030d00A1 + _PyGen_SetStopIterationValue(result); +#else + if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) { + PyErr_SetObject(PyExc_StopIteration, result); + } else { + PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result); + if (likely(exc != NULL)) { + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); + } + } +#endif + } + Py_DECREF(result); + result = NULL; + } + return result; +#endif +} +#endif +static CYTHON_INLINE __Pyx_PySendResult +__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { + __Pyx_PySendResult result; + PyObject *val = NULL; + assert(__Pyx_Coroutine_get_is_running(gen)); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); + result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); + Py_XDECREF(val); + return result; +} +#if CYTHON_USE_AM_SEND +static __Pyx_PySendResult +__Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { + PyObject *ret = NULL; + __Pyx_PySendResult delegate_result, result; + assert(__Pyx_Coroutine_get_is_running(gen)); + delegate_result = gen_am_send(gen->yieldfrom, value, &ret); + if (delegate_result == PYGEN_NEXT) { + assert (ret != NULL); + *retval = ret; + return PYGEN_NEXT; + } + assert (delegate_result != PYGEN_ERROR || ret == NULL); + __Pyx_Coroutine_Undelegate(gen); + result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); + Py_XDECREF(ret); + return result; +} +#endif +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); +} +static __Pyx_PySendResult +__Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + __Pyx_PySendResult result; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #if !CYTHON_USE_AM_SEND + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + ret = __Pyx_async_gen_asend_send(yf, value); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + if (PyCoro_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + #endif + #endif + { + #if !CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x03080000 + if (value == Py_None && PyIter_Check(yf)) + ret = __Pyx_PyIter_Next_Plain(yf); + else + #endif + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); + } + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + *retval = ret; + return PYGEN_NEXT; + } + result = __Pyx_Coroutine_FinishDelegation(gen, retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return result; +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + CYTHON_UNUSED_VAR(gen); + assert(__Pyx_Coroutine_get_is_running(gen)); + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + if (__Pyx_CoroutineAwait_CheckExact(yf)) { + result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + retval = __Pyx_async_gen_asend_close(yf, NULL); + result = PYGEN_RETURN; + } else + if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { + retval = __Pyx_async_gen_athrow_close(yf, NULL); + result = PYGEN_RETURN; + } else + #endif + { + PyObject *meth; + result = PYGEN_RETURN; + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); + if (unlikely(!meth)) { + if (unlikely(PyErr_Occurred())) { + PyErr_WriteUnraisable(yf); + } + } else { + retval = __Pyx_PyObject_CallNoArg(meth); + Py_DECREF(meth); + if (unlikely(!retval)) { + result = PYGEN_ERROR; + } + } + } + Py_XDECREF(retval); + return result == PYGEN_ERROR ? -1 : 0; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, Py_None); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + ret = __Pyx_PyIter_Next_Plain(yf); + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); +} +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; +} +static __Pyx_PySendResult +__Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PySendResult result; + PyObject *yf; + int err = 0; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + yf = gen->yieldfrom; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); + if (result == PYGEN_ERROR) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_Coroutine_unset_is_running(gen); + if (!__Pyx_PyErr_Occurred()) { + return PYGEN_RETURN; + } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { + __Pyx_PyErr_Clear(); + return PYGEN_RETURN; + } + return PYGEN_ERROR; + } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_RETURN; + } else { + const char *msg; + Py_DECREF(*retval); + *retval = NULL; + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check(self)) { + msg = "coroutine ignored GeneratorExit"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact(self)) { + msg = "async generator ignored GeneratorExit"; + #endif + } else { + msg = "generator ignored GeneratorExit"; + } + PyErr_SetString(PyExc_RuntimeError, msg); + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_ERROR; + } +} +static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, + PyObject *args, int close_on_genexit) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *yf; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) + return __Pyx_Coroutine_AlreadyRunningError(gen); + yf = gen->yieldfrom; + if (yf) { + __Pyx_PySendResult result; + PyObject *ret; + Py_INCREF(yf); + if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + goto propagate_exception; + goto throw_here; + } + if (0 + #ifdef __Pyx_Generator_USED + || __Pyx_Generator_CheckExact(yf) + #endif + #ifdef __Pyx_Coroutine_USED + || __Pyx_Coroutine_Check(yf) + #endif + ) { + ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { + ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); + #endif + } else { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (unlikely(PyErr_Occurred())) { + __Pyx_Coroutine_unset_is_running(gen); + return NULL; + } + __Pyx_Coroutine_Undelegate(gen); + goto throw_here; + } + if (likely(args)) { + ret = __Pyx_PyObject_Call(meth, args, NULL); + } else { + PyObject *cargs[4] = {NULL, typ, val, tb}; + ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + Py_DECREF(meth); + } + Py_DECREF(yf); + if (ret) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &ret); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); +propagate_exception: + { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + PyObject *typ; + PyObject *val = NULL; + PyObject *tb = NULL; + if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) + return NULL; + return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); +} +static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_VISIT(exc_state->exc_value); +#else + Py_VISIT(exc_state->exc_type); + Py_VISIT(exc_state->exc_value); + Py_VISIT(exc_state->exc_traceback); +#endif + return 0; +} +static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); + if (e) return e; + } + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); + } +#endif + Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_frame); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + Py_CLEAR(gen->gi_modulename); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label >= 0) { + PyObject_GC_Track(self); +#if CYTHON_USE_TP_FINALIZE + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) +#else + { + destructor del = __Pyx_PyObject_GetSlot(gen, tp_del, destructor); + if (del) del(self); + } + if (unlikely(Py_REFCNT(self) > 0)) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + /* We have to handle this case for asynchronous generators + right here, because this code has to be between UNTRACK + and GC_Del. */ + Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); + } +#endif + __Pyx_Coroutine_clear(self); + __Pyx_PyHeapTypeObject_GC_Del(gen); +} +#if CYTHON_USE_TP_FINALIZE +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + if (gen->resume_label < 0) { + return; + } + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; + PyObject *finalizer = agen->ag_finalizer; + if (finalizer && !agen->ag_closed) { + PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); + if (unlikely(!res)) { + PyErr_WriteUnraisable(self); + } else { + Py_DECREF(res); + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); + return; + } + } +#endif + if (unlikely(gen->resume_label == 0 && !error_value)) { +#ifdef __Pyx_Coroutine_USED +#ifdef __Pyx_Generator_USED + if (!__Pyx_Generator_CheckExact(self)) +#endif + { + PyObject_GC_UnTrack(self); + if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) + PyErr_WriteUnraisable(self); + PyObject_GC_Track(self); + } +#endif + } else { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); + if (result == PYGEN_ERROR) { + PyErr_WriteUnraisable(self); + } else { + Py_XDECREF(retval); + } + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); +} +#endif +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context) +{ + PyObject *name = self->gi_name; + CYTHON_UNUSED_VAR(context); + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_name, value); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context) +{ + PyObject *name = self->gi_qualname; + CYTHON_UNUSED_VAR(context); + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_qualname, value); + return 0; +} +static PyObject * +__Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) +{ +#if !CYTHON_COMPILING_IN_LIMITED_API + PyObject *frame; + #if PY_VERSION_HEX >= 0x030d0000 + Py_BEGIN_CRITICAL_SECTION(self); + #endif + frame = self->gi_frame; + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + PyObject *globals = PyDict_New(); + if (unlikely(!globals)) return NULL; + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + Py_DECREF(globals); + if (unlikely(!frame)) + return NULL; + if (unlikely(self->gi_frame)) { + Py_DECREF(frame); + frame = self->gi_frame; + } else { + self->gi_frame = frame; + } + } + Py_INCREF(frame); + #if PY_VERSION_HEX >= 0x030d0000 + Py_END_CRITICAL_SECTION(); + #endif + return frame; +#else + CYTHON_UNUSED_VAR(self); + Py_RETURN_NONE; +#endif +} +static PyObject * +__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { + CYTHON_UNUSED_VAR(context); + PyObject *frame = self->gi_frame; + if (frame) + return __Pyx_NewRef(frame); + return __Pyx__Coroutine_get_frame(self); +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (unlikely(!gen)) + return NULL; + return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); +} +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->yieldfrom_am_send = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API + gen->gi_exc_state.exc_value = NULL; + #else + gen->gi_exc_state.exc_type = NULL; + gen->gi_exc_state.exc_value = NULL; + gen->gi_exc_state.exc_traceback = NULL; + #endif +#if CYTHON_USE_EXC_INFO_STACK + gen->gi_exc_state.previous_item = NULL; +#endif + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + Py_XINCREF(code); + gen->gi_code = code; + gen->gi_frame = NULL; + PyObject_GC_Track(gen); + return gen; +} +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + gen->is_running = 1; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + assert(gen->is_running); + gen->is_running = 0; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif +} +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { + CYTHON_UNUSED_VAR(closure); + char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); + if (result) Py_RETURN_TRUE; + else Py_RETURN_FALSE; +} +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { + Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; + if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { + return; + } + memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); + static_amsend_methods->am_send = am_send; + type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); +} +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + __Pyx_TypeName self_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE((PyObject*)self)); + PyErr_Format(PyExc_TypeError, "cannot pickle '" __Pyx_FMT_TYPENAME "' object", + self_type_name); + __Pyx_DECREF_TypeName(self_type_name); + return NULL; +} + +/* Generator */ +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, + PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being iterated by 'yield from', or None")}, + {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the generator"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the generator"), 0}, + {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the generator"), 0}, + {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_GeneratorType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_Generator_Next}, + {Py_tp_methods, (void *)__pyx_Generator_methods}, + {Py_tp_members, (void *)__pyx_Generator_memberlist}, + {Py_tp_getset, (void *)__pyx_Generator_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, +#endif + {0, 0}, +}; +static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, + __pyx_GeneratorType_slots +}; +#if __PYX_HAS_PY_AM_SEND == 2 +static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; +#endif +static int __pyx_Generator_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); + if (unlikely(!mstate->__pyx_GeneratorType)) { + return -1; + } +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); +#endif + return 0; +} +static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *retval = NULL; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + (void) result; + assert (result == PYGEN_RETURN || result == PYGEN_ERROR); + assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); + return retval; +} + +/* GetRuntimeVersion */ +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + static unsigned long __Pyx_cached_runtime_version = 0; + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + return __Pyx_cached_runtime_version; +#endif +} + +/* CheckBinaryVersion */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); + return PyErr_WarnEx(NULL, message, 1); + } +} + +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL + && !CYTHON_COMPILING_IN_GRAAL) { + line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); + if (unlikely(!line_table_bytes)) goto done; + Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + Py_XDECREF(line_table_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* InitStrings */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { + while (t->s) { + PyObject *str; + if (t->is_unicode) { + if (t->intern) { + str = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL); + } else { + str = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + str = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + if (!str) + return -1; + *target = str; + if (PyObject_Hash(str) == -1) + return -1; + ++t; + ++target; + } + return 0; +} + +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + { + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; + } + #endif + return result; + } +#else +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif +} +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif + if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); +#endif + } else + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + PyObject *res = NULL; + if (likely(PyLong_Check(x))) + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + if (likely(m && m->nb_int)) { + res = m->nb_int(x); + } +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Long(x); + } +#endif + if (likely(res)) { + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyLong_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; +} +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/loggerModule.cp311-win_amd64.pyd b/loggerModule.cp311-win_amd64.pyd new file mode 100644 index 0000000000000000000000000000000000000000..ffa0f492ee97705ad4362bad3cc43d5e221ba301 GIT binary patch literal 227840 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

l?d}7j?X)9DJe0UoXyD9pdQiaaT}7; z(YA*X?Q%9?-5$R$L0jC?Sl58sF{Qv7?#4#6BS=aO5F)FpEb^mZ zNT^md2vc-amss1#3so8@sKODy!HIsgqp=C&HF~2&T@K$8*-&Ee7c<-<#{$Pfq}yDJ zPEu{CW-;7Q&`@`33e88A%2O$AUlgD8Id`qo*xf|6YOdSkoNKt7T2bYy#vQIYVjq;} zaB#Qdo*048e8|%sJJ1~nk7maXC+4zvLo%cziGX=(h%KCMrJ5*`X@+z-c6uu7|Igx5 zzBQhPDr(;de5(Y`J1Sdc-v#?sJL@6WLj4FsDNV19vC~OiiS#GRi?Rpa;VI3z zxVt^n6E$sR0{*9Ds%-bFR$UloKBnAu*VWfcEUP?CB0{Tnx(uA z;VXMGnBL*Ib+;+6bErxcFe7$8d?IrBf5J#r+~KHffYel?c&z4*LM$XVawGes$zNtn zB*dH_D>1qpI3QxBzaDH5r1>lyFU(Kmr}ELQE87>2@VFwwx7RmrtE`uz#o=HFN0H$) z0fu%%`OyN5bVP(VR`c=;g~Jh*ziv30UOQBr$abatBj_m{bNqAt4CSgTG878qLJwvlxNP160bA4TvvvQkWQzN`< znw-=}o9f6L<1JD&IcuEg$5rUC+ng8`oCa3r>b5t?5gDT?g1{;ye59sExnN$aMn_bG zW@;ExP#-yGgJueaMnL-_B}C~d1~IykyBX=C@f>3|z6DcpoxTQIM<|I@-#|L7IyzhC zk))R@os%Zyp-4Q-4=F+0nlTG-xiuBeT@T=xSTJbPkx;%#C@T?EEr%AP+Cy4_A!Ab$ zAgcV48dv{M5LTxP&1sFM$~uyno867BV!}n`ex7<&VyJMr)X*lg(k!9#CB@Bv zDaEkTsC8DlkGP!;&8UbPZbQX!yFlH@fEjQa}jVs>`Ui8;eZ&x|=GioU~kPfB>}U zp^=7)?xqPM=)@EGkWx@vxeHwrYbBUpRASvqj|#f#(KTF zv$h3G!&t~{+>NYQj=1WoZk6&XLdqeWR*qDO>OZ;jK<(MayvxHHXpFss#bMr_|m371!V5&Sv>&x3FC*xss^K3U8tQq@82Z+s(?94n zh5{W!&vy?$de~682*LS;R;v1AXLqNKB#QAV9UJ}Gg9%9;m;0v#ECb1@{i)f3H0Xi# z^>RspGdOeL!0@B5MCadb41N9K;lN$Phh9O+#?T9Gr=S1PnFpR4@^%b)pU`C!Y%9X) zit))Ei#u9;tpQ6QZ6JAy&+T96-x8SJy`Z~@oO=Qj0}DnH#Q4nqDVOzZ8c0qVNWRFw zb09g>55zKjn<$G6U$K9azj7cU-M8MqEPz}id$R0>Y z?pW_z?yvOkq?9TB$GxzikJ^6|;{Ltaky*(T%M54hz zrZCg{%mdxS9sZ$jBYyi6!+{4vb)O$fFx(zEv+vO`k;ZDNp|69IOuT@B9F5_}I)?B0 zzM^9|FYGt)I=Sqxz)q^yk^7Jl>xUsh!8O@Yi3PaI*3h`|Wm~J!TY)r6Vyq6Wt6y7G zwy}8QdcpKNbJsJVnt^Ai$4}gHWqpy~X(3Vcy{7CBbUMO6xj%V2^*riTOHqwY^m-L~ z@mJ8-l5HJ(fYqG9`tHk7rPL|h%@ZRAs{drfNSTJDB>Yuf;_u9UqfwT+#n?@$H5Cn$0g8j(|AdE{OdC1!U z)w!|@sHLRmg=ok$5?@lfbl83C&?p6gCEZy)*(6$R9ou~IJ}G;WI|`U&V1b0dI5cYV zL|^ux5^Z>sqPQR8&K+3Vy{da#Pi)VcUQ6%PzJe2%^_OlUsR;QMRpOPt?f&ZnJG*1L zbGjRPnZ&YX&{$}sl>v)FO*IlQg|q}pcLX*CDp@3QMInGwaDIvkf%p$#L{P+#9JsiD z*0SDgPB0^o4U(cCNWx-T9nsaQE1g*2qWLry C0#5sBkTbU57#ww{=N75S&Bwuvn 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 LC;j#BL^beVu8kvz literal 0 HcmV?d00001 diff --git a/loggerModule.py b/loggerModule.py index be40aee..d01f7c1 100644 --- a/loggerModule.py +++ b/loggerModule.py @@ -48,6 +48,151 @@ def get_level_name(level): } return level_names.get(level, f"Level {level}") + +class WindowsSafeRotatingFileHandler(logging.Handler): + """ + Windows 호환 로테이팅 파일 핸들러 + + 기존 RotatingFileHandler의 문제점: + - Windows에서 파일이 열려있으면 rename 실패 → 롤링 실패 → 로그 유실 + + 해결책: + - 파일 크기 초과 시 기존 파일을 닫고 새 파일명으로 직접 생성 + - 타임스탬프 기반 파일명으로 충돌 방지 + """ + + def __init__(self, filename, maxBytes=10*1024*1024, backupCount=50, encoding='utf-8'): + super().__init__() + self.baseFilename = os.path.abspath(filename) + self.maxBytes = maxBytes + self.backupCount = backupCount + self.encoding = encoding + self.stream = None + self._lock = threading.Lock() + self._open_file() + + def _open_file(self): + """파일 스트림 열기""" + try: + # 디렉토리 생성 + os.makedirs(os.path.dirname(self.baseFilename), exist_ok=True) + self.stream = open(self.baseFilename, 'a', encoding=self.encoding) + except Exception as e: + # 파일 열기 실패 시 stderr로 출력 + import sys + print(f"[Logger] 파일 열기 실패: {self.baseFilename}, 오류: {e}", file=sys.stderr) + self.stream = None + + def _close_file(self): + """파일 스트림 닫기""" + if self.stream: + try: + self.stream.flush() + self.stream.close() + except Exception: + pass + self.stream = None + + def _should_rollover(self): + """롤오버가 필요한지 확인""" + if self.stream is None: + return False + try: + # 현재 파일 크기 확인 + self.stream.seek(0, 2) # 파일 끝으로 이동 + size = self.stream.tell() + return size >= self.maxBytes + except Exception: + return False + + def _do_rollover(self): + """롤오버 실행 - Windows 안전 방식""" + self._close_file() + + try: + # 타임스탬프 기반 백업 파일명 생성 + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + base, ext = os.path.splitext(self.baseFilename) + backup_name = f"{base}_{timestamp}{ext}" + + # 기존 파일을 백업 파일로 이름 변경 + if os.path.exists(self.baseFilename): + try: + os.rename(self.baseFilename, backup_name) + except OSError: + # rename 실패 시 복사 후 삭제 시도 + try: + import shutil + shutil.copy2(self.baseFilename, backup_name) + # 원본 파일 내용 비우기 (삭제 대신) + with open(self.baseFilename, 'w', encoding=self.encoding) as f: + pass + except Exception: + pass + + # 오래된 백업 파일 정리 + self._cleanup_old_backups() + + except Exception as e: + import sys + print(f"[Logger] 롤오버 실패: {e}", file=sys.stderr) + + # 새 파일 열기 + self._open_file() + + def _cleanup_old_backups(self): + """오래된 백업 파일 정리""" + try: + base_dir = os.path.dirname(self.baseFilename) + base_name = os.path.basename(self.baseFilename) + name_without_ext, ext = os.path.splitext(base_name) + + # 백업 파일 패턴: {name}_{timestamp}.log + backup_files = [] + for f in os.listdir(base_dir): + if f.startswith(name_without_ext + '_') and f.endswith(ext): + full_path = os.path.join(base_dir, f) + try: + mtime = os.path.getmtime(full_path) + backup_files.append((full_path, mtime)) + except Exception: + pass + + # 최신순 정렬 후 backupCount 초과분 삭제 + backup_files.sort(key=lambda x: x[1], reverse=True) + for file_path, _ in backup_files[self.backupCount:]: + try: + os.remove(file_path) + except Exception: + pass + except Exception: + pass + + def emit(self, record): + """로그 레코드 출력""" + with self._lock: + try: + # 롤오버 체크 + if self._should_rollover(): + self._do_rollover() + + # 스트림이 없으면 다시 열기 시도 + if self.stream is None: + self._open_file() + + if self.stream: + msg = self.format(record) + self.stream.write(msg + '\n') + self.stream.flush() + except Exception: + self.handleError(record) + + def close(self): + """핸들러 종료""" + with self._lock: + self._close_file() + super().close() + class Logger: def __init__(self, gui_logger=None, log_file="Edit_PartTimer_log.log", logger_name="Edit_PartTimer_log", @@ -74,8 +219,30 @@ class Logger: # 로그 디렉토리 생성 self.log_dir.mkdir(parents=True, exist_ok=True) + # 멀티프로세스 환경에서의 로그 파일명 충돌 방지를 위해 PID 추가 + # 윈도우에서는 실행 중인 파일의 이름 변경(롤링) 시 PermissionError가 발생할 수 있으므로 + # 프로세스별로 별도의 로그 파일을 사용하도록 함. + pid = os.getpid() + + # 원본 로그 파일명에서 확장자 분리 + if log_file.endswith('.log'): + base_name = log_file[:-4] + ext = '.log' + else: + base_name = log_file + ext = '.log' + + # PID가 포함된 실제 로그 파일명 생성 (예: app_1234.log) + # 단, 메인 프로세스라고 판단되거나 특정 조건에서는 원본 이름을 유지할 수도 있으나 + # 교착 상태 해결을 위해 무조건 PID를 붙이는 것이 안전함. + self.actual_log_file = self.log_dir / f"{Path(base_name).stem}_{pid}{ext}" + + # cleanup을 위한 기본 이름 패턴 설정 (PID 부분 제외하고 매칭) + # self.log_base_name은 원본 파일의 stem을 유지하여 모든 PID 로그를 관리 대상으로 함 + self.log_base_name = Path(log_file).stem + # 로그 설정 - self.logger = logging.getLogger(logger_name) + self.logger = logging.getLogger(f"{logger_name}_{pid}") # 로거 이름도 유니크하게 self.logger.setLevel(file_log_level) # 상위 로거로의 전파 방지(중복 출력 방지) self.logger.propagate = False @@ -95,7 +262,8 @@ class Logger: # 핸들러 추가 self._add_console_handler(file_log_level) - self._add_file_handler(log_file, file_log_level) + # 실제 파일명(PID 포함)으로 핸들러 생성 + self._add_file_handler(str(self.actual_log_file), file_log_level) # 자동 정리 스레드 시작 self._start_cleanup_thread() @@ -111,17 +279,17 @@ class Logger: self.logger.addHandler(console_handler) def _add_file_handler(self, log_file, level): - """파일 크기 기반 로테이팅 + 수명 관리""" - from logging.handlers import RotatingFileHandler + """파일 크기 기반 로테이팅 + 수명 관리 (Windows 호환)""" # 확장자가 .log가 아니면 .log로 변경 if not log_file.endswith('.log'): base_name, _ = os.path.splitext(log_file) log_file = base_name + '.log' - # 크기 기반 로테이션: 10MB, 최대 50개(정리 스레드가 3일/일5개로 실제 보존 제한) - file_handler = RotatingFileHandler( + # Windows 호환 커스텀 핸들러 사용 + # RotatingFileHandler는 Windows에서 파일 잠금 문제로 롤링 실패 가능 + file_handler = WindowsSafeRotatingFileHandler( log_file, - maxBytes=10 * 1024 * 1024, + maxBytes=10 * 1024 * 1024, # 10MB backupCount=50, encoding="utf-8", ) diff --git a/modules/__pycache__/gemma_client.cpython-311.pyc b/modules/__pycache__/gemma_client.cpython-311.pyc index 3f9e8caccb3c120bbd63ea7b97977b7632cb91bf..5fe94a28d1fc29ff3848e483cee3f849d1af69d5 100644 GIT binary patch delta 5079 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 au2Ris6tB!;(LINN`&C8;?pGBU`hNhcfYMI@ delta 26032 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

HiTm1?z2x<|waJt9v! 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

RxL*=R3aHD%1X>{}M{@W%46v7A#sBt<9<_?$|2 z!FJ9TTy?hee5rrav|Pz)H*s>5rVC3$^hnRu10x5(q@U-hyeYLQtS;hgm5?UNdE17t zZ3C~a4XbMd`1_PDhzF}j)jU-arb;-fB;upY_bBTmWeq8SIZWko@dTZ!tzaaDecskb zCP>bD1k!tL?cAQdd|P+8tvgWzkXL)cY7eLOph11gnAFyL>cUBNA+NTDeQF!0wn29~ zJEygQX4;al7HRhJ^oMQ&?KQDp0u##@Z$>e~DppLHESD><)Lg0=E#}rX^QNs~(^mgh zR9kVS`cn0%bo>Bs+88!%^lyz3dgKLqUmQLhe6#{nX`k;rzyE^koQo@{y}63lHios0 zys{~*Z1QiK((2E5U+6v88>${R^4jXKw)%UW-|hZ>@3(tzS99$he9e>LnkV1uq{E#( z_c~pZoi48b2rT=f_+|ojf-by)_!GoVDE|n<8i{7KGc*#95PwG5qr`tEGT>+HWID`r3+PR`vKxISk(Xmc!V+sq`~c@gB-Pzr&flkm4HBk4PlOE_I;= zzBp7wq?EtTk4|*40(^I{9!`=smTV&HO0XZ6Nb0J{A6DW3e`Hs0uEBm(Q>$;xA#WSR z2xdmPY*HrKVIn7uIKUw@NNRzAZtk-1tsum`Gofd!Gr^JjUkg?i zSQ!`*iVNcZ3|D142k?b-*2 zI?dcb1!4R|jRy;f$Q2#?%uf+OFUZUv5fRA@xuS|@=b_Gi2SYc)t2e_84Y=*u4EzHK zV}1=ZtfM8b9Q{KLWBiCuiZC?*IE4EK7!xYKgk;GMI+#8PQ{4$AF0$WmF>m=MYRMd6 zoW1=Hcu-F?Wg?!FNZ2I=0tn0>;)zK7GOBwKz+g6jC!b{BXw~2w*k807sRH2Mjart9 z;J}`py+Lj(OZQ0}xUd0_VV^nMO!{ykc);HY>jXmK7JN!1Kb;Y13^bl?KHtoXtYM$X z$|ck6R0fIxgt7-9B9i(Ae!*0R8r5w9Js-dbgcs6NQchDbUJC%y&3wO<7d3=M4cx;L zjCmHk6~rKSMOTj>n0Ju&g$7TQ2q%R+rN%!tUg%TPm5}XFUNNj`$&G3WJiIJUvJ)F6;7Ij&^~DuLd|3WiSS|}@J+5R-kFd6BtK`D zhzzIW0N=w)9$k*Tw_MU@Cf}>nx9P~A>V$y*bh&wVCU!4V@;Nbi&m=}L-}pHJ84(Bp zhb6NGhMl<2H6e_xa_lNoAiqL^D`P|ec{uYk1pa~mS|W@ANTNd5P~X5IMvJpI9Zh%v ao6%{(m)x*-+VFBF4M(%{Su;isLjMm2_Q+-c delta 6631 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 literal 0 HcmV?d00001 diff --git a/modules/__pycache__/request_inpaint.cpython-311.pyc b/modules/__pycache__/request_inpaint.cpython-311.pyc index 09be0fa830699787169faf29e90c4272a796c300..6a332158bbca926bb355869445bcdbbc0dda9659 100644 GIT binary patch delta 1974 zcmZ{ke@s(X6vyvwwNShkaJ7uh zpfj5@>Rn`Gc7RSLLX`P*BHP@|{xHiXf||uN;x?Q=7Ii`6e(C<$J+DL5xR<=oJ@k0l31pYST?mqwQ3^C zA=Ac7@Cs=>YdU|QHeDyro?Q&>Issp#n?Nw?Khvog=OpLd&3u}t- zc4qT=;AR5g9&7czZ0`ZH6jaGYsq1xm7#zKTPnlTL;84bWWF%0w z0Zst=0moUm<`vv6->oUbxI=!?zsVePLlFRd@}-R{Erz4qu21F|32$YlGtaQnww#!K z5C952B=2fFfbl_j(QY5cZLB-I40p-DhvP+jn#Fb|;xjCxGg18|#BOIRI@hbC6J=*Q z=S@}y8=vTL2x2k^TYSF{U{YS|(svJ~#CfH&t<)N&q!L1JD96;4CDKudp6`F#rQ#fPH_$ z*{pnw5&E$J6X0jaGlMk;tSMkw0P%nz_^e> z0^K(D+)y`8XQM+4)H*H&vy^RIa;{EihQ)0~Iuyd|1cFO=+ref}jB7?j*w3YI{ze}n z!s;}M0ddTOkQX*kc|u}H=uz$G{qBdpCRIq~eHcxoHHuP#rlNp$EDs?EqVt=i5b{c6 zz791)Y{QR}^h6!PA0eU%Nv!!&!t>h4%VSiAh^|R`LxOontw!94){AAR5j*wu^LfEr zExT_XX-U4_+H>ojPi`GKdi$*&_TZAkw3Oy@HK>_Y?RNPB)oj6VuD;l*qc3qU^|B4a zY3b_dS~h@ZIY&evjV-UIKDrUSGdb4r$s%@cIJW?<;G1YvrPWz4niED5HYQ%Q*tgeT zw5GHtwIy|#hpd?wteL&KA?veSmJeH!-Vb#w@6!xg3Wh8N7c2#=^s?6ud%aP}N1Jo= z(O3G#NIa#>D9jU2XlnO3+?lqe*Q!iOZ z5l5G(G`*{p=4*%2JP8|Xy3u5-fs(0EGMVGPc43X5)cf3v=vo%{Yh8Y^5yy|Br}K{D KzxO|?QuJRv==1*o delta 1961 zcmZ{jdrVVT9LMjux3}*C4zQ(w6eyFDBEHAa`C^i}MV!%O(?px&OPUJ zWKcN&tzbBAFlagUTof#x)s2Q*iPN#*QeeJX#c@SER@8}WMJ(2FYn6BgjYbR6Ou7Q4 zq8Pdv#crL%qB=Yat6i#MHFSXo$GJ2(p7ogQ(qqHpks>WNvI+y9jm?kyvHqXzL{^!^ zbTS+NTN#C?u*xVr2U{j8v)E)X36!O>vNTup6J>gw&dOr2g=X`~YpivOwUh8%JawW4 z>yXK+Z0vp7amZ57R>vYG!(+4;y z)i)nUs8gDGz>81|J#=sxIw9RTXcAH`uy{!Dx=P3f$V>n@0P6vlsHH7gc?M)7&2QVH z9A7a#*ETm^o^@iy{g8A@(jPg9(4h2j`;T$?KY?pL09H{*@<6`AaOWndd4OL43c#;` zPQY&f9`FbKzTd3;6Xa*~VSmjs0m1IMh#$L%$TU#`Q~)(V1K<~NQAmyi4tPzWaM;2Dm)Zs*=q%RDoYt%KUg~OT}CG{|$ zmTr!VUC!4k-&DekSXPy&lG`Gz;VO|$SH6;UiPRk!>8-PjHg!enk4Abw9eukib97%_ zq_u0L{v%6dTUVs{ge9_fmt}NshmC$SY)zE!RAB+hW!2S&9B06jQ!yjQ$L^As{xzJd zv1v##3z6k?(bcILs_~tw0ME+|A;Cd5hct4!qnvojHs+)~VIyt5YG2;VjJLQS)Kdl? z{l<8;CSfQxag0NT>{m?oj;%q{f?dmojOM1w4=eXobx&=m z3>x#U81tz1T5$@T(++;If~$X?;haLdL=?_N*_Uv_SDd&+lp3yW7trf;ayTm*{-7b1 ztE9q1{3T>HT@jweBJYHkB1*pwr=kLBBwUR0`2w>B`Lpc5`#({+>EEiL4{iVe diff --git a/modules/__pycache__/tray_app.cpython-311.pyc b/modules/__pycache__/tray_app.cpython-311.pyc index 6423bda506a8454af45412a94dcddb0532284b22..ee53acacc22bb44caa6fb7b7403fe36178203e3c 100644 GIT binary patch delta 3140 zcma)8YitzP6~1?OcGuqZuHSF7UcbPD1ExHRX&x0&JK>wl>f(p^CR0v6NUl2soQmvGxX;B;+P!m-ZR{7yhs#b0O6seUgT?}=bqP`d(N3T5C0r$y%r7!8D5`Sjfv?MjD1dv+~u1mzW5t|qg9U>>{ukXHB~6K zhRT++iinkG6kp|x-QZ#-SW(nl^0?A^qr{cS+3GDdN)5hfdx%5r()Cms8J^IYQF_&b zrt#msILl``(|yVE!HV8W&QjqfW>hsZ@NuU5dn*sIlrqdlyocB@_ps-g9yrbPyyZ4} ztM&ZTthdIf)q}^SWe9qhQF9et+{ig%Xm4}K@ELX03#@*RUT|9JT_FvJ(QxDu!%>~@ zXKJBP__`{UJ0VRQGQdihDNS<%nbh%=Ih@LF*9}j z?N8T{;|Cl06)JkMFiiaC`o`jQJQ3AQq12U1sC?m)YBalfiLzOja8S zfjz!#t%Y*B<7}z`PrPyEQgJPu+sRn)}nsQ9p;p35>6Ulgq2QPB`C ztzGn3sFy5N)k2~>91Cni!(Fgl426>uLr%c5&2-w($4Yk$4jeGyxB;!wZ(@a7o?f5dN3=ktan6MHl6iM|N&?z_jlV;p@Lh*DuR|`M~ zytZs2F60JClq(!N7k1Ka( zpGDRM1MxRG5cUc7w!72q+z7NK>E7ZEpVAwC1D$b78Wa|$MumG|EXx;FN;{^;RPQb zi$hhVog*lw27uhbD1kid(1JHJEuFzDv`4OB9AUZj6XNGpG2V~XE5(DVZ%7Z98W&Ce z4>cRr>U{KwNfE618uo5y&9i*ZqMi(;&^ns2bsQU51c1W?Gzy{~!SPy#?beb)1^k4_ zGSY=HlCaa+x!O~nPys1ZS3yLajP5KiC9;g5oS=fBQv4~}x=XsDSR5ZZH35?(X9%Sj zP7*ZIW?s@9(9&`HD4eAwH>?2OG4XV{$p_J0-^|CdcKs_J9?8x%6!CT$zdvE&L)mUx zr9V1XnQE0wZx+5)*d&%%d(#^Jy7*?(trrK$jk2T9Ov%v(FOiB23g2YR@%J1BBd%j{ z*l{crNL-s76jxU2Z3!e*k1Oy5O-C7w zCsHtlQg4d2tJES=b@DWg*qR3Y*@0EB@nwhn?^e}4WcO%Me*U<{7B$K>aZp{og4)n2 z)+lfDMW)Hd`w8-YkiDV`?yn)m>TE}w$@yOK&Qp7L$ugDYvuK$V96w;D5^1=J3srH8 zMhX){_L!w0wOAkc=2}z1e@|{C^fsq1af}LO_pH3*l<>{|qH6VPl2Y6nNr6MZ&NE`c5rCJ4y-qjfHehTx~-;#Yq(A?uu$YCTZl zU`vf!Kwaz3bH6>BPNW8aCbyek+3VhYJ9YzA4EP8>KyV6h>I@jL$J8@P!wrpwm=n+w zkctl)_|`mP(Nv=5=uadK{QQ~-^<@Bzl&ztV6HLb!Xg|KO4X~ZkOj?iI2CQB3)dn=q zpqGq?b_}LXusdlQx-B|IdooXViK6lcdca2#@vppR22H&XLwyeZfZH_Gtlx;wHh*h^ z6&9ZxIB%XcFCKYo;EMUC`OeXq=;r&;%`=gX`;m^x&}_Ky+=27jS?%KCnXr04tWE}J zz2OV{zjN@OcLn}tmB8s2&UByZzOePe*o@M6UunFjG|nkrUN@^ecki*^!`VQ|9OJxB uLY2hXlG@2#^f%|ljfW2(&gF@|j%$?`ecRn`^lwwyZ8flMgZK7&j`&}z-|=Dq delta 2622 zcma)8X>3$g6n=O1rR{V|r^}RfrnJ_+vQ=3sn^KkvSQ-dmWJw;w%%dIJ&Ku5q(?Tg} zH6%(9fm|a(L#VL<2>~&qCAn)MVmXhaV9=MF2nToaC)X za+svx1%AUhr!s`3X^(0h8kp92XRB$8L8M!!D~EAGC4bRX&q{gJ)y}HYKe;9|wtzo$ zPcI0PjkyT21IP%>p~@;`M;StPk(?Dj_m&_YmfZYy zNfo~p%uDa~o@euWodZ(L*XtUPdffxkG5c;$ue8mb)diz>++Gp&qtjk#(90`pC)JD< zS8}q7ZWI_bGnk8_)s94dm1IohcXLC`$NhPY)3FD#t6G8}8>a-mSix8$iif|M7j`a0 zjV5U1pX7D0jXdBBHRS`9+05ko8&xYYL_J7gSrktrP{78vR`=oab*Qe^lvy>0EU`9&uLy zSOwn|NU;#V8z^y9lJI)&D+;k?e0tH3tcpJ<`g?6LvQ1k&u~o}tF=sT3V89YOwd)6Xdoe1MSBzS$_Kt!ePz>K6D%HOhh zX-@CfV)T1RE{tHhI;EEe)IK8e(SmY zZtC_H46&Mb)zm4Ia3^BH>KFhtxS1@w&Qlnkmz-P;N)MQW2AS3i*fAcj`EEl#pU^x^IfcSTp}~ zYReYU*P`D>Et7)j0L)Z831@I4+cI4ygoz;ra?CFhu_(tqeuYZZxN7+{1)awYMH%A9 zr=7_pCz?Js%gXq=`kKuPNn@;1VZcnMYp^NudI5hJi64zA)-7rU6b&xM)(MVH8ca0Hi${FdNp3)HPWg^zPI<}LdMtsWE> zOIYpa|Ib<&;GB2( Lr*lu*fg=4E9-UDJ diff --git a/modules/gemma_client.py b/modules/gemma_client.py index 13e705c..d660006 100644 --- a/modules/gemma_client.py +++ b/modules/gemma_client.py @@ -230,24 +230,162 @@ class GemmaTranslator: out.extend(resp.get("result", [])) return out - # ---- D) (선택) 카피 다듬기 ---- (이 메서드는 새 스펙에서 OCR가 단일 단계이므로 제거 또는 주석 처리) - # def polish_translations( - # self, - # product_name: str, - # category: str, - # id_text_pairs: List[Dict[str, Any]], - # batch_size: int = 16, - # ) -> List[Dict[str, Any]]: - # """ - # 입력: [{"id":1,"translation":"..."}] - # 반환: [{"id":1,"result":"..."}] - # """ - # if not id_text_pairs: - # return [] - # out: List[Dict[str, Any]] = [] - # for i in range(0, len(id_text_pairs), batch_size): - # chunk = id_text_pairs[i : i + batch_size] - # payload = {"product_name": product_name, "category": category, "items": chunk} - # resp = self._post("/translate_ocr_step2", payload) - # out.extend(resp.get("result", [])) - # return out + # ---- E) LLM API Translate (/api/v1/llm/run) ---- + def run_llm_translation( + self, + product_name: str, + category: str, + ocr_results: List[Dict[str, Any]], + job_type: str = "ocr_translator_step1", + prompt_name: str = "ocr_translator_step1", + retry_count: int = 3, + steps: int = 1 + ) -> List[str]: + """ + 새로운 LLM 번역 API (/api/v1/llm/run) 사용 + 입력: OCR 결과 리스트 [{'text': '...'}, ...] + 출력: 번역된 문자열 리스트 (원래 순서 유지) + + Args: + product_name: 상품명 + category: 카테고리 + ocr_results: OCR 결과 리스트 + job_type: 작업 타입 + prompt_name: 프롬프트 이름 + retry_count: 재시도 횟수 (1-5) + steps: 번역 단계 (1=직역만, 2=직역+마케팅톤 변환) + """ + if not ocr_results: + return [] + + # 1. items 구성 + items = [] + source_to_orig_idx = {} + for i, res in enumerate(ocr_results): + text = (res.get("text") or "").strip() + if text: + item_id = len(items) + 1 + items.append({"id": item_id, "source": text}) + source_to_orig_idx[item_id] = i + + if not items: + return [""] * len(ocr_results) + + # 2. API 요청 payload 구성 + payload = { + "category": category, + "items": items, + "job_type": job_type, + "product_name": product_name, + "prompt_name": prompt_name + } + + # Query parameters: retry, steps + # steps 값 검증 (1 또는 2만 허용) + steps = max(1, min(2, steps)) + path = f"/api/v1/llm/run?retry={retry_count}&steps={steps}" + + try: + # 3. 요청 전송 + # _post 메서드는 base_url + path로 요청하므로, base_url 설정이 중요함. + # 사용자 제공 URL이 /api/v1/llm/run 이므로, base_url이 호스트 루트여야 함. + # 만약 base_url이 /api 등을 포함하고 있다면 조정 필요. + # 여기서는 _post가 path를 그대로 붙인다고 가정. + + resp = self._post(path, payload) + + # 4. 응답 처리 + # 응답 스키마: { "success": bool, "results": "string", "error": "string", ... } + if not resp.get("success"): + error_msg = resp.get("error", "Unknown error") + self.log.error(f"[GemmaTranslator] LLM API Error: {error_msg}") + # 실패 시 빈 문자열 또는 원본 반환? 여기선 빈 문자열 리스트로 둠 (혹은 예외 발생) + raise GemmaTranslatorError(f"LLM API returned success=False: {error_msg}") + + results_data = resp.get("results") + + # 결과가 없거나 비어있으면 처리 + if not results_data: + # results가 None이거나 빈 리스트/문자열인 경우 + return [""] * len(ocr_results) + + translated_items = [] + + # 1. 리스트인 경우 (표준 서버 응답: List[Dict]) + if isinstance(results_data, list): + translated_items = results_data + + # 2. 딕셔너리인 경우 (단일 객체로 온 경우 대비) + elif isinstance(results_data, dict): + translated_items = [results_data] + + # 3. 문자열인 경우 (JSON 텍스트로 온 경우 - 유연한 대응) + elif isinstance(results_data, str): + try: + translated_items = json.loads(results_data) + except json.JSONDecodeError: + # JSON 파싱 실패 시 Markdown 코드 블록 제거 시도 + clean_str = results_data.strip() + + # ```json 또는 ``` 제거 + if clean_str.startswith("```"): + # 첫 줄 제거 (```json ... 또는 ``` ...) + parts = clean_str.split('\n', 1) + if len(parts) > 1: + clean_str = parts[1] + else: + clean_str = clean_str.replace("```", "") + + if clean_str.endswith("```"): + clean_str = clean_str[:-3] + + try: + translated_items = json.loads(clean_str.strip()) + except json.JSONDecodeError: + self.log.error(f"[GemmaTranslator] LLM results is not valid JSON: {results_data[:100]}...") + raise GemmaTranslatorError("LLM API results parsing failed") + + else: + self.log.error(f"[GemmaTranslator] Unexpected results type: {type(results_data)}") + raise GemmaTranslatorError(f"Unexpected results type: {type(results_data)}") + + # 5. 결과 매핑 + + out_ko = [""] * len(ocr_results) + # translated_items가 리스트인지 확인 + if isinstance(translated_items, list): + for item in translated_items: + # item 구조 확인: {"id": 1, "translation": "..."} (서버 로그 기반) + item_id = int(item.get("id", 0)) + + # 결과 필드 찾기 (translation > result > translated > source) + res_text = "" + if "translation" in item: + res_text = item["translation"] + elif "result" in item: + res_text = item["result"] + elif "translated" in item: + res_text = item["translated"] + elif "source" in item: + # source만 있고 번역이 없는 경우? (거의 없겠지만) + res_text = item["source"] + + # None 체크 + if res_text is None: + res_text = "" + + orig_idx = source_to_orig_idx.get(item_id) + if orig_idx is not None: + out_ko[orig_idx] = str(res_text).strip() + else: + self.log.warning(f"[GemmaTranslator] Unexpected translated_items type: {type(translated_items)}") + + return out_ko + + except Exception as e: + self.log.error(f"[GemmaTranslator] run_llm_translation failed: {e}") + # Fallback behavior or re-raise? + # User wants to replace google translate. If this fails, maybe we should return original texts or empty? + # Or re-raise to let caller handle (e.g. fallback to Google). + raise e + diff --git a/modules/image_processor3.py b/modules/image_processor3.py index e13c5c9..10bd044 100644 --- a/modules/image_processor3.py +++ b/modules/image_processor3.py @@ -3,6 +3,7 @@ import asyncio import requests import time import logging +import threading from urllib.parse import urlparse import sys import re @@ -33,6 +34,15 @@ except Exception: except Exception: GemmaTranslator = None # 사용 시 체크 후 동작 +# OpenRouter 번역 클라이언트(옵셔널): 다양한 LLM 모델 지원 +try: + from modules.openrouter_client import OpenRouterTranslator +except Exception: + try: + from openrouter_client import OpenRouterTranslator + except Exception: + OpenRouterTranslator = None + # from modules.background_removal_module import BackgroundRemovalModule # from modules.background_removal_module_pp import PPMattingBackgroundRemovalModule # (변경) @@ -143,16 +153,44 @@ class ImageProcessor3: self.ocr_module = None # 명시적으로 None 설정 - # try: - # self.ai_translator = GemmaTranslator( - # base_url=self.toggle_states.get("gemma_api_base_url", "http://192.168.0.146:8000"), - # timeout=int(self.toggle_states.get("gemma_api_timeout", 120)), - # ) - # self.logger.log(f"gemma_api_base_url: {self.ai_translator.base_url}", level=logging.DEBUG) - # self.logger.log(f"GemmaTranslator 연결: base={self.ai_translator.base_url}", level=logging.INFO) - # except Exception as e: - # self.logger.log(f"GemmaTranslator 연결 실패: {e}", level=logging.ERROR, exc_info=True) - # self.ai_translator = None + # AI 번역기 초기화 (OpenRouter 또는 Gemma 선택) + # toggle_states에서 llm_provider 확인: "openrouter" 또는 "gemma" + llm_provider = self.toggle_states.get("llm_provider", "gemma") + self.ai_translator = None + + if llm_provider == "openrouter" and OpenRouterTranslator is not None: + try: + openrouter_api_key = self.toggle_states.get("openrouter_api_key", "") + openrouter_model_id = self.toggle_states.get("openrouter_model_id", "xiaomi/mimo-v2-flash:free") + + if openrouter_api_key: + self.ai_translator = OpenRouterTranslator( + api_key=openrouter_api_key, + model_id=openrouter_model_id, + timeout=int(self.toggle_states.get("llm_api_timeout", 120)), + logger=self.logger + ) + self.logger.log(f"✅ OpenRouterTranslator 초기화 성공: 모델={openrouter_model_id}", level=logging.INFO) + else: + self.logger.log("⚠️ OpenRouter API 키가 설정되지 않음. Gemma로 폴백.", level=logging.WARNING) + llm_provider = "gemma" # 폴백 + except Exception as e: + self.logger.log(f"❌ OpenRouterTranslator 초기화 실패: {e}. Gemma로 폴백.", level=logging.ERROR, exc_info=True) + llm_provider = "gemma" # 폴백 + + # Gemma 초기화 (기본 또는 폴백) + if self.ai_translator is None and GemmaTranslator is not None: + try: + self.ai_translator = GemmaTranslator( + base_url=self.toggle_states.get("gemma_api_base_url", "http://192.168.0.146:8008"), + timeout=int(self.toggle_states.get("gemma_api_timeout", 120)), + logger=self.logger + ) + self.logger.log(f"gemma_api_base_url: {self.ai_translator.base_url}", level=logging.DEBUG) + self.logger.log(f"✅ GemmaTranslator 연결: base={self.ai_translator.base_url}", level=logging.INFO) + except Exception as e: + self.logger.log(f"❌ GemmaTranslator 연결 실패: {e}", level=logging.ERROR, exc_info=True) + self.ai_translator = None # try: @@ -226,21 +264,42 @@ class ImageProcessor3: except Exception as e: self.logger.log(f"GoogleTranslate 초기화 실패: {e}", level=logging.ERROR, exc_info=True) - # MIGAN ONNX 파이프라인 준비(옵션 토글 기반) + # MIGAN ONNX 파이프라인 준비 (base_dir 기반 고정 경로 사용) + # ※ toggle_states['migan_onnx_path']는 더 이상 사용하지 않음 try: from modules.migan_module import build_migan_from_toggle - # MIGAN이 실제로 사용될 때만 초기화 (inpaint_method이 'migan'이거나 로컬 inpaint_method가 'migan'일 때) + + # base_dir 기반 MIGAN 모델 경로 (고정) + migan_model_candidates = [ + os.path.join(self.base_dir, "migan_onnx", "migan_pipeline_v2_simplified.onnx"), + os.path.join(self.base_dir, "migan_onnx", "migan_pipeline_v2.onnx"), + ] + + migan_onnx_path = "" + for candidate in migan_model_candidates: + if os.path.exists(candidate): + migan_onnx_path = candidate + self.logger.log(f"[MIGAN] 모델 경로 확인: {migan_onnx_path}", level=logging.DEBUG) + break + + if not migan_onnx_path: + self.logger.log(f"[MIGAN] 모델 파일을 찾을 수 없음 (base_dir: {self.base_dir})", level=logging.WARNING) + self.logger.log(f"[MIGAN] 시도한 경로: {migan_model_candidates}", level=logging.DEBUG) + + # MIGAN 초기화 조건 inpaint_method = self.toggle_states.get("inpaint_method", "request") local_inpaint_method = self.toggle_states.get("local_inpaint_method", "migan") - should_init_migan = ( - self.toggle_states.get("migan_onnx_path") and + migan_onnx_path and (inpaint_method == "migan" or local_inpaint_method == "migan") ) if should_init_migan: # GPU 상태에 따라 CUDA 사용 여부 결정 enhanced_toggle_states = self.toggle_states.copy() + # migan_onnx_path를 내부 고정 경로로 덮어쓰기 + enhanced_toggle_states["migan_onnx_path"] = migan_onnx_path + if self.gpu_manager and self.gpu_manager.can_use_cuda: enhanced_toggle_states["migan_use_cuda"] = enhanced_toggle_states.get("migan_use_cuda", False) self.logger.log(f"MIGAN CUDA 사용 설정: {enhanced_toggle_states['migan_use_cuda']}", level=logging.DEBUG) @@ -253,10 +312,15 @@ class ImageProcessor3: self.logger.log(f"[MIGAN] 초기화 완료: gpu_manager 속성={hasattr(self.migan, 'gpu_manager')}, 값={getattr(self.migan, 'gpu_manager', None)}", level=logging.DEBUG) else: self.migan = None - self.logger.log(f"MIGAN 초기화 건너뜀: inpaint_method={inpaint_method}, local_inpaint_method={local_inpaint_method}, migan_onnx_path={bool(self.toggle_states.get('migan_onnx_path'))}", level=logging.DEBUG) + self.logger.log(f"MIGAN 초기화 건너뜀: inpaint_method={inpaint_method}, local_inpaint_method={local_inpaint_method}, migan_onnx_path={bool(migan_onnx_path)}", level=logging.DEBUG) + # MIGAN 모델이 없으면 inpaint_method를 cv로 강제 설정 + if not migan_onnx_path: + self.inpaint_method = 'cv' + self.logger.log(f"[MIGAN] 모델 없음 → inpaint_method를 'cv'로 강제 설정", level=logging.WARNING) except Exception as e: self.migan = None - self.logger.log(f"MIGAN 초기화 실패: {e}", level=logging.ERROR, exc_info=True) + self.inpaint_method = 'cv' # 초기화 실패 시 cv로 폴백 + self.logger.log(f"MIGAN 초기화 실패 → inpaint_method를 'cv'로 강제 설정: {e}", level=logging.ERROR, exc_info=True) # 인페인팅 실행 정보(마지막 사용 방식/장치) 추적용 내부 상태 self._last_inpaint_used = None @@ -264,6 +328,16 @@ class ImageProcessor3: # 외부 서버 헬스 체크 플래그 self.is_external_server_alive = False + # 초기 헬스체크 실행 (비동기로 실행하거나, 여기서 한 번 체크) + try: + if self.check_external_server_availability(): + self.is_external_server_alive = True + self.logger.log(f"외부 인페인팅 서버 활성화 확인됨: {self.toggle_states.get('request_inpainting_server_url')}", level=logging.INFO) + except Exception: + pass + + # MIGAN 동시 접근 방지용 락 + self._migan_lock = threading.Lock() except Exception as e: self.logger.log(f"ImageProcessor3 초기화 중 치명적 오류 발생: {e}", level=logging.ERROR, exc_info=True) @@ -378,7 +452,14 @@ class ImageProcessor3: self.is_member_valid = self.toggle_states.get('membership_level', 'basic') == 'vip' or self.authenticated_by_admin # 2. 인페인팅 설정 업데이트 - self.inpaint_method = self.toggle_states.get("inpaint_method", "migan") + # MIGAN이 초기화되지 않은 경우 inpaint_method를 'cv'로 강제 유지 + requested_inpaint_method = self.toggle_states.get("inpaint_method", "migan") + if getattr(self, 'migan', None) is None and requested_inpaint_method == 'migan': + self.inpaint_method = 'cv' + self.logger.log(f"[UpdateToggle] MIGAN 미초기화 상태 → inpaint_method를 'cv'로 강제 유지 (요청: {requested_inpaint_method})", level=logging.WARNING) + else: + self.inpaint_method = requested_inpaint_method + self.use_local_rembg = self.toggle_states.get("use_local_rembg", False) self.local_model_name = self.toggle_states.get("local_model_name", 'birefnet-general-lite') @@ -544,7 +625,7 @@ class ImageProcessor3: return True return False - async def process_single_image(self, original_image_url, index, delay=1.0, file_prefix=""): + async def process_single_image(self, original_image_url, index, delay=1.0, file_prefix="", model_name: str = "migan"): """ 단일 이미지를 처리합니다 (다운로드 -> OCR -> 인페인팅) @@ -577,7 +658,7 @@ class ImageProcessor3: # self.logger.log(f"unwanted_texts: {self.unwanted_texts}", level=logging.DEBUG) self.logger.log(f"이미지 번역시작", level=logging.DEBUG) - self.logger.log(f"toggle_states: {self.toggle_states}", level=logging.DEBUG) + # self.logger.log(f"toggle_states: {self.toggle_states}", level=logging.DEBUG) try: # 0. 이미지 URL 유효성 체크 (http/https & 이미지 확장자) if not original_image_url or not isinstance(original_image_url, str): @@ -698,27 +779,41 @@ class ImageProcessor3: blur_size = 15 loop = asyncio.get_running_loop() - _t_trans = _time.time() - _t_mask = _time.time() + _t_parallel_start = _time.time() - translate_future = loop.run_in_executor( - None, - lambda: self.batch_google_translate_texts(filter_ocr_results) - ) - mask_future = loop.run_in_executor( - None, - lambda: self.mask_module.create_masks( - image_path=local_image_path, - ocr_results=filter_ocr_results, - mask_option="basic", - expansion_size=expansion_size, - blur_size=blur_size + # 개별 태스크 완료 시간 기록용 변수 + _translate_done_time = None + _mask_done_time = None + + async def timed_translate(): + nonlocal _translate_done_time + result = await loop.run_in_executor( + None, + lambda: self.translate_ocr_results(filter_ocr_results) ) - ) + _translate_done_time = _time.time() + return result - translated_texts, masks = await asyncio.gather(translate_future, mask_future) - _timings_ms["translate"] = (_time.time() - _t_trans) * 1000.0 - _timings_ms["mask"] = (_time.time() - _t_mask) * 1000.0 + async def timed_mask(): + nonlocal _mask_done_time + result = await loop.run_in_executor( + None, + lambda: self.mask_module.create_masks( + image_path=local_image_path, + ocr_results=filter_ocr_results, + mask_option="basic", + expansion_size=expansion_size, + blur_size=blur_size + ) + ) + _mask_done_time = _time.time() + return result + + translated_texts, masks = await asyncio.gather(timed_translate(), timed_mask()) + + # 개별 태스크 시간 계산 (병렬 시작 시점 기준) + _timings_ms["translate"] = (_translate_done_time - _t_parallel_start) * 1000.0 if _translate_done_time else 0 + _timings_ms["mask"] = (_mask_done_time - _t_parallel_start) * 1000.0 if _mask_done_time else 0 self.logger.log(f"translated_texts: {translated_texts}", level=logging.DEBUG) self.logger.log(f"마스크 생성 완료", level=logging.DEBUG) @@ -783,13 +878,19 @@ class ImageProcessor3: self.logger.log(f"is_member_valid: {self.is_member_valid}", level=logging.DEBUG) # 인페인팅 방법 설정 - self.set_inpaint_method(file_prefix) - self.logger.log(f"최종 inpaint_method: {self.inpaint_method}", level=logging.DEBUG) + preferred_method = self.set_inpaint_method(file_prefix) + self.logger.log(f"최종 inpaint_method: {preferred_method}", level=logging.DEBUG) # self.inpaint_method = 'migan' # 인페인팅 실행 (폴백 순서: 자체서버 > GPU > CPU) _t = _time.time() - inpainted_image = self.execute_inpaint_with_fallback(local_image_path, masks, ocr_count) + + # 동기 함수인 execute_inpaint_with_fallback을 스레드 풀에서 실행 + inpainted_image = await loop.run_in_executor( + None, + lambda: self.execute_inpaint_with_fallback(local_image_path, masks, ocr_count, preferred_method, model_name=model_name) + ) + _timings_ms["inpaint"] = (_time.time() - _t) * 1000.0 self.logger.log(f"인페인팅 완료", level=logging.DEBUG) # # 개발환경에서 인페인트 결과 디버깅 저장 @@ -881,33 +982,33 @@ class ImageProcessor3: except Exception: pass - def set_inpaint_method(self, file_prefix: str) -> None: - """인페인팅 방법 설정 (CPU=cv, GPU=migan, 자체서버=request, 기타=cv)""" - # file_prefix → toggle_states 키 매핑 - key_by_prefix = { - "thumb": "thumb_trans_type", - "detail": "detail_IMGTrans_type", - "option": "optionIMGTrans_type", # 수정: option_IMGTrans_type → optionIMGTrans_type - } - - # 해당 키가 없으면 기본 'CPU' - target_key = key_by_prefix.get(file_prefix, "") - trans_type = self.toggle_states.get(target_key, "CPU") - - # 변환 타입 → 실제 메서드 매핑 - method_map = { - "CPU": "cv", # CPU 선택 시 OpenCV 인페인팅 - "GPU": "migan", # GPU 선택 시 MIGAN 인페인팅 - "자체서버": "external_request", # 자체서버 선택 시 Request 인페인팅 - } - - self.inpaint_method = method_map.get(trans_type, "cv") # 기타는 cv로 폴백 - - self.logger.log(f"[set_inpaint_method] prefix={file_prefix}, target_key={target_key}, trans_type={trans_type} → inpaint_method={self.inpaint_method}", level=logging.DEBUG) - - def execute_inpaint_with_fallback(self, local_image_path: str, masks, ocr_count: int): + def set_inpaint_method(self, file_prefix: str) -> str: + """인페인팅 방법 설정 + + 우선순위: + 1. AUTO 모드에서 이미 external_request가 선택된 경우 → external_request + 2. self.inpaint_method가 설정된 경우 → 해당 값 사용 + 3. 기본값 → migan """ - 인페인팅 실행 - toggle_states['inpaint_method'] 설정에 따라 분기. + + # 1. AUTO 모드에서 이미 external_request가 선택된 경우 우선 사용 + current_method = getattr(self, 'inpaint_method', None) + if current_method == 'external_request': + self.logger.log(f"[set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지", level=logging.DEBUG) + return "external_request" + + # 2. self.inpaint_method가 설정된 경우 해당 값 사용 + if current_method and current_method in ('migan', 'cv', 'external_request'): + self.logger.log(f"[set_inpaint_method] 기존 설정 사용 → {current_method}", level=logging.DEBUG) + return current_method + + # 3. 기본값: migan + self.logger.log(f"[set_inpaint_method] 기본값 사용 → migan", level=logging.DEBUG) + return "migan" + + def execute_inpaint_with_fallback(self, local_image_path: str, masks, ocr_count: int, preferred_method: str = None, model_name: str = "migan"): + """ + 인페인팅 실행 - preferred_method 설정에 따라 분기. 'external_request'인 경우 VIP 체크 후 외부 서버 시도, 실패 시 MIGAN 폴백. 그 외의 경우(또는 폴백 시) MIGAN 사용. @@ -915,6 +1016,7 @@ class ImageProcessor3: local_image_path: 이미지 파일 경로 masks: 마스크 데이터 ocr_count: OCR 결과 개수 + preferred_method: 선호하는 인페인팅 방식 Returns: 인페인팅된 이미지 또는 None @@ -924,24 +1026,27 @@ class ImageProcessor3: inpaint_before_mb = inpaint_before_mem.used / 1024 / 1024 inpainted_image = None + current_method = preferred_method - # 1. 사용자 설정 확인 (self.inpaint_method가 설정되어 있으면 최우선, 없으면 토글값) - # set_inpaint_method() 또는 자동 로직에 의해 설정된 값이 있으면 그것을 따름 - preferred_method = getattr(self, 'inpaint_method', None) - if not preferred_method: - preferred_method = self.toggle_states.get("inpaint_method", "migan") + # 1. 사용자 설정 확인 (preferred_method가 설정되어 있으면 최우선, 없으면 토글값) + if not current_method: + current_method = self.toggle_states.get("inpaint_method", "migan") server_url = self.toggle_states.get("request_inpainting_server_url", "") # 2. External Request 모드일 때 처리 - if preferred_method == "external_request": + if current_method == "external_request": if self.is_member_valid: - if not self.is_external_server_alive: + # 실시간 헬스 체크 수행 (캐시된 값 대신) + is_server_alive = self.check_external_server_availability() + self.is_external_server_alive = is_server_alive # 캐시 업데이트 + + if not is_server_alive: self.logger.log("외부 서버 상태 비정상(헬스 체크 실패) -> 로컬 MIGAN으로 폴백", level=logging.WARNING) elif server_url and str(server_url).strip().startswith("http"): # 외부 서버 시도 - self.inpaint_method = 'external_request' - inpainted_image = self._try_external_inpaint(local_image_path, masks, str(server_url).strip()) + current_method = 'external_request' + inpainted_image = self._try_external_inpaint(local_image_path, masks, str(server_url).strip(), model_name=model_name) if inpainted_image is not None: self._last_inpaint_used = "external_request" @@ -954,11 +1059,80 @@ class ImageProcessor3: self.logger.log("VIP 회원이 아님 -> 로컬 MIGAN으로 폴백", level=logging.WARNING) # 3. 로컬 MIGAN 인페인팅 (기본값, 또는 외부 요청 실패/조건 미충족 시) - if inpainted_image is None: - self.inpaint_method = 'migan' + if inpainted_image is None and current_method != 'cv': + current_method = 'migan' inpainted_image = self._try_migan_inpaint(local_image_path, masks) # _try_migan_inpaint 내부에서 _last_inpaint_used 설정함 + # 4. CV 인페인팅 폴백 (MIGAN 실패, 미초기화 또는 애초에 cv 선택 시) + if inpainted_image is None: + # 명시적으로 cv를 선택했거나, 위 단계들에서 모두 실패하여 최종 폴백이 필요한 경우 + current_method = 'cv' + + # MIGAN/Server 실패 로그가 이미 출력되었을 수 있으므로, 여기서 CV 시도 로그 출력 + self.logger.log("인페인팅 폴백: OpenCV(Telea) 방식 시도", level=logging.INFO) + + try: + # 원본 이미지 로드 + img = cv2.imread(local_image_path) + if img is None: + raise Exception(f"이미지 로드 실패: {local_image_path}") + + # 마스크 병합 (다양한 형태 지원) + combined_mask = np.zeros(img.shape[:2], dtype=np.uint8) + mask_count = 0 + + if isinstance(masks, np.ndarray): + # 단일 numpy 배열인 경우 + if masks.ndim == 2: + if masks.shape != combined_mask.shape: + masks = cv2.resize(masks, (combined_mask.shape[1], combined_mask.shape[0])) + combined_mask = masks.astype(np.uint8) + mask_count = 1 + self.logger.log(f"[CV Inpaint] numpy 마스크 사용: shape={masks.shape}", level=logging.DEBUG) + elif isinstance(masks, list): + for m_item in masks: + if isinstance(m_item, str) and os.path.exists(m_item): + m_img = cv2.imread(m_item, cv2.IMREAD_GRAYSCALE) + if m_img is not None: + # 크기 맞추기 + if m_img.shape != combined_mask.shape: + m_img = cv2.resize(m_img, (combined_mask.shape[1], combined_mask.shape[0])) + combined_mask = cv2.bitwise_or(combined_mask, m_img) + mask_count += 1 + elif isinstance(m_item, np.ndarray) and m_item.ndim == 2: + # 리스트 내 numpy 배열 + if m_item.shape != combined_mask.shape: + m_item = cv2.resize(m_item, (combined_mask.shape[1], combined_mask.shape[0])) + combined_mask = cv2.bitwise_or(combined_mask, m_item.astype(np.uint8)) + mask_count += 1 + self.logger.log(f"[CV Inpaint] 리스트 마스크 병합: {mask_count}개", level=logging.DEBUG) + elif isinstance(masks, str) and os.path.exists(masks): + # 단일 파일 경로 + m_img = cv2.imread(masks, cv2.IMREAD_GRAYSCALE) + if m_img is not None: + if m_img.shape != combined_mask.shape: + m_img = cv2.resize(m_img, (combined_mask.shape[1], combined_mask.shape[0])) + combined_mask = m_img + mask_count = 1 + self.logger.log(f"[CV Inpaint] 단일 파일 마스크 사용: {masks}", level=logging.DEBUG) + + # 마스크가 비어있으면 경고 + if np.sum(combined_mask) == 0: + self.logger.log(f"[CV Inpaint] 경고: 마스크가 비어있음 (mask_count={mask_count}, masks type={type(masks).__name__})", level=logging.WARNING) + + # 인페인팅 실행 + inpainted_image = cv2.inpaint(img, combined_mask, 3, cv2.INPAINT_TELEA) + + if inpainted_image is not None: + self.logger.log("OpenCV 인페인팅 성공", level=logging.DEBUG) + self._last_inpaint_used = "cv" + self._last_inpaint_device = "CPU" + except Exception as e: + self.logger.log(f"OpenCV 인페인팅 실패: {e}", level=logging.WARNING) + inpainted_image = None + + # 메모리 추적: 인페인팅 완료 후 inpaint_after_mem = psutil.virtual_memory() inpaint_after_mb = inpaint_after_mem.used / 1024 / 1024 @@ -966,7 +1140,7 @@ class ImageProcessor3: inpaint_change_percent = (inpaint_change_mb / inpaint_before_mb) * 100 if inpaint_before_mb > 0 else 0 self.logger.log( f"메모리 변화 [인페인팅]: {inpaint_before_mb:.1f}MB -> {inpaint_after_mb:.1f}MB " - f"({inpaint_change_mb:+.1f}MB, {inpaint_change_percent:+.1f}%) - 방법: {self.inpaint_method}", + f"({inpaint_change_mb:+.1f}MB, {inpaint_change_percent:+.1f}%) - 방법: {current_method}", level=logging.DEBUG if abs(inpaint_change_mb) < 10 else logging.INFO ) @@ -1004,8 +1178,6 @@ class ImageProcessor3: self.logger.log(f"자체서버 인페인팅 중 오류: {e}", level=logging.WARNING, exc_info=True) return None - - def check_external_server_availability(self): """외부 인페인팅 서버 유효성 체크""" try: @@ -1019,7 +1191,7 @@ class ImageProcessor3: except Exception: return False - def _try_external_inpaint(self, local_image_path: str, masks, server_url: str): + def _try_external_inpaint(self, local_image_path: str, masks, server_url: str, model_name: str = "migan"): """외부 서버 인페인팅 시도""" try: if self.request_ai_server is None: @@ -1027,7 +1199,7 @@ class ImageProcessor3: self.logger.log(f"외부 인페인팅 시도: {server_url}", level=logging.DEBUG) # 모델명은 필요하면 토글에서 가져올 수 있음, 현재는 기본값 - result = self.request_ai_server.request_external_inpaint(local_image_path, masks, server_url) + result = self.request_ai_server.request_external_inpaint(local_image_path, masks, server_url, model_name=model_name) return result except Exception as e: self.logger.log(f"외부 인페인팅 중 오류: {e}", level=logging.WARNING, exc_info=True) @@ -1040,8 +1212,31 @@ class ImageProcessor3: self.logger.log("MIGAN 모듈이 초기화되지 않아 건너뜀", level=logging.DEBUG) return None - self.logger.log("MIGAN 인페인팅 시도", level=logging.DEBUG) - result = self.migan.inpaint(local_image_path, masks) + # MIGAN 실행 시 락 처리 + # - DirectML/CUDA: 동시성 이슈(드라이버 행) 방지를 위해 락 사용 권장 + # - CPU: 동시 실행해도 안전하므로 락 없이 병렬 처리 가능 (CPU 점유율은 올라감) + is_cpu_mode = False + try: + # 현재 세션의 provider 확인 + if hasattr(self.migan, "session") and hasattr(self.migan.session, "get_providers"): + providers = self.migan.session.get_providers() + if providers and "CPUExecutionProvider" in providers[0]: # CPU가 최우선 순위인 경우 + is_cpu_mode = True + except Exception: + pass + + if is_cpu_mode: + # CPU 모드: 락 없이 병렬 실행하되, 과도한 점유 방지를 위해 약간의 슬립(양보) + # (OS 스케줄러가 알아서 분배하겠지만, 명시적 양보로 UI 프리징 등 방지) + time.sleep(0.01) + self.logger.log("MIGAN 인페인팅 시도 (CPU Mode - No Lock)", level=logging.DEBUG) + result = self.migan.inpaint(local_image_path, masks) + else: + # GPU(DirectML/CUDA) 모드: 락 사용 + with self._migan_lock: + self.logger.log("MIGAN 인페인팅 시도 (GPU Mode - Lock Acquired)", level=logging.DEBUG) + result = self.migan.inpaint(local_image_path, masks) + if result is not None: self.logger.log("MIGAN 인페인팅 성공", level=logging.DEBUG) # 사용 장치 기록 @@ -1468,6 +1663,58 @@ class ImageProcessor3: return texts + def batch_llm_translate_texts(self, ocr_results, delimiter='\n'): + """ + LLM API를 이용한 번역 메서드. + batch_google_translate_texts 대체용. + """ + # 1. LLM 클라이언트 확인 + if not self.ai_translator: + # self.logger.log("LLM Translator(ai_translator)가 초기화되지 않음. 구글 번역으로 폴백.", level=logging.WARNING) + return self.batch_google_translate_texts(ocr_results, delimiter) + + # 2. 필요한 파라미터 준비 (toggle_states 등에서 가져오기) + # product_name과 category가 필수이나, 현재 문맥에서 명확하지 않으면 기본값 사용 + product_name = self.toggle_states.get("product_name", "Unknown Product") + category = self.toggle_states.get("category", "General") + + # job_type, prompt_name (기본값 설정) + job_type = "ocr_translator_step1" + prompt_name = "ocr_translator_step1" + + # steps: 번역 단계 (1=직역만, 2=직역+마케팅톤 변환) + # toggle_states에서 가져오거나 기본값 1 사용 + steps = int(self.toggle_states.get("llm_translation_steps", 1)) + + try: + # 3. LLM 번역 요청 + return self.ai_translator.run_llm_translation( + product_name=product_name, + category=category, + ocr_results=ocr_results, + job_type=job_type, + prompt_name=prompt_name, + retry_count=3, + steps=steps + ) + except Exception as e: + self.logger.log(f"LLM 번역 실패: {e}. 구글 번역으로 폴백.", level=logging.ERROR, exc_info=True) + # 실패 시 구글 번역으로 폴백 + return self.batch_google_translate_texts(ocr_results, delimiter) + + + def translate_ocr_results(self, ocr_results): + """ + 사용자 설정(toggle_states)에 따라 번역 방식을 선택하여 실행 + """ + method = self.toggle_states.get("translation_method", "google") + + if method == "llm": + return self.batch_llm_translate_texts(ocr_results) + else: + return self.batch_google_translate_texts(ocr_results) + + def opencv_inpaint(self, image_path, mask, method='telea', radius=3): """MIGAN 통일 이후 비활성화(호환용). 항상 None 반환""" return None diff --git a/modules/image_worker.py b/modules/image_worker.py index 14483ba..d2bd21b 100644 --- a/modules/image_worker.py +++ b/modules/image_worker.py @@ -282,85 +282,34 @@ def worker_main( except Exception as e: logger.error(f"추가 READY 신호 전송 실패: {e}") - idle_log_last = 0.0 - while True: + # ── 작업 루프 (비동기) ──────────────────────────────────────── + + async def process_task_async(task): + uid = task.get("id") + cmd = task.get("cmd") + kwargs = task.get("kwargs", {}) + try: - # 주기적 상태 출력을 위해 타임아웃 설정 - logger.debug(f"큐에서 작업 대기 중... (PID: {os.getpid()})") - task = task_q.get(timeout=60) # 60초 타임아웃 - #logger.info(f"🔥 작업 수신 성공: {task}") - logger.info(f"🔥 작업 수신 성공") - except queue.Empty: - # 유휴 로그는 10분에 한 번만 기록해 로그 스팸을 줄인다. - now_ts = time.time() - if now_ts - idle_log_last >= 600: - idle_log_last = now_ts - logger.info("대기 중(유휴)") - continue - except Exception as e: - logger.error(f"작업 수신 중 오류: {e}", exc_info=True) - continue - - if task is None: - logger.info("Shutdown signal 수신 → 종료") - try: - # 종료 시 임시 폴더 정리(5분 경과 파일만) - base_program = os.environ.get("PROGRAMDATA", r"C:\\ProgramData") - app_data_dir = os.path.join(base_program, "ImgWorker") - def _cleanup_dir(dp: str, older_than_sec: int = 300): - try: - now_ts = time.time() - thr = max(0, int(older_than_sec or 0)) - for root, dirs, files in os.walk(dp, topdown=False): - for fn in files: - fp = os.path.join(root, fn) - try: - if thr <= 0: - os.remove(fp) - else: - mt = os.path.getmtime(fp) - if (now_ts - mt) >= thr: - os.remove(fp) - except Exception: - pass - for dn in dirs: - full = os.path.join(root, dn) - try: - if not os.listdir(full): - os.rmdir(full) - except Exception: - pass - except Exception: - pass - ttl = int(os.environ.get("IMGWK_CLEAN_OLDER_THAN_SEC", "300")) - for d in (os.path.join(app_data_dir, "incoming"), os.path.join(app_data_dir, "work"), os.path.join(app_data_dir, "output"), os.path.join(app_data_dir, "outputs")): - _cleanup_dir(d, older_than_sec=ttl) - except Exception: - pass - break + logger.info(f"🚀 작업 처리 시작: cmd={cmd}, uid={uid}") - uid = task["id"] - cmd = task["cmd"] - kwargs = task["kwargs"] - logger.info(f"🚀 작업 처리 시작: cmd={cmd}, uid={uid}") + # 메타 파라미터 제거 및 실시간 값 반영 + new_toggle = kwargs.pop("_toggle_states", None) + if new_toggle and processor: + processor.update_toggle_states(new_toggle) - # 메타 파라미터 제거 및 실시간 값 반영 - new_toggle = kwargs.pop("_toggle_states", None) - if new_toggle and processor: - processor.update_toggle_states(new_toggle) + _ = kwargs.pop("_base_dir", None) + upd_unwanted = kwargs.pop("_update_unwanted_texts", None) + if upd_unwanted and processor: + processor.update_unwanted_texts(upd_unwanted) - _ = kwargs.pop("_base_dir", None) # 필요 없으므로 버림 - upd_unwanted = kwargs.pop("_update_unwanted_texts", None) - if upd_unwanted and processor: - processor.update_unwanted_texts(upd_unwanted) - - # 실제 작업 실행 - try: logger.debug(f"작업 실행 직전: cmd={cmd}") + + data = None if cmd == "process_single_image": logger.debug("process_single_image 호출 직전") - data = asyncio.run(processor.process_single_image(**kwargs)) - # 성능 지표 포함 + # asyncio.run 제거 -> await 직접 호출 + data = await processor.process_single_image(**kwargs) + try: timings = getattr(processor, '_last_timings', None) if isinstance(data, dict) and timings: @@ -368,26 +317,26 @@ def worker_main( except Exception: pass logger.debug("process_single_image 호출 완료") + elif cmd == "remove_background": logger.debug("remove_background 호출 직전") - data = asyncio.run(processor.remove_background(**kwargs)) + data = await processor.remove_background(**kwargs) logger.debug("remove_background 호출 완료") + elif cmd == "reinit_ocr": - # 토글 반영 후 OCR 재초기화(프로바이더 캐시 고려) + # Blocking 작업이므로 run_in_executor 권장되나, 짧으면 그냥 실행 ok = processor.reset_ocr_module() data = {"ok": bool(ok)} + elif cmd == "reinit_rembg": - # REMBG(배경제거) 모듈 재준비: 현재 Bria 모듈 사용시 세션/프로바이더를 재평가하도록 None 초기화 try: - # toggle_states의 provider override는 상위에서 반영되어 내려옴 - # BriaBackgroundRemovalModule은 lazy-load 방식 → 재생성 유도 if hasattr(processor, 'background_removal_module'): try: del processor.background_removal_module except Exception: processor.background_removal_module = None + from modules.bria_background_removal_module import BriaBackgroundRemovalModule - # 경로/매개변수는 processor.toggle_states에서 유추(존재 시) model_path = processor.toggle_states.get('local_rembg_model_path') processor.background_removal_module = BriaBackgroundRemovalModule( logger=logger, @@ -399,37 +348,174 @@ def worker_main( except Exception as e: logger.error(f"REMBG 재초기화 실패: {e}") data = {"ok": False, "error": str(e)} + elif cmd == "reset_migan": - # MIGAN 재구성(토글상 migan_use_cuda 등 변경 반영) try: from modules.migan_module import build_migan_from_toggle enhanced_toggle_states = processor.toggle_states.copy() - # 가속 사용 플래그 명칭 정리(호환): migan_use_cuda -> migan_use_accel if 'migan_use_cuda' in enhanced_toggle_states and 'migan_use_accel' not in enhanced_toggle_states: enhanced_toggle_states['migan_use_accel'] = enhanced_toggle_states['migan_use_cuda'] - # provider override가 들어왔으면 반영(auto|dml|cpu) prov = kwargs.get('provider') if prov: enhanced_toggle_states['migan_provider_override'] = prov - # gpu_manager 상태와 무관하게 토글을 그대로 전달(직접 폴백은 모듈 내부) + processor.migan = build_migan_from_toggle(enhanced_toggle_states, logger=logger, gpu_manager=getattr(processor, 'gpu_manager', None)) data = {"ok": bool(processor.migan is not None)} except Exception as mm_err: logger.error(f"MIGAN 재설정 실패: {mm_err}") data = {"ok": False, "error": str(mm_err)} + elif cmd == "__PING__": - # 하트비트 응답 data = "__PONG__" + elif cmd == "update_toggle_states": - # 토글 업데이트는 위쪽 공통 로직에서 이미 수행됨 data = {"ok": True} + else: raise ValueError(f"unknown cmd: {cmd}") logger.debug(f"작업 결과 반환 중: uid={uid}") result_q.put({"id": uid, "data": data}) logger.debug(f"작업 결과 반환 완료: uid={uid}") + except Exception: logger.error(f"작업 처리 중 오류: cmd={cmd}, uid={uid}") logger.error("작업 처리 중 오류", exc_info=True) result_q.put({"id": uid, "error": traceback.format_exc()}) + + async def main_loop(): + active_tasks = set() + idle_log_last = 0.0 + + logger.info("🚀 Async Worker Loop 시작") + + last_status_log = 0.0 + + while True: + now_ts = time.time() + + # 1. 완료된 태스크 정리 + if active_tasks: + done, active_tasks = await asyncio.wait(active_tasks, timeout=0.01) + # 예외 처리는 process_task_async 내부에서 수행하므로 여기선 done 확인만 함 + + # --- [Watchdog & Status Logging] --- + if active_tasks: + # 30초마다 상태 로그 + if now_ts - last_status_log >= 30.0: + last_status_log = now_ts + try: + waiting_info = [] + for t in active_tasks: + t_info = getattr(t, "_task_info", {}) + t_uid = t_info.get("id", "unknown") + start_t = t_info.get("_started_at", now_ts) + elapsed = now_ts - start_t + waiting_info.append(f"{t_uid}({elapsed:.1f}s)") + + # 200초 이상 경과 시 경고 (DirectML 등 행 의심) + if elapsed > 200: + logger.warning(f"⚠️ 태스크 {t_uid}가 {elapsed:.1f}초째 실행 중입니다. (행 의심)") + + logger.info(f"⚡ 실행 중인 작업({len(active_tasks)}): {', '.join(waiting_info)}") + except Exception: + pass + # ----------------------------------- + + # 2. 동시성 제한 확인 + limit = 1 + if processor and processor.toggle_states: + limit = int(processor.toggle_states.get("detail_concurrency_limit", 1)) + if limit < 1: limit = 1 + + # 실행 중인 태스크가 제한보다 많으면 대기 (단, 즉시 처리해야 할 시스템 태스크 고려 필요? -> 큐에서 꺼내봐야 아므로 일단 대기) + if len(active_tasks) >= limit: + await asyncio.sleep(0.1) + continue + + # 3. 큐 폴링 (Non-blocking) + try: + task = task_q.get_nowait() + # 유휴 로그 리셋 + # logger.info(f"🔥 작업 수신 성공") + except queue.Empty: + now_ts = time.time() + if now_ts - idle_log_last >= 600: + idle_log_last = now_ts + logger.info("대기 중(유휴)") + await asyncio.sleep(0.1) + continue + except Exception as e: + logger.error(f"작업 수신 중 오류: {e}", exc_info=True) + await asyncio.sleep(1.0) + continue + + if task is None: + logger.info("Shutdown signal 수신 → 종료 대기") + if active_tasks: + await asyncio.wait(active_tasks) + break + + # 4. 태스크 실행 + cmd = task.get("cmd") + # 병렬 처리 허용 커맨드 + if cmd in ("process_single_image", "remove_background"): + # 태스크 시작 시간 기록 (Watchdog용) + task["_started_at"] = time.time() + t = asyncio.create_task(process_task_async(task)) + # 태스크 객체에 메타데이터 저장 (파이썬 3.8+ name 속성 활용 또는 커스텀 속성) + setattr(t, "_task_info", task) + active_tasks.add(t) + else: + # 설정 변경 등은 안전을 위해 기존 작업 완료 후 실행 + if active_tasks: + logger.info(f"설정 변경 명령({cmd}) 감지 - 기존 작업({len(active_tasks)}) 완료 대기...") + await asyncio.wait(active_tasks) + active_tasks.clear() + + # 동기 실행 (await) + await process_task_async(task) + + # 종료 처리 (임시 파일 정리 등) + logger.info("Worker Loop 종료 및 정리") + try: + base_program = os.environ.get("PROGRAMDATA", r"C:\\ProgramData") + app_data_dir = os.path.join(base_program, "ImgWorker") + def _cleanup_dir(dp: str, older_than_sec: int = 300): + try: + now_ts = time.time() + thr = max(0, int(older_than_sec or 0)) + for root, dirs, files in os.walk(dp, topdown=False): + for fn in files: + fp = os.path.join(root, fn) + try: + if thr <= 0: + os.remove(fp) + else: + mt = os.path.getmtime(fp) + if (now_ts - mt) >= thr: + os.remove(fp) + except Exception: + pass + for dn in dirs: + full = os.path.join(root, dn) + try: + if not os.listdir(full): + os.rmdir(full) + except Exception: + pass + except Exception: + pass + ttl = int(os.environ.get("IMGWK_CLEAN_OLDER_THAN_SEC", "300")) + for d in (os.path.join(app_data_dir, "incoming"), os.path.join(app_data_dir, "work"), os.path.join(app_data_dir, "output"), os.path.join(app_data_dir, "outputs")): + _cleanup_dir(d, older_than_sec=ttl) + except Exception: + pass + + # Async Loop 실행 + try: + asyncio.run(main_loop()) + except KeyboardInterrupt: + pass + except Exception as e: + logger.error(f"Main Loop 치명적 오류: {e}", exc_info=True) diff --git a/modules/openrouter_client.py b/modules/openrouter_client.py new file mode 100644 index 0000000..a398919 --- /dev/null +++ b/modules/openrouter_client.py @@ -0,0 +1,709 @@ +# -*- coding: utf-8 -*- +""" +OpenRouter Translation API Python Client +- OpenRouter API를 통한 다양한 LLM 모델 번역 지원 +- gemma_client.py와 동일한 인터페이스 제공 +- OpenRouter 모델 ID를 직접 사용 + +사용 예: + from openrouter_client import OpenRouterTranslator + + # 모델 ID 직접 지정 + ort = OpenRouterTranslator( + api_key="sk-or-v1-xxx", + model_id="xiaomi/mimo-v2-flash:free" + ) + + # OCR 결과 번역 + ko_list = ort.translate_ocr_texts( + product_name="휴대용 선풍기", + category="가전/계절가전", + ocr_results=[{"text":"强力送风"}, {"text":"USB-C 快速充电"}] + ) +""" +from __future__ import annotations + +import os +import time +import json +import random +import logging +from typing import List, Dict, Any, Optional + +import requests + + +_JSON = Dict[str, Any] + + +class OpenRouterTranslatorError(RuntimeError): + """OpenRouter 번역 클라이언트 예외""" + pass + + +class OpenRouterTranslator: + """ + OpenRouter API를 통한 번역 클라이언트. + + GemmaTranslator와 동일한 인터페이스를 제공하여 호환성 유지. + + Params + ------ + api_key : str + OpenRouter API 키 (sk-or-v1-xxx) + model_id : str + OpenRouter 모델 ID (예: "xiaomi/mimo-v2-flash:free", "deepseek/deepseek-r1-0528:free") + base_url : str + OpenRouter API 베이스 URL + timeout : int + 요청 타임아웃(초) + max_retries : int + 요청 재시도 횟수 + backoff : float + 재시도 backoff base (지수) + session : requests.Session | None + 세션 주입 가능 + logger : logging.Logger | None + 로거 주입 가능 + site_url : str | None + OpenRouter 대시보드에 표시될 사이트 URL (선택) + site_name : str | None + OpenRouter 대시보드에 표시될 사이트 이름 (선택) + """ + + def __init__( + self, + api_key: Optional[str] = None, + model_id: str = "xiaomi/mimo-v2-flash:free", + base_url: str = "https://openrouter.ai/api/v1", + timeout: int = 120, + max_retries: int = 2, + backoff: float = 0.6, + session: Optional[requests.Session] = None, + logger: Optional[logging.Logger] = None, + site_url: Optional[str] = None, + site_name: Optional[str] = None, + ) -> None: + self.api_key = api_key or os.getenv("OPENROUTER_API_KEY") + if not self.api_key: + raise OpenRouterTranslatorError("OpenRouter API 키가 필요합니다. api_key 파라미터 또는 OPENROUTER_API_KEY 환경변수를 설정하세요.") + + self.base_url = base_url.rstrip("/") + self.timeout = timeout + self.max_retries = max_retries + self.backoff = backoff + self.sess = session or requests.Session() + self.log = logger or logging.getLogger(__name__) + self.site_url = site_url + self.site_name = site_name + + # 모델 설정 + self.model_id = model_id + self.log.info(f"[OpenRouterTranslator] 모델 설정: {self.model_id}") + + # ----------------------------- + # 모델 관리 + # ----------------------------- + def set_model(self, model_id: str) -> None: + """ + 사용할 모델 변경 + + Args: + model_id: OpenRouter 모델 ID (예: "deepseek/deepseek-r1-0528:free") + """ + self.model_id = model_id + self.log.info(f"[OpenRouterTranslator] 모델 변경: {self.model_id}") + + def get_current_model(self) -> Dict[str, Any]: + """현재 설정된 모델 정보 반환""" + return { + "id": self.model_id, + "name": self.model_id, + } + + # ----------------------------- + # 내부 HTTP 헬퍼 + # ----------------------------- + def _build_headers(self) -> Dict[str, str]: + """API 요청 헤더 생성""" + headers = { + "Authorization": f"Bearer {self.api_key}", + "Content-Type": "application/json", + } + if self.site_url: + headers["HTTP-Referer"] = self.site_url + if self.site_name: + headers["X-Title"] = self.site_name + return headers + + def _post_chat(self, messages: List[Dict[str, str]], temperature: float = 0.3) -> str: + """ + OpenRouter Chat Completions API 호출 + + Returns + ------- + str + 모델 응답 텍스트 + """ + url = f"{self.base_url}/chat/completions" + payload = { + "model": self.model_id, + "messages": messages, + "temperature": temperature, + } + + last_err: Optional[Exception] = None + for attempt in range(self.max_retries + 1): + try: + r = self.sess.post( + url, + headers=self._build_headers(), + json=payload, + timeout=self.timeout + ) + r.raise_for_status() + data = r.json() + + # 응답 파싱 + choices = data.get("choices", []) + if not choices: + raise OpenRouterTranslatorError("API 응답에 choices가 없습니다.") + + content = choices[0].get("message", {}).get("content", "") + return content.strip() + + except requests.exceptions.HTTPError as e: + last_err = e + # 429 Rate Limit, 5xx 서버 에러 시 재시도 + if e.response is not None and e.response.status_code in (429, 500, 502, 503, 504): + if attempt < self.max_retries: + sleep_s = (self.backoff ** attempt) + random.uniform(0, 0.3) + self.log.warning(f"[OpenRouterTranslator] POST {url} 실패({e}), 재시도 {attempt+1}/{self.max_retries} 대기 {sleep_s:.2f}s") + time.sleep(sleep_s) + continue + raise OpenRouterTranslatorError(f"HTTP 에러: {e}") + + except Exception as e: + last_err = e + if attempt < self.max_retries: + sleep_s = (self.backoff ** attempt) + random.uniform(0, 0.2) + self.log.warning(f"[OpenRouterTranslator] POST {url} 실패({e}), 재시도 {attempt+1}/{self.max_retries} 대기 {sleep_s:.2f}s") + time.sleep(sleep_s) + else: + break + + raise OpenRouterTranslatorError(f"POST {url} 실패: {last_err}") + + # ----------------------------- + # 번역 프롬프트 생성 + # ----------------------------- + def _build_translation_prompt( + self, + product_name: str, + category: str, + items: List[Dict[str, Any]], + steps: int = 1 + ) -> str: + """번역 요청 프롬프트 생성""" + + items_json = json.dumps(items, ensure_ascii=False, indent=2) + + if steps == 1: + # 직역 모드 + prompt = f"""당신은 중국어-한국어 전문 온라인 쇼핑마케팅 번역가입니다. + + 상품 정보: + - 상품명: {product_name} + - 카테고리: {category} + + 아래 JSON 배열의 각 항목에서 "source" 필드의 중국어 텍스트를 한국어로 번역해주세요. + + 번역 규칙: + 1. 정확하고 자연스러운 한국어로 번역 + 2. 상품 문맥에 맞게 번역 + 3. 브랜드명, 고유명사는 그대로 유지 + 4. 숫자와 단위는 유지 + + 입력: + {items_json} + + 출력 형식 (JSON 배열만 출력, 다른 텍스트 없이): + [ + {{"id": 1, "translation": "번역된 텍스트"}}, + {{"id": 2, "translation": "번역된 텍스트"}} + ]""" + else: + # 마케팅 톤 변환 모드 (steps == 2) + # Step 2는 이미 한국어로 번역된 텍스트를 입력으로 받음 + prompt = f"""당신은 마케팅 카피라이터입니다. + + 상품 정보: + - 상품명: {product_name} + - 카테고리: {category} + + 아래 JSON 배열의 각 항목에서 "source" 필드의 한국어 텍스트를 + 한국 소비자에게 매력적으로 느껴지도록 마케팅 톤으로 다듬어주세요. + + 변환 규칙: + 1. 원본의 의미는 정확히 유지 + 2. 한국 소비자에게 친숙하고 자연스러운 표현으로 변경 + 3. 상품의 장점을 부각하는 표현 사용 + 4. 브랜드명, 고유명사는 그대로 유지 + 5. 숫자와 단위는 유지 + 6. 너무 과장되지 않게, 자연스럽게 + + 입력: + {items_json} + + 출력 형식 (JSON 배열만 출력, 다른 텍스트 없이): + [ + {{"id": 1, "translation": "마케팅톤으로 다듬은 텍스트"}}, + {{"id": 2, "translation": "마케팅톤으로 다듬은 텍스트"}} + ]""" + + return prompt + + def _build_combined_translation_prompt( + self, + product_name: str, + category: str, + items: List[Dict[str, Any]] + ) -> str: + """ + 1단계(직역)와 2단계(마케팅톤 변환)를 합친 프롬프트 생성 + + Args: + product_name: 상품명 + category: 카테고리 + items: 번역할 항목 리스트 [{"id": 1, "source": "중국어 텍스트"}, ...] + + Returns: + 통합 프롬프트 문자열 + """ + items_json = json.dumps(items, ensure_ascii=False, indent=2) + + prompt = f"""당신은 중국어-한국어 전문 번역가이자 마케팅 카피라이터입니다. + +상품 정보: +- 상품명: {product_name} +- 카테고리: {category} + +아래 JSON 배열의 각 항목에서 "source" 필드의 중국어 텍스트를 다음 두 단계로 처리해주세요: + +1단계: 정확하고 자연스러운 한국어로 번역 +2단계: 한국 소비자에게 매력적으로 느껴지도록 마케팅 톤으로 다듬기 + +처리 규칙: +1. 정확한 의미 전달 (1단계) +2. 상품 문맥에 맞게 번역 (1단계) +3. 브랜드명, 고유명사는 그대로 유지 +4. 숫자와 단위는 유지 +5. 한국 소비자에게 친숙하고 자연스러운 표현 사용 (2단계) +6. 상품의 장점을 부각하는 표현 (2단계) +7. 너무 과장되지 않게, 자연스럽게 (2단계) + +입력: +{items_json} + +출력 형식 (JSON 배열만 출력, 다른 텍스트 없이): +[ + {{"id": 1, "translation": "마케팅톤으로 다듬은 한국어 번역"}}, + {{"id": 2, "translation": "마케팅톤으로 다듬은 한국어 번역"}} +]""" + + return prompt + + # ----------------------------- + # 응답 파싱 + # ----------------------------- + def _parse_translation_response(self, response_text: str) -> List[Dict[str, Any]]: + """ + 모델 응답에서 번역 결과 JSON 파싱 + + Returns + ------- + List[Dict] + [{"id": 1, "translation": "..."}, ...] + """ + clean_str = response_text.strip() + + # Markdown 코드 블록 제거 + if clean_str.startswith("```"): + # 첫 줄 제거 (```json 등) + parts = clean_str.split('\n', 1) + if len(parts) > 1: + clean_str = parts[1] + else: + clean_str = clean_str.replace("```", "") + + if clean_str.endswith("```"): + clean_str = clean_str[:-3] + + clean_str = clean_str.strip() + + try: + result = json.loads(clean_str) + if isinstance(result, list): + return result + elif isinstance(result, dict): + return [result] + else: + raise OpenRouterTranslatorError(f"예상치 못한 응답 타입: {type(result)}") + except json.JSONDecodeError as e: + self.log.error(f"[OpenRouterTranslator] JSON 파싱 실패: {e}\n응답: {response_text[:500]}...") + raise OpenRouterTranslatorError(f"JSON 파싱 실패: {e}") + + # ----------------------------- + # 공개 API (GemmaTranslator 호환) + # ----------------------------- + def translate_ocr_texts( + self, + product_name: str, + category: str, + ocr_results: List[Dict[str, Any]], + batch_size: int = 16, + ) -> List[str]: + """ + OCR 결과 번역 (GemmaTranslator.translate_ocr_texts 호환) + + 입력: OCR 결과 리스트(각 항목에 최소 'text' 키 필요) + 출력: 원래 순서 유지한 ko 문자열 리스트 + """ + if not ocr_results: + return [] + + # 유효성 검증 + if not product_name or len(product_name.strip()) < 1: + raise OpenRouterTranslatorError("product_name은 1자 이상이어야 합니다.") + if not category or len(category.strip()) < 1: + raise OpenRouterTranslatorError("category는 1자 이상이어야 합니다.") + + # id 부여 및 source 필터링 + items = [] + source_to_orig_idx = {} + for i, d in enumerate(ocr_results): + source = (d.get("text") or "").strip() + if len(source) >= 1: + item_id = len(items) + 1 + items.append({"id": item_id, "source": source}) + source_to_orig_idx[item_id] = i + + if not items: + return [""] * len(ocr_results) + + # 배치 처리 + out_ko = [""] * len(ocr_results) + for i in range(0, len(items), batch_size): + chunk = items[i : i + batch_size] + + prompt = self._build_translation_prompt(product_name, category, chunk, steps=1) + messages = [{"role": "user", "content": prompt}] + + try: + response_text = self._post_chat(messages) + translated_items = self._parse_translation_response(response_text) + + for item in translated_items: + item_id = int(item.get("id", 0)) + translation = item.get("translation", "") + + orig_idx = source_to_orig_idx.get(item_id) + if orig_idx is not None: + out_ko[orig_idx] = str(translation).strip() if translation else "" + + except Exception as e: + self.log.error(f"[OpenRouterTranslator] 배치 번역 실패: {e}") + # 실패한 배치는 빈 문자열로 유지 + continue + + return out_ko + + def run_llm_translation( + self, + product_name: str, + category: str, + ocr_results: List[Dict[str, Any]], + job_type: str = "ocr_translator_step1", + prompt_name: str = "ocr_translator_step1", + retry_count: int = 3, + steps: int = 1 + ) -> List[str]: + """ + LLM 번역 (GemmaTranslator.run_llm_translation 호환) + + Args: + product_name: 상품명 + category: 카테고리 + ocr_results: OCR 결과 리스트 + job_type: 작업 타입 (호환성용, 사용 안함) + prompt_name: 프롬프트 이름 (호환성용, 사용 안함) + retry_count: 재시도 횟수 + steps: 번역 단계 + 1=직역만 (1회 API 호출) + 2=직역 후 마케팅톤 변환 (2회 API 호출: step1 직역 → step2 마케팅톤 변환) + """ + if not ocr_results: + return [] + + # items 구성 + items = [] + source_to_orig_idx = {} + for i, res in enumerate(ocr_results): + text = (res.get("text") or "").strip() + if text: + item_id = len(items) + 1 + items.append({"id": item_id, "source": text}) + source_to_orig_idx[item_id] = i + + if not items: + return [""] * len(ocr_results) + + # steps 검증 + steps = max(1, min(2, steps)) + + # 임시로 max_retries 조정 + original_retries = self.max_retries + self.max_retries = max(retry_count - 1, 0) + + try: + # Step 1: 직역 + prompt_step1 = self._build_translation_prompt(product_name, category, items, steps=1) + messages_step1 = [{"role": "user", "content": prompt_step1}] + + self.log.info(f"[OpenRouterTranslator] Step 1: 직역 시작") + response_text_step1 = self._post_chat(messages_step1) + translated_items_step1 = self._parse_translation_response(response_text_step1) + + # Step 1 결과를 리스트로 변환 + step1_results = [""] * len(ocr_results) + for item in translated_items_step1: + item_id = int(item.get("id", 0)) + + # 결과 필드 찾기 (translation > result > translated) + res_text = "" + if "translation" in item: + res_text = item["translation"] + elif "result" in item: + res_text = item["result"] + elif "translated" in item: + res_text = item["translated"] + + if res_text is None: + res_text = "" + + orig_idx = source_to_orig_idx.get(item_id) + if orig_idx is not None: + step1_results[orig_idx] = str(res_text).strip() + + # Step 1만 필요한 경우 + if steps == 1: + return step1_results + + # Step 2: 마케팅톤 변환 (Step 1 결과를 입력으로 사용) + self.log.info(f"[OpenRouterTranslator] Step 2: 마케팅톤 변환 시작") + + # Step 1 결과를 items 형태로 변환 + items_step2 = [] + for i, translated_text in enumerate(step1_results, 1): + if translated_text: # 빈 문자열이 아닌 경우만 + items_step2.append({"id": i, "source": translated_text}) + + if not items_step2: + return step1_results + + prompt_step2 = self._build_translation_prompt(product_name, category, items_step2, steps=2) + messages_step2 = [{"role": "user", "content": prompt_step2}] + + response_text_step2 = self._post_chat(messages_step2) + translated_items_step2 = self._parse_translation_response(response_text_step2) + + # Step 2 결과를 최종 결과로 변환 + out_ko = [""] * len(ocr_results) + for item in translated_items_step2: + item_id = int(item.get("id", 0)) + + # 결과 필드 찾기 (translation > result > translated) + res_text = "" + if "translation" in item: + res_text = item["translation"] + elif "result" in item: + res_text = item["result"] + elif "translated" in item: + res_text = item["translated"] + + if res_text is None: + res_text = "" + + # item_id는 step2의 items 인덱스이므로, 원본 인덱스로 매핑 + # step2 items는 step1 결과의 순서를 유지하므로, item_id - 1이 원본 인덱스 + if 1 <= item_id <= len(step1_results): + orig_idx = item_id - 1 + # 원본에서 실제로 번역된 항목인지 확인 + if orig_idx < len(ocr_results): + out_ko[orig_idx] = str(res_text).strip() + + return out_ko + + except Exception as e: + self.log.error(f"[OpenRouterTranslator] run_llm_translation 실패: {e}") + raise e + finally: + self.max_retries = original_retries + + def run_combined_llm_translation( + self, + product_name: str, + category: str, + ocr_results: List[Dict[str, Any]], + retry_count: int = 3 + ) -> List[str]: + """ + 통합 프롬프트를 사용한 LLM 번역 (직역 + 마케팅톤 변환을 한 번에 수행) + + Args: + product_name: 상품명 + category: 카테고리 + ocr_results: OCR 결과 리스트 + retry_count: 재시도 횟수 + + Returns: + 번역된 문자열 리스트 (원래 순서 유지) + + Note: + 이 메서드는 1단계(직역)와 2단계(마케팅톤 변환)를 한 번의 API 호출로 수행합니다. + run_llm_translation(steps=2)와 달리 2회의 API 호출이 아닌 1회만 호출합니다. + """ + if not ocr_results: + return [] + + # items 구성 + items = [] + source_to_orig_idx = {} + for i, res in enumerate(ocr_results): + text = (res.get("text") or "").strip() + if text: + item_id = len(items) + 1 + items.append({"id": item_id, "source": text}) + source_to_orig_idx[item_id] = i + + if not items: + return [""] * len(ocr_results) + + # 임시로 max_retries 조정 + original_retries = self.max_retries + self.max_retries = max(retry_count - 1, 0) + + try: + # 통합 프롬프트 사용 (직역 + 마케팅톤 변환) + prompt = self._build_combined_translation_prompt(product_name, category, items) + messages = [{"role": "user", "content": prompt}] + + self.log.info(f"[OpenRouterTranslator] 통합 번역 시작 (직역 + 마케팅톤 변환)") + response_text = self._post_chat(messages) + translated_items = self._parse_translation_response(response_text) + + # 결과를 리스트로 변환 + out_ko = [""] * len(ocr_results) + for item in translated_items: + item_id = int(item.get("id", 0)) + + # 결과 필드 찾기 (translation > result > translated) + res_text = "" + if "translation" in item: + res_text = item["translation"] + elif "result" in item: + res_text = item["result"] + elif "translated" in item: + res_text = item["translated"] + + if res_text is None: + res_text = "" + + orig_idx = source_to_orig_idx.get(item_id) + if orig_idx is not None: + out_ko[orig_idx] = str(res_text).strip() + + return out_ko + + except Exception as e: + self.log.error(f"[OpenRouterTranslator] run_combined_llm_translation 실패: {e}") + raise e + finally: + self.max_retries = original_retries + + def batch_translate_texts( + self, + product_name: str, + category: str, + text_list: List[str], + delimiter: str = " / ", + batch_size: int = 8, + ) -> List[str]: + """ + 순수 텍스트 리스트 번역 (GemmaTranslator.batch_translate_texts 호환) + """ + if not text_list: + return [] + + # text_list를 ocr_results 형태로 변환 + ocr_results = [{"text": t} for t in text_list] + return self.translate_ocr_texts(product_name, category, ocr_results, batch_size) + + def translate_option_groups( + self, + product_name: str, + category: str, + option_groups: List[Dict[str, Any]], + batch_size: int = 8, + ) -> List[Dict[str, Any]]: + """ + 옵션 그룹 번역 (GemmaTranslator.translate_option_groups 호환) + + option_groups 예: + [{"id": 1, "source": ["红色","蓝色"]}, {"id": 2, "source": ["小号","大号"]}] + 반환: + [{"id": 1, "translations": ["빨강","파랑"]}, {"id": 2, "translations": ["소형","대형"]}] + """ + if not option_groups: + return [] + + results = [] + for group in option_groups: + group_id = group.get("id") + sources = group.get("source", []) + + if not sources: + results.append({"id": group_id, "translations": []}) + continue + + # 각 옵션을 번역 + ocr_results = [{"text": s} for s in sources] + translations = self.translate_ocr_texts(product_name, category, ocr_results, batch_size) + + results.append({"id": group_id, "translations": translations}) + + return results + + # ----------------------------- + # 유틸리티 + # ----------------------------- + def health(self) -> _JSON: + """API 상태 확인 (간단한 테스트 요청)""" + try: + messages = [{"role": "user", "content": "Hello"}] + self._post_chat(messages) + return {"status": "ok", "model": self.model_id} + except Exception as e: + return {"status": "error", "error": str(e)} + + def get_credits(self) -> _JSON: + """OpenRouter 크레딧 잔액 조회""" + url = f"{self.base_url}/credits" + try: + r = self.sess.get(url, headers=self._build_headers(), timeout=10) + r.raise_for_status() + return r.json() + except Exception as e: + self.log.error(f"[OpenRouterTranslator] 크레딧 조회 실패: {e}") + return {"error": str(e)} + diff --git a/modules/request_inpaint.py b/modules/request_inpaint.py index f5c046b..544f6f7 100644 --- a/modules/request_inpaint.py +++ b/modules/request_inpaint.py @@ -83,7 +83,7 @@ class Request_AI_Server: return None - def request_external_inpaint(self, image: np.ndarray, mask: np.ndarray, server_url: str, invert_mask: bool = False, model_name: str = "simple-lama") -> np.ndarray: + def request_external_inpaint(self, image: np.ndarray, mask: np.ndarray, server_url: str, invert_mask: bool = False, model_name: str = "migan") -> np.ndarray: """외부 IOPaint 서버를 이용한 인페인팅 요청 (VIP용) Args: @@ -169,7 +169,7 @@ class Request_AI_Server: # 요청 파라미터 명시: 이 서버는 Accept 에 따라 응답이 달라질 수 있으므로 쿼리로 고정 params = { "response_format": "binary", - "image_format": "png", + "image_format": "webp", # webp 사용 (png 대비 ~90% 용량 절약) } self.logger.log(f"외부 인페인팅 서버 요청: {api_url}, model={model_name}", level=logging.DEBUG) @@ -179,7 +179,7 @@ class Request_AI_Server: self.logger.log(f"외부 인페인팅 서버 에러: {response.status_code} {response.text}", level=logging.WARNING) return None - # 응답이 바이너리 PNG 이미지이므로 바로 디코딩 + # 응답이 바이너리 webp 이미지이므로 바로 디코딩 (cv2.imdecode는 webp도 지원) nparr = np.frombuffer(response.content, np.uint8) result = cv2.imdecode(nparr, cv2.IMREAD_COLOR) @@ -822,12 +822,12 @@ class Request_AI_Server: return None def is_server_alive(self, base_url: str, timeout: int = 3) -> bool: - """서버 헬스체크(현재는 사용 안 함). base_url이 비어있으면 False.""" + """서버 헬스체크. base_url이 비어있으면 False.""" try: if not base_url: return False - model_url = base_url.rstrip('/') + '/api/v1/model' - response = requests.get(model_url, timeout=timeout) + health_url = base_url.rstrip('/') + '/health' + response = requests.get(health_url, timeout=timeout) return response.status_code == 200 except Exception as e: self.logger.log(f"서버 상태 확인 실패 ({base_url}): {e}", level=logging.WARNING) diff --git a/modules/test/Edit_PartTimer_log_15124.log b/modules/test/Edit_PartTimer_log_15124.log new file mode 100644 index 0000000..31ad989 --- /dev/null +++ b/modules/test/Edit_PartTimer_log_15124.log @@ -0,0 +1,184 @@ +[2025-12-01 23:38:06,415] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-01 23:38:06,421] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-01 23:38:06,422] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-01 23:38:06,422] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-01 23:38:06,422] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-01 23:38:06,422] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-01 23:38:06,422] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-01 23:38:06,423] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-01 23:38:06,423] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-01 23:38:06,423] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-01 23:38:06,423] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-01 23:38:06,423] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'font_type': '폰트8', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\Pretendard-Regular.ttf', 'ocr': True, 'force_cpu_ocr': True, 'use_cuda': False, 'inpaint_model': 'migan', 'local_inpaint_method': 'migan', 'migan_onnx_path': 'D:\\py\\img_worker\\modules\\migan_onnx\\migan_pipeline_v2.onnx', 'migan_use_accel': False, 'migan_provider_override': 'cpu', 'detail_IMGTrans_type': 'CPU', 'optionIMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:38:06,424] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-01 23:38:06,424] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-01 23:38:06,424] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\Pretendard-Regular.ttf +[2025-12-01 23:38:06,424] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\Pretendard-Regular.ttf +[2025-12-01 23:38:06,425] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test +[2025-12-01 23:38:06,425] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-01 23:38:06,425] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-01 23:38:06,425] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-01 23:38:06,425] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-01 23:38:06,426] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-01 23:38:06,426] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-01 23:38:06,426] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-01 23:38:06,426] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-01 23:38:06,426] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:38:06,426] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:38:08,228] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-01 23:38:08,312] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-01 23:38:08,312] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-01 23:38:08,312] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-01 23:38:08,313] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-01 23:38:08,313] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: http://192.168.0.146:8008 +[2025-12-01 23:38:08,314] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=http://192.168.0.146:8008 +[2025-12-01 23:38:08,314] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-01 23:38:08,314] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-01 23:38:08,314] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-01 23:38:08,314] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\Pretendard-Regular.ttf +[2025-12-01 23:38:08,314] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-01 23:38:08,315] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\Pretendard-Regular.ttf +[2025-12-01 23:38:08,315] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-01 23:38:08,315] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-01 23:38:08,315] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-01 23:38:08,315] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-01 23:38:08,316] [MainThread] [DEBUG] [image_processor3.py:__init__:251] MIGAN CUDA 사용 불가 - CPU 모드로 설정 +[2025-12-01 23:38:08,317] [MainThread] [DEBUG] [image_processor3.py:__init__:253] [MIGAN] GPU 관리자 전달: GPUManager, can_use_cuda: False +[2025-12-01 23:38:08,317] [MainThread] [DEBUG] [migan_module.py:_get_or_create_session:166] [MIGAN] GPU 관리자 사용 가능: False +[2025-12-01 23:38:08,317] [MainThread] [DEBUG] [migan_module.py:_get_or_create_session:186] [MIGAN] CPU 전용 모드 +[2025-12-01 23:38:08,317] [MainThread] [DEBUG] [migan_module.py:_get_or_create_session:188] [MIGAN] 최종 providers: [('CPUExecutionProvider', {})] +[2025-12-01 23:38:08,318] [MainThread] [DEBUG] [migan_module.py:_get_or_create_session:204] [MIGAN] CPU 전용 시도: [('CPUExecutionProvider', {})] +[2025-12-01 23:38:08,395] [MainThread] [INFO] [migan_module.py:_get_or_create_session:207] [MIGAN] CPU 전용 성공! 실제 providers: ['CPUExecutionProvider'] +[2025-12-01 23:38:08,396] [MainThread] [DEBUG] [migan_module.py:__init__:115] [MIGAN] 입력 0: image, 형태: ['batch_size', 3, 'height', 'width'], 타입: tensor(uint8) +[2025-12-01 23:38:08,396] [MainThread] [DEBUG] [migan_module.py:__init__:115] [MIGAN] 입력 1: mask, 형태: ['batch_size', 1, 'height', 'width'], 타입: tensor(uint8) +[2025-12-01 23:38:08,396] [MainThread] [DEBUG] [migan_module.py:__init__:117] [MIGAN] 출력 0: result, 형태: ['ScatterNDresult_dim_0', 3, 'ScatterNDresult_dim_2', 'ScatterNDresult_dim_3'], 타입: tensor(uint8) +[2025-12-01 23:38:08,397] [MainThread] [DEBUG] [migan_module.py:__init__:119] [MIGAN] 세션 준비 완료. providers=['CPUExecutionProvider'] +[2025-12-01 23:38:08,397] [MainThread] [DEBUG] [migan_module.py:build_migan_from_toggle:348] [MIGAN] GPU 관리자 연결 완료: GPUManager +[2025-12-01 23:38:08,397] [MainThread] [DEBUG] [migan_module.py:build_migan_from_toggle:355] [MIGAN] 파이프라인 gpu_manager 속성: True, 값: +[2025-12-01 23:38:08,397] [MainThread] [DEBUG] [image_processor3.py:__init__:255] [MIGAN] 초기화 완료: gpu_manager 속성=True, 값= +[2025-12-01 23:38:08,398] [MainThread] [INFO] [create_font_preview.py:main:99] 프리뷰 생성 시작: Pretendard-Regular.ttf +[2025-12-01 23:38:08,398] [MainThread] [INFO] [create_font_preview.py:main:100] 저장 경로: D:\py\img_worker\modules\test +[2025-12-01 23:38:08,398] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-01 23:38:08,398] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'font_type': '폰트8', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\Pretendard-Regular.ttf', 'ocr': True, 'force_cpu_ocr': True, 'use_cuda': False, 'inpaint_model': 'migan', 'local_inpaint_method': 'migan', 'migan_onnx_path': 'D:\\py\\img_worker\\modules\\migan_onnx\\migan_pipeline_v2.onnx', 'migan_use_accel': False, 'migan_provider_override': 'cpu', 'detail_IMGTrans_type': 'CPU', 'optionIMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:38:08,590] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-01 23:38:08,590] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:38:08,590] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: preview_Pretendard-Regular +[2025-12-01 23:38:08,591] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:38:08,601] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-01 23:38:09,272] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 671.0ms +[2025-12-01 23:38:09,272] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 77.0ms, 인식: 563.0ms, 분류: 24.0ms +[2025-12-01 23:38:09,285] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 30211.0MB -> 30452.9MB (+241.9MB, +0.8%) - 이미지 1 +[2025-12-01 23:38:09,300] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:38:09,324] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-01 23:38:09,324] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-01 23:38:09,325] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-01 23:38:09,325] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-01 23:38:09,325] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-01 23:38:09,325] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-01 23:38:09,325] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-01 23:38:09,326] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-01 23:38:09,326] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-01 23:38:09,326] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-01 23:38:09,326] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-01 23:38:09,326] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-01 23:38:09,326] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-01 23:38:09,327] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-01 23:38:09,327] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-01 23:38:09,327] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-01 23:38:09,327] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-01 23:38:09,327] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-01 23:38:09,328] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-01 23:38:09,328] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-01 23:38:09,328] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-01 23:38:09,328] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-01 23:38:09,329] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-01 23:38:09,329] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-01 23:38:09,329] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-01 23:38:09,329] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-01 23:38:09,329] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-01 23:38:09,330] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-01 23:38:09,339] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:38:09,339] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-01 23:38:09,340] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-01 23:38:10,947] [MainThread] [DEBUG] [image_processor3.py:process_single_image:748] translated_texts: ['코르노', 'CMC 인증', 'CPA 자격증', '국가 방폭형', 'ISO 인증', 'CE 인증', 'SGS 인증', '레이저 먼지 감지기', '정확도≤±5%F.S', '보호 수준:', '과전압 보호 / 소리와 빛 경보 / 매장 인쇄', '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능', '클래스 100,000 이상의 클린룸에 적합', '전국', '7일이면 반품할 이유가 없습니다.', '무료 배송 보험', '무료 배송', '오리지널 정품 / 청구 가능 / 1년 보증'] +[2025-12-01 23:38:10,948] [MainThread] [DEBUG] [image_processor3.py:process_single_image:749] 마스크 생성 완료 +[2025-12-01 23:38:10,948] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 1] 원본 텍스트: '코르노' +[2025-12-01 23:38:10,948] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 1] 분리된 단어: ['코르노'] +[2025-12-01 23:38:10,948] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 1] 변경 없음: '코르노' +[2025-12-01 23:38:10,949] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 2] 원본 텍스트: 'CMC 인증' +[2025-12-01 23:38:10,949] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 2] 분리된 단어: ['CMC', '인증'] +[2025-12-01 23:38:10,949] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 2] 변경 없음: 'CMC 인증' +[2025-12-01 23:38:10,949] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 3] 원본 텍스트: 'CPA 자격증' +[2025-12-01 23:38:10,949] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 3] 분리된 단어: ['CPA', '자격증'] +[2025-12-01 23:38:10,950] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 3] 변경 없음: 'CPA 자격증' +[2025-12-01 23:38:10,950] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 4] 원본 텍스트: '국가 방폭형' +[2025-12-01 23:38:10,950] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 4] 분리된 단어: ['국가', '방폭형'] +[2025-12-01 23:38:10,950] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 4] 변경 없음: '국가 방폭형' +[2025-12-01 23:38:10,950] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 5] 원본 텍스트: 'ISO 인증' +[2025-12-01 23:38:10,950] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 5] 분리된 단어: ['ISO', '인증'] +[2025-12-01 23:38:10,951] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 5] 변경 없음: 'ISO 인증' +[2025-12-01 23:38:10,951] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 6] 원본 텍스트: 'CE 인증' +[2025-12-01 23:38:10,951] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 6] 분리된 단어: ['CE', '인증'] +[2025-12-01 23:38:10,951] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 6] 변경 없음: 'CE 인증' +[2025-12-01 23:38:10,951] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 7] 원본 텍스트: 'SGS 인증' +[2025-12-01 23:38:10,952] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 7] 분리된 단어: ['SGS', '인증'] +[2025-12-01 23:38:10,952] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 7] 변경 없음: 'SGS 인증' +[2025-12-01 23:38:10,952] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 8] 원본 텍스트: '레이저 먼지 감지기' +[2025-12-01 23:38:10,952] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 8] 분리된 단어: ['레이저', '먼지', '감지기'] +[2025-12-01 23:38:10,952] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 8] 변경 없음: '레이저 먼지 감지기' +[2025-12-01 23:38:10,952] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 9] 원본 텍스트: '정확도≤±5%F.S' +[2025-12-01 23:38:10,953] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 9] 분리된 단어: ['정확도≤±5%F.S'] +[2025-12-01 23:38:10,953] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 9] 변경 없음: '정확도≤±5%F.S' +[2025-12-01 23:38:10,953] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 10] 원본 텍스트: '보호 수준:' +[2025-12-01 23:38:10,953] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 10] 분리된 단어: ['보호', '수준:'] +[2025-12-01 23:38:10,954] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 10] 변경 없음: '보호 수준:' +[2025-12-01 23:38:10,954] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 11] 원본 텍스트: '과전압 보호 / 소리와 빛 경보 / 매장 인쇄' +[2025-12-01 23:38:10,954] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 11] 분리된 단어: ['과전압', '보호', '/', '소리와', '빛', '경보', '/', '매장', '인쇄'] +[2025-12-01 23:38:10,954] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 11] 변경 없음: '과전압 보호 / 소리와 빛 경보 / 매장 인쇄' +[2025-12-01 23:38:10,954] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 12] 원본 텍스트: '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능' +[2025-12-01 23:38:10,955] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 12] 분리된 단어: ['다양한', '입자', '크기의', '먼지', '입자', '수를', '동시에', '모니터링', '가능'] +[2025-12-01 23:38:10,955] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 12] 변경 없음: '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능' +[2025-12-01 23:38:10,955] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 13] 원본 텍스트: '클래스 100,000 이상의 클린룸에 적합' +[2025-12-01 23:38:10,955] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 13] 분리된 단어: ['클래스', '100,000', '이상의', '클린룸에', '적합'] +[2025-12-01 23:38:10,955] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 13] 변경 없음: '클래스 100,000 이상의 클린룸에 적합' +[2025-12-01 23:38:10,955] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 14] 원본 텍스트: '전국' +[2025-12-01 23:38:10,956] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 14] 분리된 단어: ['전국'] +[2025-12-01 23:38:10,956] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 14] 변경 없음: '전국' +[2025-12-01 23:38:10,956] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 15] 원본 텍스트: '7일이면 반품할 이유가 없습니다.' +[2025-12-01 23:38:10,956] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 15] 분리된 단어: ['7일이면', '반품할', '이유가', '없습니다.'] +[2025-12-01 23:38:10,956] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 15] 변경 없음: '7일이면 반품할 이유가 없습니다.' +[2025-12-01 23:38:10,956] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 16] 원본 텍스트: '무료 배송 보험' +[2025-12-01 23:38:10,957] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 16] 분리된 단어: ['무료', '배송', '보험'] +[2025-12-01 23:38:10,957] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 16] 변경 없음: '무료 배송 보험' +[2025-12-01 23:38:10,957] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 17] 원본 텍스트: '무료 배송' +[2025-12-01 23:38:10,957] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 17] 분리된 단어: ['무료', '배송'] +[2025-12-01 23:38:10,958] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 17] 변경 없음: '무료 배송' +[2025-12-01 23:38:10,958] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 18] 원본 텍스트: '오리지널 정품 / 청구 가능 / 1년 보증' +[2025-12-01 23:38:10,958] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 18] 분리된 단어: ['오리지널', '정품', '/', '청구', '가능', '/', '1년', '보증'] +[2025-12-01 23:38:10,958] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 18] 변경 없음: '오리지널 정품 / 청구 가능 / 1년 보증' +[2025-12-01 23:38:10,958] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1496] 전체 치환 결과: 18개 텍스트 처리 완료 +[2025-12-01 23:38:10,959] [MainThread] [DEBUG] [image_processor3.py:process_single_image:758] 이미지 1 치환됨 +[2025-12-01 23:38:10,959] [MainThread] [INFO] [image_processor3.py:process_single_image:774] [inpaint_model 강제] migan → inpaint_method=migan +[2025-12-01 23:38:10,959] [MainThread] [DEBUG] [image_processor3.py:process_single_image:808] ocr_count: 18 +[2025-12-01 23:38:10,959] [MainThread] [DEBUG] [image_processor3.py:process_single_image:809] is_member_valid: True +[2025-12-01 23:38:10,960] [MainThread] [DEBUG] [image_processor3.py:set_inpaint_method:959] [set_inpaint_method] prefix=preview_Pretendard-Regular, target_key=, trans_type=GPU → inpaint_method=migan +[2025-12-01 23:38:10,960] [MainThread] [DEBUG] [image_processor3.py:process_single_image:813] 최종 inpaint_method: migan +[2025-12-01 23:38:10,976] [asyncio_1] [DEBUG] [image_processor3.py:_try_migan_inpaint:1173] MIGAN 인페인팅 시도 (CPU Mode - No Lock) +[2025-12-01 23:38:10,978] [asyncio_1] [DEBUG] [migan_module.py:inpaint:276] [MIGAN] 입력 형태 - 이미지: (1, 3, 640, 640), 마스크: (1, 1, 640, 640) +[2025-12-01 23:38:11,292] [asyncio_1] [DEBUG] [migan_module.py:inpaint:289] [MIGAN] 출력 형태: (640, 640, 3), dtype: uint8 +[2025-12-01 23:38:11,293] [asyncio_1] [DEBUG] [migan_module.py:inpaint:297] [MIGAN] 추론 완료: 315.00 ms +[2025-12-01 23:38:11,295] [asyncio_1] [DEBUG] [image_processor3.py:_try_migan_inpaint:1182] MIGAN 인페인팅 성공 +[2025-12-01 23:38:11,301] [asyncio_1] [INFO] [image_processor3.py:execute_inpaint_with_fallback:1080] 메모리 변화 [인페인팅]: 30486.8MB -> 30873.2MB (+386.4MB, +1.3%) - 방법: migan +[2025-12-01 23:38:11,302] [MainThread] [DEBUG] [image_processor3.py:process_single_image:826] 인페인팅 완료 +[2025-12-01 23:38:11,396] [MainThread] [DEBUG] [image_processor3.py:process_single_image:848] 텍스트 렌더링 완료 +[2025-12-01 23:38:11,397] [MainThread] [DEBUG] [image_processor3.py:postProcess_and_save_image:1281] watermark_text: 이미지 저작권 보유 +[2025-12-01 23:38:11,397] [MainThread] [DEBUG] [image_processor3.py:postProcess_and_save_image:1282] is_watermark_enabled: True +[2025-12-01 23:38:11,398] [MainThread] [INFO] [postImageManager.py:save_image_to_path:101] 이미지 저장 완료 : D:\py\img_worker\modules\test\translated_preview_Pretendard-Regular_img_1.jpg +[2025-12-01 23:38:11,399] [MainThread] [DEBUG] [image_processor3.py:process_single_image:854] 이미지 1 번역 완료: D:\py\img_worker\modules\test\translated_preview_Pretendard-Regular_img_1.jpg +[2025-12-01 23:38:11,429] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 3030.5ms | download=0.0ms | ocr=688.0ms | translate=1606.9ms | mask=48.6ms | inpaint=342.0ms(migan/CPU) | render=94.0ms | save=2.0ms +[2025-12-01 23:38:11,430] [MainThread] [INFO] [create_font_preview.py:main:116] 프리뷰 생성 성공: D:\py\img_worker\modules\test\translated_preview_Pretendard-Regular_img_1.jpg +[2025-12-01 23:38:11,444] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-01 23:38:11,444] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-01 23:38:11,483] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test +[2025-12-01 23:38:11,507] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test +[2025-12-01 23:38:11,507] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_17176.log b/modules/test/Edit_PartTimer_log_17176.log new file mode 100644 index 0000000..16306b8 --- /dev/null +++ b/modules/test/Edit_PartTimer_log_17176.log @@ -0,0 +1,183 @@ +[2025-12-02 01:24:27,532] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-02 01:24:27,539] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-02 01:24:27,539] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-02 01:24:27,539] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-02 01:24:27,540] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-02 01:24:27,540] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-02 01:24:27,540] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-02 01:24:27,540] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-02 01:24:27,540] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-02 01:24:27,541] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-02 01:24:27,541] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-02 01:24:27,541] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-02 01:24:27,541] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-02 01:24:27,542] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-02 01:24:27,542] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:24:27,542] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:24:27,542] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test\temp +[2025-12-02 01:24:27,542] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-02 01:24:27,542] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-02 01:24:27,543] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-02 01:24:27,543] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-02 01:24:27,543] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-02 01:24:27,543] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-02 01:24:27,543] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-02 01:24:27,544] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-02 01:24:27,544] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-02 01:24:27,544] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-02 01:24:29,415] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-02 01:24:29,501] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-02 01:24:29,502] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-02 01:24:29,502] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-02 01:24:29,503] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-02 01:24:29,503] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: https://inpaint.m1tcloud.cc +[2025-12-02 01:24:29,503] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=https://inpaint.m1tcloud.cc +[2025-12-02 01:24:29,503] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-02 01:24:29,504] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-02 01:24:29,504] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-02 01:24:29,504] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:24:29,504] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-02 01:24:29,505] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:24:29,505] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-02 01:24:29,505] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-02 01:24:29,505] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-02 01:24:29,505] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-02 01:24:29,506] [MainThread] [DEBUG] [image_processor3.py:__init__:258] MIGAN 초기화 건너뜀: inpaint_method=request, local_inpaint_method=request, migan_onnx_path=False +[2025-12-02 01:24:31,235] [MainThread] [INFO] [image_processor3.py:__init__:273] 외부 인페인팅 서버 활성화 확인됨: https://inpaint.m1tcloud.cc +[2025-12-02 01:24:31,235] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-02 01:24:31,236] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-02 01:24:31,535] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-02 01:24:31,535] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-02 01:24:31,536] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: llm_test_result +[2025-12-02 01:24:31,536] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-02 01:24:31,543] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-02 01:24:32,199] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 656.0ms +[2025-12-02 01:24:32,199] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 75.0ms, 인식: 554.0ms, 분류: 19.0ms +[2025-12-02 01:24:32,211] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 32102.2MB -> 32310.1MB (+207.9MB, +0.6%) - 이미지 1 +[2025-12-02 01:24:32,224] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-02 01:24:32,250] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-02 01:24:32,250] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-02 01:24:32,250] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-02 01:24:32,250] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-02 01:24:32,251] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-02 01:24:32,251] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-02 01:24:32,251] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-02 01:24:32,252] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-02 01:24:32,252] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-02 01:24:32,252] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-02 01:24:32,252] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-02 01:24:32,252] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-02 01:24:32,253] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-02 01:24:32,253] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-02 01:24:32,253] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-02 01:24:32,253] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-02 01:24:32,253] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-02 01:24:32,253] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-02 01:24:32,254] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-02 01:24:32,254] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-02 01:24:32,254] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-02 01:24:32,254] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-02 01:24:32,254] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-02 01:24:32,255] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-02 01:24:32,255] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-02 01:24:32,255] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-02 01:24:32,255] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-02 01:24:32,255] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-02 01:24:32,264] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-02 01:24:32,265] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-02 01:24:32,265] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-02 01:25:02,528] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 1/2 대기 1.12s +[2025-12-02 01:25:33,948] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 2/2 대기 0.64s +[2025-12-02 01:26:04,805] [asyncio_0] [ERROR] [loggerModule.py:error:322] [GemmaTranslator] run_llm_translation failed: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) +[2025-12-02 01:26:04,813] [asyncio_0] [ERROR] [image_processor3.py:batch_llm_translate_texts:1637] LLM 번역 실패: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30). 구글 번역으로 폴백. +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 1628, in batch_llm_translate_texts + return self.ai_translator.run_llm_translation( + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 378, in run_llm_translation + raise e + File "D:\py\img_worker\modules\gemma_client.py", line 283, in run_llm_translation + resp = self._post(path, payload) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 100, in _post + raise GemmaTranslatorError(f"POST {url} 실패: {last_err}") +modules.gemma_client.GemmaTranslatorError: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) + +[2025-12-02 01:26:05,330] [MainThread] [DEBUG] [image_processor3.py:process_single_image:748] translated_texts: ['코르노', 'CMC 인증', 'CPA 자격증', '국가 방폭형', 'ISO 인증', 'CE 인증', 'SGS 인증', '레이저 먼지 감지기', '정확도≤±5%F.S', '보호 수준:', '과전압 보호 / 소리와 빛 경보 / 매장 인쇄', '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능', '클래스 100,000 이상의 클린룸에 적합', '전국', '7일이면 반품할 이유가 없습니다.', '무료 배송 보험', '무료 배송', '오리지널 정품 / 청구 가능 / 1년 보증'] +[2025-12-02 01:26:05,330] [MainThread] [DEBUG] [image_processor3.py:process_single_image:749] 마스크 생성 완료 +[2025-12-02 01:26:05,331] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 1] 원본 텍스트: '코르노' +[2025-12-02 01:26:05,331] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 1] 분리된 단어: ['코르노'] +[2025-12-02 01:26:05,331] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 1] 변경 없음: '코르노' +[2025-12-02 01:26:05,331] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 2] 원본 텍스트: 'CMC 인증' +[2025-12-02 01:26:05,332] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 2] 분리된 단어: ['CMC', '인증'] +[2025-12-02 01:26:05,332] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 2] 변경 없음: 'CMC 인증' +[2025-12-02 01:26:05,332] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 3] 원본 텍스트: 'CPA 자격증' +[2025-12-02 01:26:05,332] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 3] 분리된 단어: ['CPA', '자격증'] +[2025-12-02 01:26:05,332] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 3] 변경 없음: 'CPA 자격증' +[2025-12-02 01:26:05,332] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 4] 원본 텍스트: '국가 방폭형' +[2025-12-02 01:26:05,333] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 4] 분리된 단어: ['국가', '방폭형'] +[2025-12-02 01:26:05,333] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 4] 변경 없음: '국가 방폭형' +[2025-12-02 01:26:05,333] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 5] 원본 텍스트: 'ISO 인증' +[2025-12-02 01:26:05,333] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 5] 분리된 단어: ['ISO', '인증'] +[2025-12-02 01:26:05,333] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 5] 변경 없음: 'ISO 인증' +[2025-12-02 01:26:05,334] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 6] 원본 텍스트: 'CE 인증' +[2025-12-02 01:26:05,334] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 6] 분리된 단어: ['CE', '인증'] +[2025-12-02 01:26:05,334] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 6] 변경 없음: 'CE 인증' +[2025-12-02 01:26:05,334] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 7] 원본 텍스트: 'SGS 인증' +[2025-12-02 01:26:05,334] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 7] 분리된 단어: ['SGS', '인증'] +[2025-12-02 01:26:05,335] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 7] 변경 없음: 'SGS 인증' +[2025-12-02 01:26:05,335] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 8] 원본 텍스트: '레이저 먼지 감지기' +[2025-12-02 01:26:05,335] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 8] 분리된 단어: ['레이저', '먼지', '감지기'] +[2025-12-02 01:26:05,335] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 8] 변경 없음: '레이저 먼지 감지기' +[2025-12-02 01:26:05,335] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 9] 원본 텍스트: '정확도≤±5%F.S' +[2025-12-02 01:26:05,336] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 9] 분리된 단어: ['정확도≤±5%F.S'] +[2025-12-02 01:26:05,336] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 9] 변경 없음: '정확도≤±5%F.S' +[2025-12-02 01:26:05,336] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 10] 원본 텍스트: '보호 수준:' +[2025-12-02 01:26:05,336] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 10] 분리된 단어: ['보호', '수준:'] +[2025-12-02 01:26:05,336] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 10] 변경 없음: '보호 수준:' +[2025-12-02 01:26:05,337] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 11] 원본 텍스트: '과전압 보호 / 소리와 빛 경보 / 매장 인쇄' +[2025-12-02 01:26:05,337] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 11] 분리된 단어: ['과전압', '보호', '/', '소리와', '빛', '경보', '/', '매장', '인쇄'] +[2025-12-02 01:26:05,337] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 11] 변경 없음: '과전압 보호 / 소리와 빛 경보 / 매장 인쇄' +[2025-12-02 01:26:05,337] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 12] 원본 텍스트: '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능' +[2025-12-02 01:26:05,337] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 12] 분리된 단어: ['다양한', '입자', '크기의', '먼지', '입자', '수를', '동시에', '모니터링', '가능'] +[2025-12-02 01:26:05,338] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 12] 변경 없음: '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능' +[2025-12-02 01:26:05,338] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 13] 원본 텍스트: '클래스 100,000 이상의 클린룸에 적합' +[2025-12-02 01:26:05,338] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 13] 분리된 단어: ['클래스', '100,000', '이상의', '클린룸에', '적합'] +[2025-12-02 01:26:05,339] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 13] 변경 없음: '클래스 100,000 이상의 클린룸에 적합' +[2025-12-02 01:26:05,339] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 14] 원본 텍스트: '전국' +[2025-12-02 01:26:05,339] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 14] 분리된 단어: ['전국'] +[2025-12-02 01:26:05,339] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 14] 변경 없음: '전국' +[2025-12-02 01:26:05,339] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 15] 원본 텍스트: '7일이면 반품할 이유가 없습니다.' +[2025-12-02 01:26:05,340] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 15] 분리된 단어: ['7일이면', '반품할', '이유가', '없습니다.'] +[2025-12-02 01:26:05,340] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 15] 변경 없음: '7일이면 반품할 이유가 없습니다.' +[2025-12-02 01:26:05,340] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 16] 원본 텍스트: '무료 배송 보험' +[2025-12-02 01:26:05,341] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 16] 분리된 단어: ['무료', '배송', '보험'] +[2025-12-02 01:26:05,341] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 16] 변경 없음: '무료 배송 보험' +[2025-12-02 01:26:05,341] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 17] 원본 텍스트: '무료 배송' +[2025-12-02 01:26:05,341] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 17] 분리된 단어: ['무료', '배송'] +[2025-12-02 01:26:05,342] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 17] 변경 없음: '무료 배송' +[2025-12-02 01:26:05,342] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 18] 원본 텍스트: '오리지널 정품 / 청구 가능 / 1년 보증' +[2025-12-02 01:26:05,342] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 18] 분리된 단어: ['오리지널', '정품', '/', '청구', '가능', '/', '1년', '보증'] +[2025-12-02 01:26:05,342] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 18] 변경 없음: '오리지널 정품 / 청구 가능 / 1년 보증' +[2025-12-02 01:26:05,343] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1496] 전체 치환 결과: 18개 텍스트 처리 완료 +[2025-12-02 01:26:05,343] [MainThread] [DEBUG] [image_processor3.py:process_single_image:758] 이미지 1 치환됨 +[2025-12-02 01:26:05,345] [MainThread] [INFO] [image_processor3.py:process_single_image:795] [AUTO Inpaint] coverage=0.388, comps=8, min_center_dist=0.072 → external_request +[2025-12-02 01:26:05,345] [MainThread] [DEBUG] [image_processor3.py:process_single_image:808] ocr_count: 18 +[2025-12-02 01:26:05,345] [MainThread] [DEBUG] [image_processor3.py:process_single_image:809] is_member_valid: True +[2025-12-02 01:26:05,346] [MainThread] [DEBUG] [image_processor3.py:process_single_image:813] 최종 inpaint_method: external_request +[2025-12-02 01:26:05,351] [asyncio_1] [DEBUG] [image_processor3.py:_try_external_inpaint:1141] 외부 인페인팅 시도: https://inpaint.m1tcloud.cc +[2025-12-02 01:26:05,698] [asyncio_1] [DEBUG] [request_inpaint.py:request_external_inpaint:175] 외부 인페인팅 서버 요청: https://inpaint.m1tcloud.cc/api/v1/inpaint, model=simple-lama +[2025-12-02 01:26:07,055] [asyncio_1] [DEBUG] [request_inpaint.py:request_external_inpaint:187] 외부 인페인팅 성공 +[2025-12-02 01:26:07,062] [asyncio_1] [INFO] [image_processor3.py:execute_inpaint_with_fallback:1080] 메모리 변화 [인페인팅]: 31036.4MB -> 31097.1MB (+60.7MB, +0.2%) - 방법: external_request +[2025-12-02 01:26:07,062] [MainThread] [DEBUG] [image_processor3.py:process_single_image:826] 인페인팅 완료 +[2025-12-02 01:26:07,125] [MainThread] [DEBUG] [image_processor3.py:process_single_image:848] 텍스트 렌더링 완료 +[2025-12-02 01:26:07,126] [MainThread] [DEBUG] [image_processor3.py:postProcess_and_save_image:1281] watermark_text: 이미지 저작권 보유 +[2025-12-02 01:26:07,126] [MainThread] [DEBUG] [image_processor3.py:postProcess_and_save_image:1282] is_watermark_enabled: True +[2025-12-02 01:26:07,128] [MainThread] [INFO] [postImageManager.py:save_image_to_path:101] 이미지 저장 완료 : D:\py\img_worker\modules\test\temp\translated_llm_test_result_img_1.jpg +[2025-12-02 01:26:07,128] [MainThread] [DEBUG] [image_processor3.py:process_single_image:854] 이미지 1 번역 완료: D:\py\img_worker\modules\test\temp\translated_llm_test_result_img_1.jpg +[2025-12-02 01:26:07,157] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 95921.5ms | download=0.0ms | ocr=670.0ms | translate=93063.4ms | mask=8.0ms | inpaint=1716.5ms(external_request/SERVER) | render=62.0ms | save=2.0ms +[2025-12-02 01:26:07,171] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-02 01:26:07,171] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-02 01:26:07,199] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-02 01:26:07,219] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-02 01:26:07,220] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_21308.log b/modules/test/Edit_PartTimer_log_21308.log new file mode 100644 index 0000000..2039db8 --- /dev/null +++ b/modules/test/Edit_PartTimer_log_21308.log @@ -0,0 +1,36 @@ +[2025-12-01 23:38:43,542] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-01 23:38:43,549] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-01 23:38:43,549] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-01 23:38:43,550] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-01 23:38:43,550] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-01 23:38:43,550] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-01 23:38:43,550] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-01 23:38:43,550] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-01 23:38:43,551] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-01 23:38:43,551] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-01 23:38:43,551] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-01 23:38:43,551] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'font_type': '폰트8', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\Pretendard-Regular.ttf', 'ocr': True, 'force_cpu_ocr': True, 'use_cuda': False, 'inpaint_model': 'migan', 'local_inpaint_method': 'migan', 'migan_onnx_path': 'D:\\py\\img_worker\\modules\\migan_onnx\\migan_pipeline_v2.onnx', 'migan_use_accel': False, 'migan_provider_override': 'cpu', 'detail_IMGTrans_type': 'CPU', 'optionIMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:38:43,551] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-01 23:38:43,552] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-01 23:38:43,552] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\Pretendard-Regular.ttf +[2025-12-01 23:38:43,552] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\Pretendard-Regular.ttf +[2025-12-01 23:38:43,552] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test +[2025-12-01 23:38:43,552] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-01 23:38:43,553] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-01 23:38:43,553] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-01 23:38:43,553] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-01 23:38:43,553] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-01 23:38:43,554] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-01 23:38:43,554] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-01 23:38:43,554] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-01 23:38:43,554] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:38:43,554] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:38:44,754] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-01 23:38:44,754] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-01 23:38:44,760] [MainThread] [ERROR] [image_processor3.py:cleanup:496] 리소스 정리 중 오류: sys.meta_path is None, Python is likely shutting down +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 481, in cleanup + import gc +ImportError: sys.meta_path is None, Python is likely shutting down + +[2025-12-01 23:38:44,760] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_22272.log b/modules/test/Edit_PartTimer_log_22272.log new file mode 100644 index 0000000..01579c7 --- /dev/null +++ b/modules/test/Edit_PartTimer_log_22272.log @@ -0,0 +1,111 @@ +[2025-12-02 16:50:01,615] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-02 16:50:01,621] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-02 16:50:01,621] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-02 16:50:01,621] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-02 16:50:01,622] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-02 16:50:01,622] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-02 16:50:01,622] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-02 16:50:01,622] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-02 16:50:01,623] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-02 16:50:01,623] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-02 16:50:01,623] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-02 16:50:01,623] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-02 16:50:01,624] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-02 16:50:01,624] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-02 16:50:01,624] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 16:50:01,624] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 16:50:01,625] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test\temp +[2025-12-02 16:50:01,625] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-02 16:50:01,625] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-02 16:50:01,625] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-02 16:50:01,625] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-02 16:50:01,626] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-02 16:50:01,626] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-02 16:50:01,626] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-02 16:50:01,626] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-02 16:50:01,627] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-02 16:50:01,627] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-02 16:50:03,939] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-02 16:50:04,055] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-02 16:50:04,055] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-02 16:50:04,055] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-02 16:50:04,056] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-02 16:50:04,057] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: https://inpaint.m1tcloud.cc +[2025-12-02 16:50:04,057] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=https://inpaint.m1tcloud.cc +[2025-12-02 16:50:04,057] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-02 16:50:04,057] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-02 16:50:04,057] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-02 16:50:04,058] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 16:50:04,058] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-02 16:50:04,060] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 16:50:04,060] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-02 16:50:04,060] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-02 16:50:04,060] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-02 16:50:04,060] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-02 16:50:04,062] [MainThread] [DEBUG] [image_processor3.py:__init__:258] MIGAN 초기화 건너뜀: inpaint_method=request, local_inpaint_method=request, migan_onnx_path=False +[2025-12-02 16:50:04,645] [MainThread] [INFO] [image_processor3.py:__init__:273] 외부 인페인팅 서버 활성화 확인됨: https://inpaint.m1tcloud.cc +[2025-12-02 16:50:04,646] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-02 16:50:04,646] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-02 16:50:04,925] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-02 16:50:04,925] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-02 16:50:04,925] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: llm_test_result +[2025-12-02 16:50:04,926] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-02 16:50:04,938] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-02 16:50:05,616] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 677.6ms +[2025-12-02 16:50:05,616] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 85.0ms, 인식: 561.6ms, 분류: 21.0ms +[2025-12-02 16:50:05,632] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 18333.7MB -> 18542.9MB (+209.2MB, +1.1%) - 이미지 1 +[2025-12-02 16:50:05,645] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-02 16:50:05,668] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-02 16:50:05,669] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-02 16:50:05,669] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-02 16:50:05,669] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-02 16:50:05,669] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-02 16:50:05,670] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-02 16:50:05,670] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-02 16:50:05,670] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-02 16:50:05,670] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-02 16:50:05,670] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-02 16:50:05,670] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-02 16:50:05,671] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-02 16:50:05,671] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-02 16:50:05,671] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-02 16:50:05,671] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-02 16:50:05,671] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-02 16:50:05,671] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-02 16:50:05,672] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-02 16:50:05,672] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-02 16:50:05,672] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-02 16:50:05,672] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-02 16:50:05,672] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-02 16:50:05,673] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-02 16:50:05,673] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-02 16:50:05,673] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-02 16:50:05,673] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-02 16:50:05,673] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-02 16:50:05,674] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-02 16:50:05,683] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-02 16:50:05,683] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-02 16:50:05,684] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-02 16:50:35,893] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3&steps=1 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 1/2 대기 1.06s +[2025-12-02 16:50:41,010] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 36363.7ms | download=0.0ms | ocr=700.6ms +[2025-12-02 16:50:41,023] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-02 16:50:41,023] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-02 16:50:41,047] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-02 16:51:07,229] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3&steps=1 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 2/2 대기 0.69s +[2025-12-02 16:51:38,127] [asyncio_0] [ERROR] [loggerModule.py:error:322] [GemmaTranslator] run_llm_translation failed: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3&steps=1 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) +[2025-12-02 16:51:38,135] [asyncio_0] [ERROR] [image_processor3.py:batch_llm_translate_texts:1642] LLM 번역 실패: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3&steps=1 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30). 구글 번역으로 폴백. +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 1632, in batch_llm_translate_texts + return self.ai_translator.run_llm_translation( + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 390, in run_llm_translation + raise e + File "D:\py\img_worker\modules\gemma_client.py", line 295, in run_llm_translation + resp = self._post(path, payload) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 100, in _post + raise GemmaTranslatorError(f"POST {url} 실패: {last_err}") +modules.gemma_client.GemmaTranslatorError: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3&steps=1 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) + +[2025-12-02 16:51:40,539] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-02 16:51:40,539] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_24188.log b/modules/test/Edit_PartTimer_log_24188.log new file mode 100644 index 0000000..9eb717e --- /dev/null +++ b/modules/test/Edit_PartTimer_log_24188.log @@ -0,0 +1,111 @@ +[2025-12-01 23:51:38,958] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-01 23:51:38,965] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-01 23:51:38,965] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-01 23:51:38,965] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-01 23:51:38,965] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-01 23:51:38,966] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-01 23:51:38,966] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-01 23:51:38,966] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-01 23:51:38,967] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-01 23:51:38,967] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-01 23:51:38,967] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-01 23:51:38,967] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:51:38,968] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-01 23:51:38,968] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-01 23:51:38,968] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:51:38,969] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:51:38,969] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test\temp +[2025-12-01 23:51:38,969] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-01 23:51:38,969] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-01 23:51:38,970] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-01 23:51:38,970] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-01 23:51:38,970] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-01 23:51:38,971] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-01 23:51:38,971] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-01 23:51:38,971] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-01 23:51:38,971] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:51:38,971] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:51:40,935] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-01 23:51:41,028] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-01 23:51:41,028] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-01 23:51:41,029] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-01 23:51:41,030] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-01 23:51:41,030] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: https://inpaint.m1tcloud.cc +[2025-12-01 23:51:41,030] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=https://inpaint.m1tcloud.cc +[2025-12-01 23:51:41,031] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-01 23:51:41,031] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-01 23:51:41,031] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-01 23:51:41,031] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:51:41,032] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-01 23:51:41,032] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:51:41,032] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-01 23:51:41,032] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-01 23:51:41,033] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-01 23:51:41,033] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-01 23:51:41,034] [MainThread] [DEBUG] [image_processor3.py:__init__:258] MIGAN 초기화 건너뜀: inpaint_method=request, local_inpaint_method=request, migan_onnx_path=False +[2025-12-01 23:51:41,661] [MainThread] [INFO] [image_processor3.py:__init__:273] 외부 인페인팅 서버 활성화 확인됨: https://inpaint.m1tcloud.cc +[2025-12-01 23:51:41,662] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-01 23:51:41,662] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:51:41,907] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-01 23:51:41,907] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:51:41,908] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: llm_test_result +[2025-12-01 23:51:41,908] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:51:41,916] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-01 23:51:42,590] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 674.0ms +[2025-12-01 23:51:42,591] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 78.0ms, 인식: 567.0ms, 분류: 20.0ms +[2025-12-01 23:51:42,604] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 32077.1MB -> 32290.2MB (+213.1MB, +0.7%) - 이미지 1 +[2025-12-01 23:51:42,616] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:51:42,642] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-01 23:51:42,643] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-01 23:51:42,643] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-01 23:51:42,643] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-01 23:51:42,643] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-01 23:51:42,644] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-01 23:51:42,644] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-01 23:51:42,644] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-01 23:51:42,644] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-01 23:51:42,644] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-01 23:51:42,645] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-01 23:51:42,645] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-01 23:51:42,645] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-01 23:51:42,645] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-01 23:51:42,645] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-01 23:51:42,645] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-01 23:51:42,646] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-01 23:51:42,646] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-01 23:51:42,646] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-01 23:51:42,646] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-01 23:51:42,646] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-01 23:51:42,646] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-01 23:51:42,647] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-01 23:51:42,647] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-01 23:51:42,647] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-01 23:51:42,647] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-01 23:51:42,648] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-01 23:51:42,648] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-01 23:51:42,657] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:51:42,658] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-01 23:51:42,658] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-01 23:52:12,868] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 1/2 대기 1.19s +[2025-12-01 23:52:44,271] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 2/2 대기 0.63s +[2025-12-01 23:52:58,180] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 76516.9ms | download=1.0ms | ocr=690.0ms +[2025-12-01 23:52:58,193] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-01 23:52:58,193] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-01 23:52:58,217] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-01 23:53:15,150] [asyncio_0] [ERROR] [loggerModule.py:error:322] [GemmaTranslator] run_llm_translation failed: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) +[2025-12-01 23:53:15,158] [asyncio_0] [ERROR] [image_processor3.py:batch_llm_translate_texts:1637] LLM 번역 실패: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30). 구글 번역으로 폴백. +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 1628, in batch_llm_translate_texts + return self.ai_translator.run_llm_translation( + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 378, in run_llm_translation + raise e + File "D:\py\img_worker\modules\gemma_client.py", line 283, in run_llm_translation + resp = self._post(path, payload) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 100, in _post + raise GemmaTranslatorError(f"POST {url} 실패: {last_err}") +modules.gemma_client.GemmaTranslatorError: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) + +[2025-12-01 23:53:16,881] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-01 23:53:16,882] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_28972.log b/modules/test/Edit_PartTimer_log_28972.log new file mode 100644 index 0000000..e7673aa --- /dev/null +++ b/modules/test/Edit_PartTimer_log_28972.log @@ -0,0 +1,111 @@ +[2025-12-02 01:19:30,814] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-02 01:19:30,821] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-02 01:19:30,821] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-02 01:19:30,821] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-02 01:19:30,821] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-02 01:19:30,822] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-02 01:19:30,822] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-02 01:19:30,822] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-02 01:19:30,822] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-02 01:19:30,822] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-02 01:19:30,822] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-02 01:19:30,823] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-02 01:19:30,823] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-02 01:19:30,823] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-02 01:19:30,823] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:19:30,824] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:19:30,824] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test\temp +[2025-12-02 01:19:30,824] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-02 01:19:30,824] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-02 01:19:30,824] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-02 01:19:30,824] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-02 01:19:30,825] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-02 01:19:30,825] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-02 01:19:30,825] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-02 01:19:30,825] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-02 01:19:30,826] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-02 01:19:30,826] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-02 01:19:32,645] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-02 01:19:32,732] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-02 01:19:32,733] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-02 01:19:32,733] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-02 01:19:32,734] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-02 01:19:32,734] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: https://inpaint.m1tcloud.cc +[2025-12-02 01:19:32,734] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=https://inpaint.m1tcloud.cc +[2025-12-02 01:19:32,735] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-02 01:19:32,735] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-02 01:19:32,735] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-02 01:19:32,735] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:19:32,735] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-02 01:19:32,736] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-02 01:19:32,736] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-02 01:19:32,736] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-02 01:19:32,736] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-02 01:19:32,736] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-02 01:19:32,738] [MainThread] [DEBUG] [image_processor3.py:__init__:258] MIGAN 초기화 건너뜀: inpaint_method=request, local_inpaint_method=request, migan_onnx_path=False +[2025-12-02 01:19:33,192] [MainThread] [INFO] [image_processor3.py:__init__:273] 외부 인페인팅 서버 활성화 확인됨: https://inpaint.m1tcloud.cc +[2025-12-02 01:19:33,193] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-02 01:19:33,193] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-02 01:19:33,399] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-02 01:19:33,399] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-02 01:19:33,400] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: llm_test_result +[2025-12-02 01:19:33,400] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-02 01:19:33,409] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-02 01:19:34,084] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 674.1ms +[2025-12-02 01:19:34,085] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 74.0ms, 인식: 574.1ms, 분류: 19.0ms +[2025-12-02 01:19:34,097] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 30899.2MB -> 31190.9MB (+291.7MB, +0.9%) - 이미지 1 +[2025-12-02 01:19:34,110] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-02 01:19:34,135] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-02 01:19:34,135] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-02 01:19:34,136] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-02 01:19:34,136] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-02 01:19:34,136] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-02 01:19:34,136] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-02 01:19:34,137] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-02 01:19:34,137] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-02 01:19:34,137] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-02 01:19:34,137] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-02 01:19:34,138] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-02 01:19:34,138] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-02 01:19:34,138] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-02 01:19:34,138] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-02 01:19:34,138] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-02 01:19:34,139] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-02 01:19:34,139] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-02 01:19:34,139] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-02 01:19:34,139] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-02 01:19:34,139] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-02 01:19:34,139] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-02 01:19:34,140] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-02 01:19:34,140] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-02 01:19:34,140] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-02 01:19:34,140] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-02 01:19:34,141] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-02 01:19:34,141] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-02 01:19:34,141] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-02 01:19:34,150] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-02 01:19:34,151] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-02 01:19:34,151] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-02 01:20:04,412] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 1/2 대기 1.00s +[2025-12-02 01:20:35,656] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 2/2 대기 0.80s +[2025-12-02 01:20:40,943] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 67749.7ms | download=1.1ms | ocr=692.1ms +[2025-12-02 01:20:40,957] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-02 01:20:40,957] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-02 01:20:40,980] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-02 01:21:06,690] [asyncio_0] [ERROR] [loggerModule.py:error:322] [GemmaTranslator] run_llm_translation failed: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) +[2025-12-02 01:21:06,701] [asyncio_0] [ERROR] [image_processor3.py:batch_llm_translate_texts:1637] LLM 번역 실패: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30). 구글 번역으로 폴백. +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 1628, in batch_llm_translate_texts + return self.ai_translator.run_llm_translation( + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 378, in run_llm_translation + raise e + File "D:\py\img_worker\modules\gemma_client.py", line 283, in run_llm_translation + resp = self._post(path, payload) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 100, in _post + raise GemmaTranslatorError(f"POST {url} 실패: {last_err}") +modules.gemma_client.GemmaTranslatorError: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30) + +[2025-12-02 01:21:07,359] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-02 01:21:07,359] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_6996.log b/modules/test/Edit_PartTimer_log_6996.log new file mode 100644 index 0000000..66150ab --- /dev/null +++ b/modules/test/Edit_PartTimer_log_6996.log @@ -0,0 +1,111 @@ +[2025-12-01 23:38:47,518] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-01 23:38:47,524] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-01 23:38:47,524] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-01 23:38:47,524] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-01 23:38:47,524] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-01 23:38:47,525] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-01 23:38:47,525] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-01 23:38:47,525] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-01 23:38:47,525] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-01 23:38:47,526] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-01 23:38:47,526] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-01 23:38:47,526] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:38:47,526] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-01 23:38:47,527] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-01 23:38:47,527] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:38:47,527] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:38:47,527] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test\temp +[2025-12-01 23:38:47,527] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-01 23:38:47,528] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-01 23:38:47,528] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-01 23:38:47,528] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-01 23:38:47,528] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-01 23:38:47,528] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-01 23:38:47,529] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-01 23:38:47,529] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-01 23:38:47,529] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:38:47,529] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:38:49,331] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-01 23:38:49,415] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-01 23:38:49,415] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-01 23:38:49,416] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-01 23:38:49,416] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-01 23:38:49,417] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: https://inpaint.m1tcloud.cc +[2025-12-01 23:38:49,417] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=https://inpaint.m1tcloud.cc +[2025-12-01 23:38:49,417] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-01 23:38:49,417] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-01 23:38:49,417] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-01 23:38:49,418] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:38:49,418] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-01 23:38:49,418] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:38:49,418] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-01 23:38:49,419] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-01 23:38:49,419] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-01 23:38:49,419] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-01 23:38:49,420] [MainThread] [DEBUG] [image_processor3.py:__init__:258] MIGAN 초기화 건너뜀: inpaint_method=request, local_inpaint_method=request, migan_onnx_path=False +[2025-12-01 23:38:52,627] [MainThread] [WARNING] [request_inpaint.py:is_server_alive:833] 서버 상태 확인 실패 (https://inpaint.m1tcloud.cc): HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=3) +[2025-12-01 23:38:52,629] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-01 23:38:52,629] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:38:53,031] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-01 23:38:53,031] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:38:53,031] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: llm_test_result +[2025-12-01 23:38:53,032] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:38:53,038] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-01 23:38:53,693] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 654.3ms +[2025-12-01 23:38:53,693] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 75.3ms, 인식: 553.0ms, 분류: 19.0ms +[2025-12-01 23:38:53,706] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 31423.5MB -> 31654.5MB (+230.9MB, +0.7%) - 이미지 1 +[2025-12-01 23:38:53,719] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:38:53,743] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-01 23:38:53,743] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-01 23:38:53,744] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-01 23:38:53,744] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-01 23:38:53,744] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-01 23:38:53,744] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-01 23:38:53,744] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-01 23:38:53,745] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-01 23:38:53,745] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-01 23:38:53,745] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-01 23:38:53,745] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-01 23:38:53,745] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-01 23:38:53,745] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-01 23:38:53,746] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-01 23:38:53,746] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-01 23:38:53,746] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-01 23:38:53,746] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-01 23:38:53,746] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-01 23:38:53,746] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-01 23:38:53,747] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-01 23:38:53,747] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-01 23:38:53,747] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-01 23:38:53,748] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-01 23:38:53,748] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-01 23:38:53,748] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-01 23:38:53,748] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-01 23:38:53,749] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-01 23:38:53,749] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-01 23:38:53,758] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:38:53,759] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-01 23:38:53,760] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-01 23:39:24,024] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 1/2 대기 1.19s +[2025-12-01 23:39:55,457] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 2/2 대기 0.63s +[2025-12-01 23:40:03,451] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 70820.9ms | download=0.0ms | ocr=669.3ms +[2025-12-01 23:40:03,464] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-01 23:40:03,464] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-01 23:40:03,487] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-01 23:40:10,137] [asyncio_0] [ERROR] [loggerModule.py:error:322] [GemmaTranslator] run_llm_translation failed: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: 502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 +[2025-12-01 23:40:10,144] [asyncio_0] [ERROR] [image_processor3.py:batch_llm_translate_texts:1637] LLM 번역 실패: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: 502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3. 구글 번역으로 폴백. +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 1628, in batch_llm_translate_texts + return self.ai_translator.run_llm_translation( + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 378, in run_llm_translation + raise e + File "D:\py\img_worker\modules\gemma_client.py", line 283, in run_llm_translation + resp = self._post(path, payload) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 100, in _post + raise GemmaTranslatorError(f"POST {url} 실패: {last_err}") +modules.gemma_client.GemmaTranslatorError: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: 502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 + +[2025-12-01 23:40:12,213] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-01 23:40:12,214] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/Edit_PartTimer_log_9948.log b/modules/test/Edit_PartTimer_log_9948.log new file mode 100644 index 0000000..c86661d --- /dev/null +++ b/modules/test/Edit_PartTimer_log_9948.log @@ -0,0 +1,186 @@ +[2025-12-01 23:41:24,914] [MainThread] [DEBUG] [image_processor3.py:__init__:58] tracemalloc 메모리 추적 시작 +[2025-12-01 23:41:24,920] [MainThread] [DEBUG] [gpu_utils.py:_setup_directml_environment:55] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2025-12-01 23:41:24,920] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:79] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2025-12-01 23:41:24,921] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:80] 🎯 사용자 GPU 가속 요청: False +[2025-12-01 23:41:24,921] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:81] 💻 현재 운영체제: Windows +[2025-12-01 23:41:24,921] [MainThread] [DEBUG] [gpu_utils.py:initialize_gpu_state:84] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2025-12-01 23:41:24,921] [MainThread] [INFO] [gpu_utils.py:_set_safe_cpu_mode:157] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2025-12-01 23:41:24,921] [MainThread] [DEBUG] [image_processor3.py:__init__:80] 🔧 ImageProcessor3 GPU 상태 요약: +[2025-12-01 23:41:24,922] [MainThread] [DEBUG] [image_processor3.py:__init__:81] - CUDA 사용 가능: False +[2025-12-01 23:41:24,922] [MainThread] [DEBUG] [image_processor3.py:__init__:82] - toggle_states['use_cuda']: False +[2025-12-01 23:41:24,922] [MainThread] [DEBUG] [image_processor3.py:__init__:83] - GPU 하드웨어 정보: {} +[2025-12-01 23:41:24,922] [MainThread] [DEBUG] [image_processor3.py:__init__:85] ImageProcessor3 Init toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:41:24,922] [MainThread] [DEBUG] [image_processor3.py:__init__:88] is_member_valid: True +[2025-12-01 23:41:24,923] [MainThread] [DEBUG] [image_processor3.py:__init__:110] debug_images 디렉토리 이미 존재: D:\py\img_worker\modules\debug_images +[2025-12-01 23:41:24,923] [MainThread] [DEBUG] [image_processor3.py:__init__:118] self.font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:41:24,923] [MainThread] [DEBUG] [image_processor3.py:__init__:120] toggle_states font_path: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:41:24,923] [MainThread] [DEBUG] [image_processor3.py:__init__:122] self.TEMP_IMAGE_DIR: D:\py\img_worker\modules\test\temp +[2025-12-01 23:41:24,923] [MainThread] [DEBUG] [image_processor3.py:__init__:124] self.debugging_save_Dir: D:\py\img_worker\modules\debug_images +[2025-12-01 23:41:24,924] [MainThread] [DEBUG] [image_processor3.py:__init__:126] self.unwanted_texts: {} +[2025-12-01 23:41:24,924] [MainThread] [DEBUG] [image_processor3.py:__init__:128] self.inpaint_method: migan +[2025-12-01 23:41:24,924] [MainThread] [DEBUG] [image_processor3.py:__init__:134] Image.MAX_IMAGE_PIXELS set to 20000000 +[2025-12-01 23:41:24,924] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_determine_model_type:447] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2025-12-01 23:41:24,925] [MainThread] [INFO] [onnx_ocr_wrapper.py:_determine_model_type:453] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2025-12-01 23:41:24,925] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:324] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2025-12-01 23:41:24,925] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:333] ONNX OCR 모듈 CPU 모드로 설정 +[2025-12-01 23:41:24,925] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:356] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:41:24,925] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_initialize_onnx_system:539] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2025-12-01 23:41:26,761] [MainThread] [DEBUG] [onnx_ocr_wrapper.py:_ensure_utf8_encoding:487] 문자 사전 파일 UTF-8 확인 완료: D:\py\img_worker\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2025-12-01 23:41:26,849] [MainThread] [INFO] [onnx_ocr_wrapper.py:_initialize_onnx_system:743] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2025-12-01 23:41:26,849] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:363] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2025-12-01 23:41:26,849] [MainThread] [INFO] [onnx_ocr_wrapper.py:__init__:364] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2025-12-01 23:41:26,850] [MainThread] [INFO] [image_processor3.py:__init__:141] ✅ ONNX OCR 모듈 초기화 성공 +[2025-12-01 23:41:26,851] [MainThread] [DEBUG] [image_processor3.py:__init__:153] gemma_api_base_url: https://inpaint.m1tcloud.cc +[2025-12-01 23:41:26,851] [MainThread] [INFO] [image_processor3.py:__init__:154] GemmaTranslator 연결: base=https://inpaint.m1tcloud.cc +[2025-12-01 23:41:26,852] [MainThread] [INFO] [mask_module_for_paddle.py:__init__:12] 마스크 모듈 초기화 완료 +[2025-12-01 23:41:26,852] [MainThread] [DEBUG] [image_processor3.py:__init__:183] MaskModule 초기화 성공 +[2025-12-01 23:41:26,852] [MainThread] [INFO] [text_rendering_module.py:__init__:21] 텍스트 렌더링 모듈 초기화 완료 +[2025-12-01 23:41:26,852] [MainThread] [INFO] [text_rendering_module.py:__init__:22] 기본 폰트: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:41:26,853] [MainThread] [DEBUG] [image_processor3.py:__init__:189] TextRenderingModule 초기화 성공 +[2025-12-01 23:41:26,854] [MainThread] [DEBUG] [postImageManager.py:font_load:40] 폰트 로드 성공: D:\py\img_worker\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2025-12-01 23:41:26,854] [MainThread] [DEBUG] [image_processor3.py:__init__:195] PostImageManager 초기화 성공 +[2025-12-01 23:41:26,854] [MainThread] [DEBUG] [request_inpaint.py:__init__:43] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2025-12-01 23:41:26,854] [MainThread] [DEBUG] [image_processor3.py:__init__:218] Request_AI_Server 초기화 성공 +[2025-12-01 23:41:26,855] [MainThread] [DEBUG] [image_processor3.py:__init__:225] GoogleTranslate 초기화 성공 +[2025-12-01 23:41:26,856] [MainThread] [DEBUG] [image_processor3.py:__init__:258] MIGAN 초기화 건너뜀: inpaint_method=request, local_inpaint_method=request, migan_onnx_path=False +[2025-12-01 23:41:27,548] [MainThread] [INFO] [image_processor3.py:__init__:273] 외부 인페인팅 서버 활성화 확인됨: https://inpaint.m1tcloud.cc +[2025-12-01 23:41:27,549] [MainThread] [DEBUG] [image_processor3.py:process_single_image:590] 이미지 번역시작 +[2025-12-01 23:41:27,549] [MainThread] [DEBUG] [image_processor3.py:process_single_image:592] toggle_states: {'translation_method': 'llm', 'gemma_api_base_url': 'https://inpaint.m1tcloud.cc', 'gemma_api_timeout': 30, 'request_inpainting_server_url': 'https://inpaint.m1tcloud.cc', 'product_name': 'Test Product', 'category': 'Test Category', 'font_type': '폰트1', 'image_font_path': 'D:\\py\\img_worker\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'ocr': True, 'use_cuda': False, 'force_cpu_ocr': True, 'inpaint_model': 'request', 'local_inpaint_method': 'request', 'TEMP_IMAGE_DIR': 'D:\\py\\img_worker\\modules\\test\\temp', 'output_image_format': 'jpg', 'watermark_toggle': False, 'store_ocr_data_to_db': False, 'ocr_engine': 'onnx'} +[2025-12-01 23:41:28,038] [MainThread] [DEBUG] [image_processor3.py:process_single_image:610] 이미지 1 처리 시작: D:\py\img_worker\modules\test\2.jpg - OCR+인페인팅 모드 +[2025-12-01 23:41:28,038] [MainThread] [DEBUG] [image_processor3.py:download_image:1328] 로컬 파일 경로 감지, 다운로드 생략: D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:41:28,038] [MainThread] [DEBUG] [image_processor3.py:process_single_image:633] 옵션 이미지는 스케일 처리 건너뛰기: llm_test_result +[2025-12-01 23:41:28,039] [MainThread] [DEBUG] [image_processor3.py:process_single_image:643] 이미지 1 로컬 저장위치(옵션 이미지 원본 유지): D:\py\img_worker\modules\test\2.jpg +[2025-12-01 23:41:28,046] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:838] 🔍 ONNX OCR 감지 방식: polygon +[2025-12-01 23:41:28,701] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:906] ⚡ ONNX OCR 추론 완료: 654.2ms +[2025-12-01 23:41:28,702] [MainThread] [INFO] [onnx_ocr_wrapper.py:detect_text:907] 📊 세부 시간 - 감지: 79.0ms, 인식: 550.2ms, 분류: 19.0ms +[2025-12-01 23:41:28,714] [MainThread] [INFO] [image_processor3.py:process_single_image:659] 메모리 변화 [OCR 처리]: 30935.2MB -> 31168.1MB (+232.9MB, +0.8%) - 이미지 1 +[2025-12-01 23:41:28,727] [MainThread] [DEBUG] [image_processor3.py:process_single_image:664] ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'MC', 'confidence': 0.6195815205574036, 'polygon': [[243.0, 22.0], [291.0, 22.0], [291.0, 45.0], [243.0, 45.0]], 'bbox': (243, 22, 49, 24), 'method': 'polygon'}, {'text': 'PA', 'confidence': 0.9959151744842529, 'polygon': [[309.0, 22.0], [350.0, 24.0], [349.0, 43.0], [308.0, 41.0]], 'bbox': (308, 22, 43, 22), 'method': 'polygon'}, {'text': 'CNEX', 'confidence': 0.9921517372131348, 'polygon': [[372.0, 25.0], [423.0, 25.0], [423.0, 41.0], [372.0, 41.0]], 'bbox': (372, 25, 52, 17), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9579383730888367, 'polygon': [[493.0, 17.0], [542.0, 17.0], [542.0, 48.0], [493.0, 48.0]], 'bbox': (493, 17, 50, 32), 'method': 'polygon'}, {'text': 'SGS', 'confidence': 0.9938830733299255, 'polygon': [[561.0, 19.0], [611.0, 19.0], [611.0, 46.0], [561.0, 46.0]], 'bbox': (561, 19, 51, 28), 'method': 'polygon'}, {'text': 'KORNO', 'confidence': 0.9965261220932007, 'polygon': [[75.0, 53.0], [158.0, 53.0], [158.0, 74.0], [75.0, 74.0]], 'bbox': (75, 53, 84, 22), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': 'GT-1000', 'confidence': 0.9941906332969666, 'polygon': [[45.0, 101.0], [283.0, 101.0], [283.0, 146.0], [45.0, 146.0]], 'bbox': (45, 101, 239, 46), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': ':IP65', 'confidence': 0.9789117574691772, 'polygon': [[148.0, 295.0], [236.0, 295.0], [236.0, 323.0], [148.0, 323.0]], 'bbox': (148, 295, 89, 29), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': 'PM0.3/0.5/1.0/2.5/5.0/10um', 'confidence': 0.9829089641571045, 'polygon': [[21.0, 410.0], [425.0, 413.0], [425.0, 440.0], [21.0, 437.0]], 'bbox': (21, 410, 405, 31), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:41:28,751] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): '科尔诺' +[2025-12-01 23:41:28,751] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'MC' +[2025-12-01 23:41:28,751] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PA' +[2025-12-01 23:41:28,752] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CNEX' +[2025-12-01 23:41:28,752] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'CE' +[2025-12-01 23:41:28,752] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'SGS' +[2025-12-01 23:41:28,752] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'KORNO' +[2025-12-01 23:41:28,752] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.5%): 'CMC认证' +[2025-12-01 23:41:28,753] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CPA认证' +[2025-12-01 23:41:28,753] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '国家防爆' +[2025-12-01 23:41:28,753] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): 'ISO认证' +[2025-12-01 23:41:28,753] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): 'CE认证' +[2025-12-01 23:41:28,753] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): 'SGS认证' +[2025-12-01 23:41:28,753] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'GT-1000' +[2025-12-01 23:41:28,754] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '激光粉尘检测仪' +[2025-12-01 23:41:28,754] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 95.1%): '精度≤±5%F.S' +[2025-12-01 23:41:28,754] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '防护等级：' +[2025-12-01 23:41:28,754] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): ':IP65' +[2025-12-01 23:41:28,754] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 96.2%): '过压保护/声光报警/存储打印' +[2025-12-01 23:41:28,754] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1240] [필터링] 제외 (중국어 없음): 'PM0.3/0.5/1.0/2.5/5.0/10um' +[2025-12-01 23:41:28,755] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.7%): '可同时监测多种粒径尘埃粒子数' +[2025-12-01 23:41:28,755] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.2%): '适合十万级以上洁净室' +[2025-12-01 23:41:28,755] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '全国' +[2025-12-01 23:41:28,755] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.8%): '7天无理由退货' +[2025-12-01 23:41:28,755] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.9%): '赠运险费' +[2025-12-01 23:41:28,756] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '包邮' +[2025-12-01 23:41:28,756] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1238] [필터링] 포함 (신뢰도 99.1%): '原厂正品/可开发票/质保一年' +[2025-12-01 23:41:28,756] [MainThread] [DEBUG] [image_processor3.py:filter_ocr_results:1242] 필터링 결과: 18/27개 (신뢰도 + & 중국어) +[2025-12-01 23:41:28,765] [MainThread] [DEBUG] [image_processor3.py:process_single_image:676] filter_ocr_results: [{'text': '科尔诺', 'confidence': 0.9947741627693176, 'polygon': [[74.0, 20.0], [157.0, 20.0], [157.0, 49.0], [74.0, 49.0]], 'bbox': (74, 20, 84, 30), 'method': 'polygon'}, {'text': 'CMC认证', 'confidence': 0.9946390390396118, 'polygon': [[240.0, 57.0], [291.0, 57.0], [291.0, 71.0], [240.0, 71.0]], 'bbox': (240, 57, 52, 15), 'method': 'polygon'}, {'text': 'CPA认证', 'confidence': 0.9976500272750854, 'polygon': [[306.0, 57.0], [355.0, 57.0], [355.0, 71.0], [306.0, 71.0]], 'bbox': (306, 57, 50, 15), 'method': 'polygon'}, {'text': '国家防爆', 'confidence': 0.9972962141036987, 'polygon': [[371.0, 57.0], [419.0, 57.0], [419.0, 71.0], [371.0, 71.0]], 'bbox': (371, 57, 49, 15), 'method': 'polygon'}, {'text': 'ISO认证', 'confidence': 0.9966510534286499, 'polygon': [[436.0, 57.0], [480.0, 57.0], [480.0, 71.0], [436.0, 71.0]], 'bbox': (436, 57, 45, 15), 'method': 'polygon'}, {'text': 'CE认证', 'confidence': 0.9982095956802368, 'polygon': [[500.0, 57.0], [539.0, 57.0], [539.0, 71.0], [500.0, 71.0]], 'bbox': (500, 57, 40, 15), 'method': 'polygon'}, {'text': 'SGS认证', 'confidence': 0.9988520741462708, 'polygon': [[562.0, 57.0], [609.0, 57.0], [609.0, 71.0], [562.0, 71.0]], 'bbox': (562, 57, 48, 15), 'method': 'polygon'}, {'text': '激光粉尘检测仪', 'confidence': 0.9979674220085144, 'polygon': [[45.0, 166.0], [407.0, 166.0], [407.0, 211.0], [45.0, 211.0]], 'bbox': (45, 166, 363, 46), 'method': 'polygon'}, {'text': '精度≤±5%F.S', 'confidence': 0.9514796733856201, 'polygon': [[29.0, 239.0], [216.0, 237.0], [216.0, 264.0], [29.0, 266.0]], 'bbox': (29, 237, 188, 30), 'method': 'polygon'}, {'text': '防护等级：', 'confidence': 0.9984657168388367, 'polygon': [[28.0, 297.0], [162.0, 297.0], [162.0, 324.0], [28.0, 324.0]], 'bbox': (28, 297, 135, 28), 'method': 'polygon'}, {'text': '过压保护/声光报警/存储打印', 'confidence': 0.9622736573219299, 'polygon': [[23.0, 356.0], [420.0, 356.0], [420.0, 380.0], [23.0, 380.0]], 'bbox': (23, 356, 398, 25), 'method': 'polygon'}, {'text': '可同时监测多种粒径尘埃粒子数', 'confidence': 0.996757447719574, 'polygon': [[29.0, 469.0], [371.0, 469.0], [371.0, 492.0], [29.0, 492.0]], 'bbox': (29, 469, 343, 24), 'method': 'polygon'}, {'text': '适合十万级以上洁净室', 'confidence': 0.9917443990707397, 'polygon': [[29.0, 505.0], [271.0, 505.0], [271.0, 526.0], [29.0, 526.0]], 'bbox': (29, 505, 243, 22), 'method': 'polygon'}, {'text': '全国', 'confidence': 0.9994616508483887, 'polygon': [[15.0, 532.0], [119.0, 532.0], [119.0, 589.0], [15.0, 589.0]], 'bbox': (15, 532, 105, 58), 'method': 'polygon'}, {'text': '7天无理由退货', 'confidence': 0.997958242893219, 'polygon': [[194.0, 544.0], [391.0, 544.0], [391.0, 571.0], [194.0, 571.0]], 'bbox': (194, 544, 198, 28), 'method': 'polygon'}, {'text': '赠运险费', 'confidence': 0.9987455606460571, 'polygon': [[428.0, 543.0], [542.0, 543.0], [542.0, 571.0], [428.0, 571.0]], 'bbox': (428, 543, 115, 29), 'method': 'polygon'}, {'text': '包邮', 'confidence': 0.9907816648483276, 'polygon': [[15.0, 585.0], [122.0, 587.0], [121.0, 639.0], [14.0, 637.0]], 'bbox': (14, 585, 109, 55), 'method': 'polygon'}, {'text': '原厂正品/可开发票/质保一年', 'confidence': 0.9911054968833923, 'polygon': [[138.0, 585.0], [625.0, 583.0], [625.0, 617.0], [138.0, 619.0]], 'bbox': (138, 583, 488, 37), 'method': 'polygon'}] +[2025-12-01 23:41:28,766] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_chinese_text:1192] 중국어 텍스트 18개 필터링 완료 +[2025-12-01 23:41:28,766] [MainThread] [INFO] [onnx_ocr_wrapper.py:filter_korean_text:1213] 한글 텍스트 0개 필터링 완료 +[2025-12-01 23:41:58,986] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(HTTPSConnectionPool(host='inpaint.m1tcloud.cc', port=443): Read timed out. (read timeout=30)), 재시도 1/2 대기 1.05s +[2025-12-01 23:42:00,514] [asyncio_0] [WARNING] [loggerModule.py:warning:316] [GemmaTranslator] POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패(502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3), 재시도 2/2 대기 0.79s +[2025-12-01 23:42:01,433] [asyncio_0] [ERROR] [loggerModule.py:error:322] [GemmaTranslator] run_llm_translation failed: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: 502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 +[2025-12-01 23:42:01,440] [asyncio_0] [ERROR] [image_processor3.py:batch_llm_translate_texts:1637] LLM 번역 실패: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: 502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3. 구글 번역으로 폴백. +Traceback (most recent call last): + File "D:\py\img_worker\modules\image_processor3.py", line 1628, in batch_llm_translate_texts + return self.ai_translator.run_llm_translation( + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 378, in run_llm_translation + raise e + File "D:\py\img_worker\modules\gemma_client.py", line 283, in run_llm_translation + resp = self._post(path, payload) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "D:\py\img_worker\modules\gemma_client.py", line 100, in _post + raise GemmaTranslatorError(f"POST {url} 실패: {last_err}") +modules.gemma_client.GemmaTranslatorError: POST https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 실패: 502 Server Error: Bad Gateway for url: https://inpaint.m1tcloud.cc/api/v1/llm/run?retry=3 + +[2025-12-01 23:42:02,171] [MainThread] [DEBUG] [image_processor3.py:process_single_image:748] translated_texts: ['코르노', 'CMC 인증', 'CPA 자격증', '국가 방폭형', 'ISO 인증', 'CE 인증', 'SGS 인증', '레이저 먼지 감지기', '정확도≤±5%F.S', '보호 수준:', '과전압 보호 / 소리와 빛 경보 / 매장 인쇄', '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능', '클래스 100,000 이상의 클린룸에 적합', '전국', '7일이면 반품할 이유가 없습니다.', '무료 배송 보험', '무료 배송', '오리지널 정품 / 청구 가능 / 1년 보증'] +[2025-12-01 23:42:02,171] [MainThread] [DEBUG] [image_processor3.py:process_single_image:749] 마스크 생성 완료 +[2025-12-01 23:42:02,171] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 1] 원본 텍스트: '코르노' +[2025-12-01 23:42:02,171] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 1] 분리된 단어: ['코르노'] +[2025-12-01 23:42:02,172] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 1] 변경 없음: '코르노' +[2025-12-01 23:42:02,172] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 2] 원본 텍스트: 'CMC 인증' +[2025-12-01 23:42:02,172] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 2] 분리된 단어: ['CMC', '인증'] +[2025-12-01 23:42:02,172] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 2] 변경 없음: 'CMC 인증' +[2025-12-01 23:42:02,172] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 3] 원본 텍스트: 'CPA 자격증' +[2025-12-01 23:42:02,173] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 3] 분리된 단어: ['CPA', '자격증'] +[2025-12-01 23:42:02,173] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 3] 변경 없음: 'CPA 자격증' +[2025-12-01 23:42:02,173] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 4] 원본 텍스트: '국가 방폭형' +[2025-12-01 23:42:02,173] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 4] 분리된 단어: ['국가', '방폭형'] +[2025-12-01 23:42:02,173] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 4] 변경 없음: '국가 방폭형' +[2025-12-01 23:42:02,173] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 5] 원본 텍스트: 'ISO 인증' +[2025-12-01 23:42:02,174] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 5] 분리된 단어: ['ISO', '인증'] +[2025-12-01 23:42:02,174] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 5] 변경 없음: 'ISO 인증' +[2025-12-01 23:42:02,174] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 6] 원본 텍스트: 'CE 인증' +[2025-12-01 23:42:02,174] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 6] 분리된 단어: ['CE', '인증'] +[2025-12-01 23:42:02,174] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 6] 변경 없음: 'CE 인증' +[2025-12-01 23:42:02,174] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 7] 원본 텍스트: 'SGS 인증' +[2025-12-01 23:42:02,175] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 7] 분리된 단어: ['SGS', '인증'] +[2025-12-01 23:42:02,175] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 7] 변경 없음: 'SGS 인증' +[2025-12-01 23:42:02,175] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 8] 원본 텍스트: '레이저 먼지 감지기' +[2025-12-01 23:42:02,175] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 8] 분리된 단어: ['레이저', '먼지', '감지기'] +[2025-12-01 23:42:02,175] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 8] 변경 없음: '레이저 먼지 감지기' +[2025-12-01 23:42:02,176] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 9] 원본 텍스트: '정확도≤±5%F.S' +[2025-12-01 23:42:02,176] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 9] 분리된 단어: ['정확도≤±5%F.S'] +[2025-12-01 23:42:02,176] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 9] 변경 없음: '정확도≤±5%F.S' +[2025-12-01 23:42:02,176] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 10] 원본 텍스트: '보호 수준:' +[2025-12-01 23:42:02,176] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 10] 분리된 단어: ['보호', '수준:'] +[2025-12-01 23:42:02,177] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 10] 변경 없음: '보호 수준:' +[2025-12-01 23:42:02,177] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 11] 원본 텍스트: '과전압 보호 / 소리와 빛 경보 / 매장 인쇄' +[2025-12-01 23:42:02,177] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 11] 분리된 단어: ['과전압', '보호', '/', '소리와', '빛', '경보', '/', '매장', '인쇄'] +[2025-12-01 23:42:02,177] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 11] 변경 없음: '과전압 보호 / 소리와 빛 경보 / 매장 인쇄' +[2025-12-01 23:42:02,177] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 12] 원본 텍스트: '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능' +[2025-12-01 23:42:02,177] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 12] 분리된 단어: ['다양한', '입자', '크기의', '먼지', '입자', '수를', '동시에', '모니터링', '가능'] +[2025-12-01 23:42:02,178] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 12] 변경 없음: '다양한 입자 크기의 먼지 입자 수를 동시에 모니터링 가능' +[2025-12-01 23:42:02,178] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 13] 원본 텍스트: '클래스 100,000 이상의 클린룸에 적합' +[2025-12-01 23:42:02,178] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 13] 분리된 단어: ['클래스', '100,000', '이상의', '클린룸에', '적합'] +[2025-12-01 23:42:02,178] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 13] 변경 없음: '클래스 100,000 이상의 클린룸에 적합' +[2025-12-01 23:42:02,179] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 14] 원본 텍스트: '전국' +[2025-12-01 23:42:02,179] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 14] 분리된 단어: ['전국'] +[2025-12-01 23:42:02,179] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 14] 변경 없음: '전국' +[2025-12-01 23:42:02,179] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 15] 원본 텍스트: '7일이면 반품할 이유가 없습니다.' +[2025-12-01 23:42:02,179] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 15] 분리된 단어: ['7일이면', '반품할', '이유가', '없습니다.'] +[2025-12-01 23:42:02,180] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 15] 변경 없음: '7일이면 반품할 이유가 없습니다.' +[2025-12-01 23:42:02,180] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 16] 원본 텍스트: '무료 배송 보험' +[2025-12-01 23:42:02,180] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 16] 분리된 단어: ['무료', '배송', '보험'] +[2025-12-01 23:42:02,180] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 16] 변경 없음: '무료 배송 보험' +[2025-12-01 23:42:02,180] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 17] 원본 텍스트: '무료 배송' +[2025-12-01 23:42:02,180] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 17] 분리된 단어: ['무료', '배송'] +[2025-12-01 23:42:02,181] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 17] 변경 없음: '무료 배송' +[2025-12-01 23:42:02,181] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1449] [치환 처리 18] 원본 텍스트: '오리지널 정품 / 청구 가능 / 1년 보증' +[2025-12-01 23:42:02,181] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1453] [치환 처리 18] 분리된 단어: ['오리지널', '정품', '/', '청구', '가능', '/', '1년', '보증'] +[2025-12-01 23:42:02,181] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1494] [치환 처리 18] 변경 없음: '오리지널 정품 / 청구 가능 / 1년 보증' +[2025-12-01 23:42:02,182] [MainThread] [DEBUG] [image_processor3.py:process_translated_texts:1496] 전체 치환 결과: 18개 텍스트 처리 완료 +[2025-12-01 23:42:02,182] [MainThread] [DEBUG] [image_processor3.py:process_single_image:758] 이미지 1 치환됨 +[2025-12-01 23:42:02,184] [MainThread] [INFO] [image_processor3.py:process_single_image:795] [AUTO Inpaint] coverage=0.388, comps=8, min_center_dist=0.072 → external_request +[2025-12-01 23:42:02,184] [MainThread] [DEBUG] [image_processor3.py:process_single_image:808] ocr_count: 18 +[2025-12-01 23:42:02,184] [MainThread] [DEBUG] [image_processor3.py:process_single_image:809] is_member_valid: True +[2025-12-01 23:42:02,184] [MainThread] [DEBUG] [image_processor3.py:process_single_image:813] 최종 inpaint_method: external_request +[2025-12-01 23:42:02,190] [asyncio_1] [DEBUG] [image_processor3.py:_try_external_inpaint:1141] 외부 인페인팅 시도: https://inpaint.m1tcloud.cc +[2025-12-01 23:42:02,672] [asyncio_1] [WARNING] [request_inpaint.py:request_external_inpaint:106] 외부 인페인팅 서버(https://inpaint.m1tcloud.cc)가 응답하지 않습니다. +[2025-12-01 23:42:02,672] [asyncio_1] [WARNING] [image_processor3.py:execute_inpaint_with_fallback:1004] 외부 서버 인페인팅 실패 -> 로컬 MIGAN으로 폴백 +[2025-12-01 23:42:02,672] [asyncio_1] [DEBUG] [image_processor3.py:_try_migan_inpaint:1153] MIGAN 모듈이 초기화되지 않아 건너뜀 +[2025-12-01 23:42:02,672] [asyncio_1] [DEBUG] [image_processor3.py:execute_inpaint_with_fallback:1022] 인페인팅 폴백: OpenCV(Telea) 방식 시도 +[2025-12-01 23:42:02,678] [asyncio_1] [DEBUG] [image_processor3.py:execute_inpaint_with_fallback:1067] OpenCV 인페인팅 성공 +[2025-12-01 23:42:02,683] [asyncio_1] [INFO] [image_processor3.py:execute_inpaint_with_fallback:1080] 메모리 변화 [인페인팅]: 31942.3MB -> 31968.4MB (+26.1MB, +0.1%) - 방법: cv +[2025-12-01 23:42:02,684] [MainThread] [DEBUG] [image_processor3.py:process_single_image:826] 인페인팅 완료 +[2025-12-01 23:42:02,751] [MainThread] [DEBUG] [image_processor3.py:process_single_image:848] 텍스트 렌더링 완료 +[2025-12-01 23:42:02,752] [MainThread] [DEBUG] [image_processor3.py:postProcess_and_save_image:1281] watermark_text: 이미지 저작권 보유 +[2025-12-01 23:42:02,752] [MainThread] [DEBUG] [image_processor3.py:postProcess_and_save_image:1282] is_watermark_enabled: True +[2025-12-01 23:42:02,753] [MainThread] [INFO] [postImageManager.py:save_image_to_path:101] 이미지 저장 완료 : D:\py\img_worker\modules\test\temp\translated_llm_test_result_img_1.jpg +[2025-12-01 23:42:02,754] [MainThread] [DEBUG] [image_processor3.py:process_single_image:854] 이미지 1 번역 완료: D:\py\img_worker\modules\test\temp\translated_llm_test_result_img_1.jpg +[2025-12-01 23:42:02,779] [MainThread] [DEBUG] [image_processor3.py:process_single_image:907] ⏱ 이미지 파이프라인 총 35230.2ms | download=0.0ms | ocr=670.2ms | translate=33404.0ms | mask=8.0ms | inpaint=498.1ms(cv/CPU) | render=67.7ms | save=2.0ms +[2025-12-01 23:42:02,794] [MainThread] [DEBUG] [image_processor3.py:cleanup:450] OCR 모듈 정리 완료 +[2025-12-01 23:42:02,794] [MainThread] [DEBUG] [image_processor3.py:cleanup:458] 마스크 모듈 정리 완료 +[2025-12-01 23:42:02,818] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-01 23:42:02,835] [MainThread] [DEBUG] [image_processor3.py:cleanup:493] 임시 폴더 삭제됨: D:\py\img_worker\modules\test\temp +[2025-12-01 23:42:02,835] [MainThread] [DEBUG] [image_processor3.py:__del__:441] 이미지 프로세서 소멸 diff --git a/modules/test/create_font_preview.py b/modules/test/create_font_preview.py index 3a4e752..7834eaa 100644 --- a/modules/test/create_font_preview.py +++ b/modules/test/create_font_preview.py @@ -32,7 +32,8 @@ async def main(): font_file_name = "Pretendard-Regular.ttf" font_path = os.path.join(base_dir, "fonts", font_file_name) - original_image_path = os.path.join(base_dir, "fonts", "ori.jpg") + # original_image_path = os.path.join(base_dir, "fonts", "ori.jpg") + original_image_path = os.path.join(base_dir, "test", "2.jpg") # 결과 저장 경로: modules/test preview_output_dir = os.path.join(base_dir, "test") diff --git a/modules/test/outputs_test/inpaint_result_class_test.webp b/modules/test/outputs_test/inpaint_result_class_test.webp new file mode 100644 index 0000000000000000000000000000000000000000..bcf0f1c159e02543ac95906a8b87bed9587b6141 GIT binary patch literal 466228 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

j^ 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 z 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