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 96e5a96..c8bd268 100644 Binary files a/__pycache__/loggerModule.cpython-311.pyc and b/__pycache__/loggerModule.cpython-311.pyc differ diff --git a/build_log.txt b/build_log.txt new file mode 100644 index 0000000..0cfcb84 Binary files /dev/null and b/build_log.txt differ diff --git a/build_log2.txt b/build_log2.txt new file mode 100644 index 0000000..a51b417 Binary files /dev/null and b/build_log2.txt differ diff --git a/build_log3.txt b/build_log3.txt new file mode 100644 index 0000000..621ef6e Binary files /dev/null and b/build_log3.txt differ diff --git a/build_log4.txt b/build_log4.txt new file mode 100644 index 0000000..e2088d8 Binary files /dev/null and b/build_log4.txt differ 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 0000000..ffa0f49 Binary files /dev/null and b/loggerModule.cp311-win_amd64.pyd differ 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 3f9e8ca..5fe94a2 100644 Binary files a/modules/__pycache__/gemma_client.cpython-311.pyc and b/modules/__pycache__/gemma_client.cpython-311.pyc differ diff --git a/modules/__pycache__/image_processor3.cpython-311.pyc b/modules/__pycache__/image_processor3.cpython-311.pyc index 04d6798..f9ad34e 100644 Binary files a/modules/__pycache__/image_processor3.cpython-311.pyc and b/modules/__pycache__/image_processor3.cpython-311.pyc differ diff --git a/modules/__pycache__/image_worker.cpython-311.pyc b/modules/__pycache__/image_worker.cpython-311.pyc index 08fd39a..5c272cb 100644 Binary files a/modules/__pycache__/image_worker.cpython-311.pyc and b/modules/__pycache__/image_worker.cpython-311.pyc differ diff --git a/modules/__pycache__/openrouter_client.cpython-311.pyc b/modules/__pycache__/openrouter_client.cpython-311.pyc new file mode 100644 index 0000000..3d595b6 Binary files /dev/null and b/modules/__pycache__/openrouter_client.cpython-311.pyc differ diff --git a/modules/__pycache__/request_inpaint.cpython-311.pyc b/modules/__pycache__/request_inpaint.cpython-311.pyc index 09be0fa..6a33215 100644 Binary files a/modules/__pycache__/request_inpaint.cpython-311.pyc and b/modules/__pycache__/request_inpaint.cpython-311.pyc differ diff --git a/modules/__pycache__/tray_app.cpython-311.pyc b/modules/__pycache__/tray_app.cpython-311.pyc index 6423bda..ee53aca 100644 Binary files a/modules/__pycache__/tray_app.cpython-311.pyc and b/modules/__pycache__/tray_app.cpython-311.pyc differ 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 0000000..bcf0f1c Binary files /dev/null and b/modules/test/outputs_test/inpaint_result_class_test.webp differ diff --git a/modules/test/outputs_test/inpaint_result_migan.webp b/modules/test/outputs_test/inpaint_result_migan.webp new file mode 100644 index 0000000..bcf0f1c Binary files /dev/null and b/modules/test/outputs_test/inpaint_result_migan.webp differ diff --git a/modules/test/outputs_test/inpaint_result_simple-lama.webp b/modules/test/outputs_test/inpaint_result_simple-lama.webp new file mode 100644 index 0000000..bcf0f1c Binary files /dev/null and b/modules/test/outputs_test/inpaint_result_simple-lama.webp differ diff --git a/modules/test/temp/translated_llm_test_result_img_1.jpg b/modules/test/temp/translated_llm_test_result_img_1.jpg new file mode 100644 index 0000000..d37905e Binary files /dev/null and b/modules/test/temp/translated_llm_test_result_img_1.jpg differ diff --git a/modules/test/test_external_inpaint.py b/modules/test/test_external_inpaint.py new file mode 100644 index 0000000..1e72aa2 --- /dev/null +++ b/modules/test/test_external_inpaint.py @@ -0,0 +1,169 @@ +"""외부 인페인팅 서버 테스트 스크립트""" +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) + +import cv2 +import numpy as np +import requests +import base64 + +# 테스트 서버 URL +SERVER_URL = "http://192.168.0.146:8008" + +def test_health_check(): + """서버 상태 확인""" + print("=" * 50) + print("1. 서버 상태 확인 (Health Check)") + print("=" * 50) + try: + response = requests.get(f"{SERVER_URL}/health", timeout=5) + print(f"Status: {response.status_code}") + print(f"Response: {response.json()}") + return response.status_code == 200 + except Exception as e: + print(f"Error: {e}") + return False + +def test_inpaint_api(model_name="migan"): + """인페인팅 API 테스트""" + print("=" * 50) + print(f"2. 인페인팅 API 테스트 (model: {model_name})") + print("=" * 50) + + # 테스트 이미지 로드 + test_image_path = os.path.join(os.path.dirname(__file__), "1.jpg") + if not os.path.exists(test_image_path): + print(f"테스트 이미지 없음: {test_image_path}") + return False + + image = cv2.imread(test_image_path) + print(f"이미지 크기: {image.shape}") + + # 간단한 테스트 마스크 생성 (중앙에 사각형) + h, w = image.shape[:2] + mask = np.zeros((h, w), dtype=np.uint8) + # 중앙에 100x100 마스크 영역 + cx, cy = w // 2, h // 2 + mask[cy-50:cy+50, cx-50:cx+50] = 255 + print(f"마스크 크기: {mask.shape}, 마스크 영역: 100x100 중앙") + + # Base64 인코딩 + _, img_encoded = cv2.imencode('.png', image) + _, mask_encoded = cv2.imencode('.png', mask) + img_b64 = base64.b64encode(img_encoded).decode('utf-8') + mask_b64 = base64.b64encode(mask_encoded).decode('utf-8') + + # API 요청 + api_url = f"{SERVER_URL}/api/v1/inpaint" + params = { + "response_format": "binary", + "image_format": "webp", + } + payload = { + "image": img_b64, + "mask": mask_b64, + "model_name": model_name + } + + print(f"요청 URL: {api_url}") + print(f"파라미터: {params}") + print(f"모델: {model_name}") + + try: + response = requests.post(api_url, params=params, json=payload, timeout=(5, 60)) + print(f"Status: {response.status_code}") + print(f"Content-Type: {response.headers.get('content-type', 'N/A')}") + print(f"응답 크기: {len(response.content)} bytes") + + if response.status_code == 200: + # 이미지 디코딩 테스트 + nparr = np.frombuffer(response.content, np.uint8) + result = cv2.imdecode(nparr, cv2.IMREAD_COLOR) + + if result is not None: + print(f"✅ 성공! 결과 이미지 크기: {result.shape}") + + # 결과 저장 + output_path = os.path.join(os.path.dirname(__file__), f"outputs_test/inpaint_result_{model_name}.webp") + os.makedirs(os.path.dirname(output_path), exist_ok=True) + cv2.imwrite(output_path, result) + print(f"결과 저장: {output_path}") + return True + else: + print("❌ 이미지 디코딩 실패") + return False + else: + print(f"❌ 서버 에러: {response.text}") + return False + + except Exception as e: + print(f"❌ 요청 실패: {e}") + return False + +def test_with_request_ai_server(): + """Request_AI_Server 클래스를 통한 테스트""" + print("=" * 50) + print("3. Request_AI_Server 클래스 테스트") + print("=" * 50) + + from loggerModule import Logger + from modules.request_inpaint import Request_AI_Server + + logger = Logger() + server = Request_AI_Server(logger) + + # 테스트 이미지 로드 + test_image_path = os.path.join(os.path.dirname(__file__), "1.jpg") + image = cv2.imread(test_image_path) + + # 마스크 생성 + h, w = image.shape[:2] + mask = np.zeros((h, w), dtype=np.uint8) + cx, cy = w // 2, h // 2 + mask[cy-50:cy+50, cx-50:cx+50] = 255 + + # 외부 인페인팅 요청 + print(f"서버 URL: {SERVER_URL}") + result = server.request_external_inpaint( + image=image, + mask=mask, + server_url=SERVER_URL, + model_name="migan" + ) + + if result is not None: + print(f"✅ 성공! 결과 이미지 크기: {result.shape}") + output_path = os.path.join(os.path.dirname(__file__), "outputs_test/inpaint_result_class_test.webp") + cv2.imwrite(output_path, result) + print(f"결과 저장: {output_path}") + return True + else: + print("❌ 인페인팅 실패") + return False + +if __name__ == "__main__": + print("\n🔧 외부 인페인팅 서버 테스트 시작\n") + + # 1. 서버 상태 확인 + if not test_health_check(): + print("\n❌ 서버에 연결할 수 없습니다. 테스트 중단.") + sys.exit(1) + + print() + + # 2. migan 모델 테스트 + test_inpaint_api("migan") + + print() + + # 3. simple-lama 모델 테스트 + test_inpaint_api("simple-lama") + + print() + + # 4. Request_AI_Server 클래스 테스트 + test_with_request_ai_server() + + print("\n🎉 테스트 완료!") + diff --git a/modules/test/test_llm_translation.py b/modules/test/test_llm_translation.py new file mode 100644 index 0000000..50c4393 --- /dev/null +++ b/modules/test/test_llm_translation.py @@ -0,0 +1,135 @@ +import sys +import os +import logging +import asyncio +import shutil + +# 루트 디렉토리 설정 (img_worker/) +current_dir = os.path.dirname(os.path.abspath(__file__)) +# modules/test/.. -> modules/.. -> img_worker/ +root_dir = os.path.abspath(os.path.join(current_dir, "../../")) +sys.path.append(root_dir) + +from modules.image_processor3 import ImageProcessor3 +from loggerModule import Logger + +# 더미 클래스 정의 +class MockPage: + pass + +class MockTranslator: + async def translate(self, text, source_lang, target_lang): + return text + +async def main(): + # 1. 로거 초기화 + logger = Logger() + + # 2. 경로 설정 + base_dir = os.path.join(root_dir, "modules") + + # 샘플 이미지 및 폰트 경로 + sample_image_name = "2.jpg" + sample_image_path = os.path.join(current_dir, sample_image_name) + font_path = os.path.join(base_dir, "fonts", "HakgyoansimDunggeunmisoTTFB.ttf") + + if not os.path.exists(sample_image_path): + logger.log(f"샘플 이미지가 없습니다: {sample_image_path}", level=logging.ERROR) + # 1.jpg가 없다면 fonts 폴더의 ori.jpg를 복사해서 사용하거나 에러 처리 + ori_path = os.path.join(base_dir, "fonts", "ori.jpg") + if os.path.exists(ori_path): + logger.log(f"대체 이미지 사용: {ori_path}", level=logging.INFO) + sample_image_path = ori_path + else: + return + + # 3. Toggle States 설정 + toggle_states = { + # LLM 번역 설정 + "translation_method": "llm", # 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": font_path, + "ocr": True, + "use_cuda": False, + "force_cpu_ocr": True, + "inpaint_model": "request", # 테스트 속도를 위해 가벼운 CV 모델 사용 (또는 'request'로 서버 사용 가능) + "local_inpaint_method": "request", + "TEMP_IMAGE_DIR": os.path.join(base_dir, "test", "temp"), + "output_image_format": "jpg", + "watermark_toggle": False, + "store_ocr_data_to_db": False, + "ocr_engine": "onnx", + } + + # 임시 디렉토리 생성 + if not os.path.exists(toggle_states["TEMP_IMAGE_DIR"]): + os.makedirs(toggle_states["TEMP_IMAGE_DIR"], exist_ok=True) + + # 4. ImageProcessor3 초기화 + print(">>> ImageProcessor3 초기화 중...") + processor = None + try: + processor = ImageProcessor3( + logger=logger, + page=MockPage(), + toggle_states=toggle_states, + unwanted_words={}, + authenticated_by_admin=True, + base_dir=base_dir, + papago_translator=MockTranslator() + ) + except Exception as e: + logger.log(f"프로세서 초기화 실패: {e}", level=logging.ERROR) + return + + # 5. 실제 이미지 처리 테스트 (OCR -> LLM 번역 -> 인페인팅 -> 텍스트 렌더링) + print("\n>>> 실제 이미지 처리 및 LLM 번역 테스트 시작") + print(f"대상 이미지: {sample_image_path}") + print(f"설정된 번역 방식: {processor.toggle_states.get('translation_method')}") + print(f"LLM API URL: {processor.toggle_states.get('gemma_api_base_url')}") + + try: + # process_single_image 호출 + file_prefix = "llm_test_result" + + # 실제 처리 실행 + result = await processor.process_single_image( + original_image_url=sample_image_path, + index=0, + delay=0, + file_prefix=file_prefix + ) + + if result['status'] in ['translated', 'inpainted', 'success']: + print("\n[테스트 성공]") + print(f"처리된 이미지 경로: {result['path']}") + + # 결과 이미지가 실제로 존재하는지 확인 + if os.path.exists(result['path']): + print(f"파일 확인됨: {result['path']}") + else: + print(f"경고: 결과 파일이 반환되었으나 디스크에 없음: {result['path']}") + + else: + print("\n[테스트 실패]") + print(f"상태: {result.get('status')}") + print(f"메시지: {result.get('error') or result.get('message')}") + + except Exception as e: + logger.log(f"테스트 중 치명적 오류 발생: {e}", level=logging.ERROR) + import traceback + traceback.print_exc() + finally: + # 리소스 정리 + if processor: + processor.cleanup() + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/modules/test/translated_preview_Pretendard-Regular_img_1.jpg b/modules/test/translated_preview_Pretendard-Regular_img_1.jpg index 53efc5d..df81bde 100644 Binary files a/modules/test/translated_preview_Pretendard-Regular_img_1.jpg and b/modules/test/translated_preview_Pretendard-Regular_img_1.jpg differ diff --git a/modules/test_groq.py b/modules/test_groq.py new file mode 100644 index 0000000..d31fbce --- /dev/null +++ b/modules/test_groq.py @@ -0,0 +1,92 @@ +import os +import json +from groq import Groq + +# 1. API 키 설정 (직접 문자열로 넣거나 환경변수 사용) +# 발급받은 키를 "gsk_..." 부분에 넣으세요. +client = Groq( + api_key="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" +) + +# 2. 테스트할 OCR 결과 데이터 (샘플) +SAMPLE_1 = [ + {'text': '高密【拉毛布】', 'confidence': 0.8697245717048645}, + {'text': '柔中带韧不易坏', 'confidence': 0.9874316453933716}, + {'text': '安静无声助力深度睡眠', 'confidence': 0.9960897564888}, + {'text': 'newpet家的', 'confidence': 0.9988763928413391}, + {'text': '别人家的', 'confidence': 0.9997605085372925}, + {'text': '密织拉毛布保暖还结实', 'confidence': 0.9967950582504272}, + {'text': '劣质无纺布一拉就烂一洗就散', 'confidence': 0.9917935729026794}, +] + +# OCR 결과를 번역용 items 형태로 변환 +items = [] +for i, ocr_item in enumerate(SAMPLE_1, 1): + text = (ocr_item.get("text") or "").strip() + if text: + items.append({"id": i, "source": text}) + +items_json = json.dumps(items, ensure_ascii=False, indent=2) + +print(f"--- [모델: llama-3.1-8b-instant] 테스트 시작 ---") +print(f"입력 항목 수: {len(items)}") + +try: + completion = client.chat.completions.create( + # 스크린샷에 있던 그 모델입니다. (속도 매우 빠름) + model="llama-3.1-8b-instant", + messages=[ + { + "role": "system", + "content": ( + "당신은 중국어-한국어 전문 온라인 쇼핑마케팅 번역가입니다.\n\n" + "아래 JSON 배열의 각 항목에서 \"source\" 필드의 중국어 텍스트를 한국어로 번역해주세요.\n\n" + "번역 규칙:\n" + "1. 정확하고 자연스러운 한국어로 번역\n" + "2. 상품 문맥에 맞게 번역\n" + "3. 브랜드명, 고유명사는 그대로 유지\n" + "4. 숫자와 단위는 유지\n\n" + "반드시 입력된 순서와 개수를 지켜서 JSON 배열만 출력하세요. 다른 설명 없이 JSON 배열만 출력합니다." + ) + }, + { + "role": "user", + "content": f"입력:\n{items_json}\n\n출력 형식 (JSON 배열만 출력, 다른 텍스트 없이):\n[\n{{\"id\": 1, \"translation\": \"번역된 텍스트\"}},\n{{\"id\": 2, \"translation\": \"번역된 텍스트\"}}\n]" + } + ], + temperature=0.5, # 창의성 조절 + max_tokens=2048, # 출력 길이 제한 증가 + ) + + # 결과 출력 + response_content = completion.choices[0].message.content + print("\n--- 번역 결과 ---") + print(response_content) + + # JSON 파싱 시도 + try: + # JSON 코드 블록 제거 (```json ... ``` 형태) + if "```" in response_content: + lines = response_content.split("\n") + json_lines = [] + in_json_block = False + for line in lines: + if line.strip().startswith("```"): + in_json_block = not in_json_block + continue + if in_json_block or (not in_json_block and line.strip()): + json_lines.append(line) + response_content = "\n".join(json_lines) + + translated_items = json.loads(response_content.strip()) + print(f"\n--- 파싱된 결과 ({len(translated_items)}개) ---") + for item in translated_items: + item_id = item.get("id", "N/A") + translation = item.get("translation", item.get("result", item.get("translated", ""))) + print(f"ID {item_id}: {translation}") + except json.JSONDecodeError as e: + print(f"\nJSON 파싱 실패: {e}") + print("원본 응답을 확인하세요.") + +except Exception as e: + print(f"에러 발생: {e}") \ No newline at end of file diff --git a/modules/test_openrouter_client.py b/modules/test_openrouter_client.py new file mode 100644 index 0000000..0a84b9c --- /dev/null +++ b/modules/test_openrouter_client.py @@ -0,0 +1,542 @@ +# -*- coding: utf-8 -*- +""" +OpenRouter 클라이언트 테스트 스크립트 + +사용법: + python modules/test_openrouter_client.py + +환경변수 설정: + export OPENROUTER_API_KEY="sk-or-v1-xxxxx" + 또는 코드에서 직접 설정 +""" +import os +import sys +import time +import logging +from typing import List, Dict, Any, Optional +from dataclasses import dataclass + +# 로깅 설정 +logging.basicConfig( + level=logging.INFO, + format='[%(asctime)s] [%(levelname)s] %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' +) +logger = logging.getLogger(__name__) + +# 모듈 경로 추가 +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from modules.openrouter_client import OpenRouterTranslator + + +# ============================================================================= +# 로그에서 추출한 샘플 OCR 데이터 +# ============================================================================= + +# 샘플 1: 이미지 35 (7개 텍스트, 모두 중국어) +SAMPLE_1: List[Dict[str, Any]] = [ + {'text': '高密【拉毛布】', 'confidence': 0.8697245717048645}, + {'text': '柔中带韧不易坏', 'confidence': 0.9874316453933716}, + {'text': '安静无声助力深度睡眠', 'confidence': 0.9960897564888}, + {'text': 'newpet家的', 'confidence': 0.9988763928413391}, + {'text': '别人家的', 'confidence': 0.9997605085372925}, + {'text': '密织拉毛布保暖还结实', 'confidence': 0.9967950582504272}, + {'text': '劣质无纺布一拉就烂一洗就散', 'confidence': 0.9917935729026794}, +] + +# 샘플 2: 이미지 37 (3개 텍스트, 모두 중국어) +SAMPLE_2: List[Dict[str, Any]] = [ + {'text': '隐藏拉链不易咬', 'confidence': 0.9800551533699036}, + {'text': '宠物更安全', 'confidence': 0.9966630935668945}, + {'text': '隐藏式拉链+顺滑手感告别突元五金', 'confidence': 0.9670320749282837}, +] + +# 샘플 3: 이미지 38 (12개 중 11개 중국어, Productparameters 제외됨) +SAMPLE_3: List[Dict[str, Any]] = [ + {'text': '产品参数', 'confidence': 0.995430052280426}, + {'text': '品牌', 'confidence': 0.9999157786369324}, + {'text': '名称', 'confidence': 0.9999277591705322}, + {'text': 'NewPet妞派特', 'confidence': 0.9976658225059509}, + {'text': '加厚防风圆弧房子', 'confidence': 0.9947051405906677}, + {'text': '适用对象', 'confidence': 0.9994360208511353}, + {'text': '产品材质', 'confidence': 0.9989043474197388}, + {'text': '猫犬通用', 'confidence': 0.9970399141311646}, + {'text': '高密度海绵、牛津布', 'confidence': 0.995124101638794}, + {'text': '颜色', 'confidence': 0.9999042749404907}, + {'text': '多色可选', 'confidence': 0.9995521903038025}, +] + +# 샘플 4: 이미지 4 (9개 중 8개 중국어, newpet 제외됨) +SAMPLE_4: List[Dict[str, Any]] = [ + {'text': '工厂直销', 'confidence': 0.9989292621612549}, + {'text': '品质稳定有保证', 'confidence': 0.9961501359939575}, + {'text': '实力源头厂家，13年畅销好产品', 'confidence': 0.9883608222007751}, + {'text': 'M稳定货源', 'confidence': 0.8720976114273071}, + {'text': '诚实守信', 'confidence': 0.9912816882133484}, + {'text': 'M品质放心', 'confidence': 0.9013170003890991}, + {'text': '德国品质·13年畅销', 'confidence': 0.9565986394882202}, + {'text': '连续登顶天猫宠物窝TOP榜', 'confidence': 0.9966885447502136}, +] + +# 샘플 5: 이미지 1 (8개 텍스트, 모두 중국어) +SAMPLE_5: List[Dict[str, Any]] = [ + {'text': '二', 'confidence': 0.9579324722290039}, + {'text': '暖意不容等待', 'confidence': 0.9924479126930237}, + {'text': '趁"冷"下单，立享温暖', 'confidence': 0.9866428971290588}, + {'text': '降温预警', 'confidence': 0.9913228750228882}, + {'text': '广州', 'confidence': 0.9998736381530762}, + {'text': '低至10°℃-9℃', 'confidence': 0.9398331046104431}, + {'text': '部分城市', 'confidence': 0.9955496191978455}, + {'text': '未来7天降温情况', 'confidence': 0.9742034077644348}, +] + +# 필터링 전 원본 데이터 (중국어 없는 텍스트 포함) +SAMPLE_3_WITH_ENGLISH: List[Dict[str, Any]] = [ + {'text': 'Productparameters', 'confidence': 0.9952481389045715}, # 영어 (필터링됨) + {'text': '产品参数', 'confidence': 0.995430052280426}, + {'text': '品牌', 'confidence': 0.9999157786369324}, + {'text': '名称', 'confidence': 0.9999277591705322}, + {'text': 'NewPet妞派特', 'confidence': 0.9976658225059509}, + {'text': '加厚防风圆弧房子', 'confidence': 0.9947051405906677}, + {'text': '适用对象', 'confidence': 0.9994360208511353}, + {'text': '产品材质', 'confidence': 0.9989043474197388}, + {'text': '猫犬通用', 'confidence': 0.9970399141311646}, + {'text': '高密度海绵、牛津布', 'confidence': 0.995124101638794}, + {'text': '颜色', 'confidence': 0.9999042749404907}, + {'text': '多色可选', 'confidence': 0.9995521903038025}, +] + +SAMPLE_4_WITH_ENGLISH: List[Dict[str, Any]] = [ + {'text': '工厂直销', 'confidence': 0.9989292621612549}, + {'text': '品质稳定有保证', 'confidence': 0.9961501359939575}, + {'text': '实力源头厂家，13年畅销好产品', 'confidence': 0.9883608222007751}, + {'text': 'M稳定货源', 'confidence': 0.8720976114273071}, + {'text': '诚实守信', 'confidence': 0.9912816882133484}, + {'text': 'M品质放心', 'confidence': 0.9013170003890991}, + {'text': 'newpet', 'confidence': 0.9935563206672668}, # 영어 (필터링됨) + {'text': '德国品质·13年畅销', 'confidence': 0.9565986394882202}, + {'text': '连续登顶天猫宠物窝TOP榜', 'confidence': 0.9966885447502136}, +] + + +# ============================================================================= +# 테스트 함수들 +# ============================================================================= + +@dataclass +class BenchmarkResult: + """벤치마크 결과 데이터 클래스""" + model_id: str + elapsed_time: float + success: bool + results: Optional[List[str]] = None + error: Optional[str] = None + + +def print_separator(title: str = ""): + """구분선 출력""" + print("\n" + "=" * 80) + if title: + print(f" {title}") + print("=" * 80) + print() + + +def test_translate_ocr_texts( + translator: OpenRouterTranslator, + ocr_results: List[Dict[str, Any]], + product_name: str = "테스트 상품", + category: str = "테스트 카테고리", + sample_name: str = "샘플" +): + """translate_ocr_texts 메서드 테스트""" + print_separator(f"{sample_name} - translate_ocr_texts 테스트") + + print(f"입력 텍스트 ({len(ocr_results)}개):") + for i, item in enumerate(ocr_results, 1): + print(f" {i}. {item['text']}") + + print(f"\n상품명: {product_name}") + print(f"카테고리: {category}") + print(f"모델: {translator.get_current_model()['name']}") + print("\n번역 중...") + + try: + results = translator.translate_ocr_texts( + product_name=product_name, + category=category, + ocr_results=ocr_results + ) + + print(f"\n번역 결과 ({len(results)}개):") + for i, (original, translated) in enumerate(zip(ocr_results, results), 1): + print(f" {i}. {original['text']} → {translated}") + + return results + except Exception as e: + print(f"\n❌ 오류 발생: {e}") + import traceback + traceback.print_exc() + return None + + +def test_run_llm_translation( + translator: OpenRouterTranslator, + ocr_results: List[Dict[str, Any]], + product_name: str = "테스트 상품", + category: str = "테스트 카테고리", + steps: int = 2, + sample_name: str = "샘플" +): + """run_llm_translation 메서드 테스트 (steps 지원)""" + print_separator(f"{sample_name} - run_llm_translation 테스트 (steps={steps})") + + print(f"입력 텍스트 ({len(ocr_results)}개):") + for i, item in enumerate(ocr_results, 1): + print(f" {i}. {item['text']}") + + print(f"\n상품명: {product_name}") + print(f"카테고리: {category}") + print(f"모델: {translator.get_current_model()['name']}") + print(f"번역 단계: {steps} ({'직역만' if steps == 1 else '직역+마케팅톤 변환'})") + print("\n번역 중...") + + try: + results = translator.run_llm_translation( + product_name=product_name, + category=category, + ocr_results=ocr_results, + steps=steps + ) + + print(f"\n번역 결과 ({len(results)}개):") + for i, (original, translated) in enumerate(zip(ocr_results, results), 1): + print(f" {i}. {original['text']} → {translated}") + + return results + except Exception as e: + print(f"\n❌ 오류 발생: {e}") + import traceback + traceback.print_exc() + return None + + +def test_filtering_comparison( + translator: OpenRouterTranslator, + filtered_results: List[Dict[str, Any]], + unfiltered_results: List[Dict[str, Any]], + product_name: str = "테스트 상품", + category: str = "테스트 카테고리" +): + """필터링 전/후 비교 테스트""" + print_separator("필터링 전/후 비교 테스트") + + print("=" * 80) + print(" 중국어가 없는 텍스트를 포함한 경우 (필터링 전)") + print("=" * 80) + + print(f"\n입력 텍스트 ({len(unfiltered_results)}개):") + for i, item in enumerate(unfiltered_results, 1): + has_chinese = any('\u4e00' <= char <= '\u9fff' for char in item['text']) + marker = "✓" if has_chinese else "✗ (필터링됨)" + print(f" {i}. {item['text']} {marker}") + + print("\n번역 중...") + try: + results_unfiltered = translator.translate_ocr_texts( + product_name=product_name, + category=category, + ocr_results=unfiltered_results + ) + + print("\n번역 결과:") + for i, (original, translated) in enumerate(zip(unfiltered_results, results_unfiltered), 1): + has_chinese = any('\u4e00' <= char <= '\u9fff' for char in original['text']) + marker = "" if has_chinese else " (원본 유지)" + print(f" {i}. {original['text']} → {translated}{marker}") + except Exception as e: + print(f"\n❌ 오류 발생: {e}") + import traceback + traceback.print_exc() + + print("\n" + "=" * 80) + print(" 중국어만 포함한 경우 (필터링 후)") + print("=" * 80) + + print(f"\n입력 텍스트 ({len(filtered_results)}개):") + for i, item in enumerate(filtered_results, 1): + print(f" {i}. {item['text']}") + + print("\n번역 중...") + try: + results_filtered = translator.translate_ocr_texts( + product_name=product_name, + category=category, + ocr_results=filtered_results + ) + + print("\n번역 결과:") + for i, (original, translated) in enumerate(zip(filtered_results, results_filtered), 1): + print(f" {i}. {original['text']} → {translated}") + except Exception as e: + print(f"\n❌ 오류 발생: {e}") + import traceback + traceback.print_exc() + + print("\n" + "=" * 80) + print(" 분석 및 권장사항") + print("=" * 80) + print(""" + 중국어가 없는 텍스트를 필터링하는 것에 대한 분석: + + 1. 맥락 이해 측면: + - 중국어가 없는 텍스트(영어, 숫자 등)는 보통 브랜드명, 모델명, + 또는 이미 번역된 텍스트일 가능성이 높음 + - 이러한 텍스트를 포함하면 LLM이 전체 맥락을 더 잘 이해할 수 있음 + - 예: "newpet" 브랜드명이 있으면 "newpet家的"의 번역 품질이 향상될 수 있음 + + 2. 토큰 사용 측면: + - 필터링하지 않으면 입력 토큰이 증가함 + - 하지만 맥락 정보가 추가되어 번역 품질이 향상될 수 있음 + - 비용과 품질의 트레이드오프 + + 3. 권장사항: + - 브랜드명, 모델명 등은 포함하는 것이 좋음 (맥락 이해 향상) + - 순수 영어 설명문은 제외해도 무방 (중국어 번역 대상이 아님) + - 숫자, 기호는 포함 (상품 정보의 일부) + - 최종 결정은 번역 품질과 비용을 고려하여 선택 + """) + + +def benchmark_models( + api_key: str, + model_ids: List[str], + ocr_results: List[Dict[str, Any]], + product_name: str = "테스트 상품", + category: str = "테스트 카테고리", + use_llm_translation: bool = False, + steps: int = 1 +) -> List[BenchmarkResult]: + """ + 여러 모델을 벤치마크하여 비교 + + Args: + api_key: OpenRouter API 키 + model_ids: 테스트할 모델 ID 리스트 + ocr_results: OCR 결과 데이터 + product_name: 상품명 + category: 카테고리 + use_llm_translation: True면 run_llm_translation 사용, False면 translate_ocr_texts 사용 + steps: run_llm_translation 사용 시 번역 단계 (1=직역만, 2=직역+마케팅톤 변환) + + Returns: + 벤치마크 결과 리스트 + """ + benchmark_results: List[BenchmarkResult] = [] + + method_name = "run_llm_translation" if use_llm_translation else "translate_ocr_texts" + print_separator("벤치마크 시작") + print(f"테스트 모델 수: {len(model_ids)}") + print(f"입력 텍스트 수: {len(ocr_results)}") + print(f"상품명: {product_name}") + print(f"카테고리: {category}") + print(f"사용 메서드: {method_name}") + if use_llm_translation: + print(f"번역 단계: {steps} ({'직역만' if steps == 1 else '직역+마케팅톤 변환'})") + print() + + for idx, model_id in enumerate(model_ids, 1): + print(f"[{idx}/{len(model_ids)}] 모델: {model_id}") + print("-" * 80) + + start_time = time.time() + success = False + results = None + error_msg = None + + try: + # 번역기 초기화 (타임아웃 10초) + translator = OpenRouterTranslator( + api_key=api_key, + model_id=model_id, + timeout=10, + logger=logger + ) + + # 번역 실행 (플래그에 따라 메서드 선택) + if use_llm_translation: + results = translator.run_llm_translation( + product_name=product_name, + category=category, + ocr_results=ocr_results, + steps=steps + ) + + + + # results = translator.run_combined_llm_translation( + # product_name=product_name, + # category=category, + # ocr_results=ocr_results, + # # steps=steps + # ) + + + else: + results = translator.translate_ocr_texts( + product_name=product_name, + category=category, + ocr_results=ocr_results + ) + + success = True + elapsed_time = time.time() - start_time + + print(f"✅ 성공 - 소요 시간: {elapsed_time:.2f}초") + print(f"번역 결과:") + for i, (original, translated) in enumerate(zip(ocr_results, results), 1): + print(f" {i}. {original['text']} → {translated}") + + except Exception as e: + elapsed_time = time.time() - start_time + error_msg = str(e) + print(f"❌ 실패 - 소요 시간: {elapsed_time:.2f}초") + print(f"오류: {error_msg}") + import traceback + traceback.print_exc() + + benchmark_results.append(BenchmarkResult( + model_id=model_id, + elapsed_time=elapsed_time, + success=success, + results=results, + error=error_msg + )) + + print() + + return benchmark_results + + +def print_benchmark_summary(benchmark_results: List[BenchmarkResult]): + """벤치마크 결과 요약 출력""" + print_separator("벤치마크 결과 요약") + + # 성공한 결과만 필터링 + successful_results = [r for r in benchmark_results if r.success] + failed_results = [r for r in benchmark_results if not r.success] + + if successful_results: + # 실행 시간 기준 정렬 + sorted_results = sorted(successful_results, key=lambda x: x.elapsed_time) + + print("✅ 성공한 모델:") + print("-" * 80) + print(f"{'순위':<6} {'모델 ID':<50} {'소요 시간':<15} {'상태'}") + print("-" * 80) + + for rank, result in enumerate(sorted_results, 1): + status = "✅ 성공" + print(f"{rank:<6} {result.model_id:<50} {result.elapsed_time:>10.2f}초 {status}") + + print() + print("📊 통계:") + times = [r.elapsed_time for r in successful_results] + print(f" 평균 시간: {sum(times) / len(times):.2f}초") + print(f" 최소 시간: {min(times):.2f}초 ({sorted_results[0].model_id})") + print(f" 최대 시간: {max(times):.2f}초 ({sorted_results[-1].model_id})") + print() + + if failed_results: + print("❌ 실패한 모델:") + print("-" * 80) + for result in failed_results: + print(f" {result.model_id}") + print(f" 오류: {result.error}") + print(f" 소요 시간: {result.elapsed_time:.2f}초") + print() + + # 결과 비교 + if len(successful_results) > 1: + print_separator("번역 결과 비교") + + # 첫 번째 성공한 모델의 결과를 기준으로 비교 + base_result = successful_results[0] + print(f"기준 모델: {base_result.model_id}") + print() + + for result in successful_results[1:]: + if result.results and base_result.results: + print(f"모델: {result.model_id}") + print("-" * 80) + + differences = [] + for i, (base_trans, comp_trans) in enumerate(zip(base_result.results, result.results), 1): + if base_trans != comp_trans: + differences.append(i) + print(f" 차이 {len(differences)}: 항목 {i}") + print(f" 기준: {base_trans}") + print(f" 비교: {comp_trans}") + + if not differences: + print(" 모든 번역 결과가 기준 모델과 동일합니다.") + else: + print(f" 총 {len(differences)}개 항목에서 차이 발견") + print() + + +def main(): + """메인 테스트 함수""" + print_separator("OpenRouter 클라이언트 벤치마크 테스트") + + # ============================================================================= + # 여기서 모델과 API 키를 직접 지정하세요 + # ============================================================================= + API_KEY = os.getenv("OPENROUTER_API_KEY", "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") + + + # 테스트 데이터 + product_name = "NewPet 반려동물 House" + category = "반려동물용품" + test_sample = SAMPLE_1 # 또는 SAMPLE_2, SAMPLE_3 등 + + # 벤치마크 설정 + USE_LLM_TRANSLATION = True # True: run_llm_translation 사용, False: translate_ocr_texts 사용 + STEPS = 2 # run_llm_translation 사용 시 번역 단계 (1=직역만, 2=직역+마케팅톤 변환) + + # 벤치마크할 모델 ID 리스트 + MODEL_IDS = [ + # "xiaomi/mimo-v2-flash:free", + # "openai/gpt-oss-20b:deepinfra/fp4", + # "mistralai/devstral-2512:free", + # "mistralai/mistral-7b-instruct:free", + # "openai/gpt-oss-20b:gmicloud/fp4", + # "z-ai/glm-4.5-air:novita/bf16", + # "deepseek/deepseek-v3.2:atlas-cloud/fp8", + "openai/gpt-5-nano:azure", + # "google/gemma-3n-e4b-it:together", + # "google/gemma-3-4b-it:deepinfra/bf16", + # 추가 모델 ID를 여기에 추가하세요 + ] + + # 벤치마크 실행 + benchmark_results = benchmark_models( + api_key=API_KEY, + model_ids=MODEL_IDS, + ocr_results=test_sample, + product_name=product_name, + category=category, + use_llm_translation=USE_LLM_TRANSLATION, + steps=STEPS + ) + + # 결과 요약 출력 + print_benchmark_summary(benchmark_results) + + print_separator("벤치마크 완료") + + +if __name__ == "__main__": + main() + diff --git a/modules/test_openrouter_dual_model.py b/modules/test_openrouter_dual_model.py new file mode 100644 index 0000000..4afac9d --- /dev/null +++ b/modules/test_openrouter_dual_model.py @@ -0,0 +1,433 @@ +# -*- coding: utf-8 -*- +""" +OpenRouter 클라이언트 이중 모델 테스트 스크립트 + +직역과 마케팅 변환에 각각 다른 모델을 사용할 수 있는 테스트 코드 + +사용법: + python modules/test_openrouter_dual_model.py + +환경변수 설정: + export OPENROUTER_API_KEY="sk-or-v1-xxxxx" + 또는 코드에서 직접 설정 +""" +import os +import sys +import time +import logging +from typing import List, Dict, Any, Optional +from dataclasses import dataclass + +# 로깅 설정 +logging.basicConfig( + level=logging.INFO, + format='[%(asctime)s] [%(levelname)s] %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' +) +logger = logging.getLogger(__name__) + +# 모듈 경로 추가 +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from modules.openrouter_client import OpenRouterTranslator + + +# ============================================================================= +# 로그에서 추출한 샘플 OCR 데이터 +# ============================================================================= + +# 샘플 1: 이미지 35 (7개 텍스트, 모두 중국어) +SAMPLE_1: List[Dict[str, Any]] = [ + {'text': '高密【拉毛布】', 'confidence': 0.8697245717048645}, + {'text': '柔中带韧不易坏', 'confidence': 0.9874316453933716}, + {'text': '安静无声助力深度睡眠', 'confidence': 0.9960897564888}, + {'text': 'newpet家的', 'confidence': 0.9988763928413391}, + {'text': '别人家的', 'confidence': 0.9997605085372925}, + {'text': '密织拉毛布保暖还结实', 'confidence': 0.9967950582504272}, + {'text': '劣质无纺布一拉就烂一洗就散', 'confidence': 0.9917935729026794}, +] + +# 샘플 2: 이미지 37 (3개 텍스트, 모두 중국어) +SAMPLE_2: List[Dict[str, Any]] = [ + {'text': '隐藏拉链不易咬', 'confidence': 0.9800551533699036}, + {'text': '宠物更安全', 'confidence': 0.9966630935668945}, + {'text': '隐藏式拉链+顺滑手感告别突元五金', 'confidence': 0.9670320749282837}, +] + + +# ============================================================================= +# 테스트 함수들 +# ============================================================================= + +@dataclass +class DualModelTestResult: + """이중 모델 테스트 결과 데이터 클래스""" + step1_model_id: str + step2_model_id: Optional[str] + elapsed_time: float + success: bool + step1_results: Optional[List[str]] = None + step2_results: Optional[List[str]] = None + error: Optional[str] = None + + +def print_separator(title: str = ""): + """구분선 출력""" + print("\n" + "=" * 80) + if title: + print(f" {title}") + print("=" * 80) + print() + + +def test_dual_model_translation( + api_key: str, + step1_model_id: str, + step2_model_id: Optional[str], + ocr_results: List[Dict[str, Any]], + product_name: str = "테스트 상품", + category: str = "테스트 카테고리", + use_llm_translation: bool = True, + steps: int = 1 +) -> DualModelTestResult: + """ + 이중 모델을 사용한 번역 테스트 + + Args: + api_key: OpenRouter API 키 + step1_model_id: Step 1 (직역)에 사용할 모델 ID + step2_model_id: Step 2 (마케팅톤 변환)에 사용할 모델 ID (None이면 step1과 동일) + ocr_results: OCR 결과 데이터 + product_name: 상품명 + category: 카테고리 + use_llm_translation: True면 run_llm_translation 사용, False면 translate_ocr_texts 사용 + steps: 번역 단계 (1=직역만, 2=직역+마케팅톤 변환) + + Returns: + 테스트 결과 + """ + print_separator("이중 모델 번역 테스트") + print(f"Step 1 모델 (직역): {step1_model_id}") + if steps == 2: + step2_actual = step2_model_id or step1_model_id + print(f"Step 2 모델 (마케팅톤): {step2_actual}") + print(f"입력 텍스트 수: {len(ocr_results)}") + print(f"상품명: {product_name}") + print(f"카테고리: {category}") + print(f"사용 메서드: {'run_llm_translation' if use_llm_translation else 'translate_ocr_texts'}") + print(f"번역 단계: {steps} ({'직역만' if steps == 1 else '직역+마케팅톤 변환'})") + print() + + start_time = time.time() + success = False + step1_results = None + step2_results = None + error_msg = None + + try: + if not use_llm_translation: + # translate_ocr_texts 사용 (단일 모델) + translator = OpenRouterTranslator( + api_key=api_key, + model_id=step1_model_id, + timeout=10, + logger=logger + ) + + results = translator.translate_ocr_texts( + product_name=product_name, + category=category, + ocr_results=ocr_results + ) + + step1_results = results + step2_results = None + success = True + + elif steps == 1: + # run_llm_translation, steps=1 (직역만) + translator = OpenRouterTranslator( + api_key=api_key, + model_id=step1_model_id, + timeout=10, + logger=logger + ) + + results = translator.run_llm_translation( + product_name=product_name, + category=category, + ocr_results=ocr_results, + steps=1 + ) + + step1_results = results + step2_results = None + success = True + + else: + # run_llm_translation, steps=2 (직역 + 마케팅톤 변환, 다른 모델 사용) + step2_actual = step2_model_id or step1_model_id + + # Step 1: 직역 + translator_step1 = OpenRouterTranslator( + api_key=api_key, + model_id=step1_model_id, + timeout=10, + logger=logger + ) + + print(f"[Step 1] 직역 시작 - 모델: {step1_model_id}") + step1_results = translator_step1.run_llm_translation( + product_name=product_name, + category=category, + ocr_results=ocr_results, + steps=1 + ) + + print(f"[Step 1] 직역 완료") + print("Step 1 결과:") + for i, (original, translated) in enumerate(zip(ocr_results, step1_results), 1): + print(f" {i}. {original['text']} → {translated}") + print() + + # Step 2: 마케팅톤 변환 (Step 1 결과를 입력으로 사용) + if step2_actual != step1_model_id: + translator_step2 = OpenRouterTranslator( + api_key=api_key, + model_id=step2_actual, + timeout=10, + logger=logger + ) + else: + translator_step2 = translator_step1 + + print(f"[Step 2] 마케팅톤 변환 시작 - 모델: {step2_actual}") + + # Step 1 결과를 OCR 결과 형태로 변환 + step1_ocr_results = [{"text": text} for text in step1_results] + + step2_results = translator_step2.run_llm_translation( + product_name=product_name, + category=category, + ocr_results=step1_ocr_results, + steps=2 + ) + + print(f"[Step 2] 마케팅톤 변환 완료") + print("Step 2 결과:") + for i, (step1_text, step2_text) in enumerate(zip(step1_results, step2_results), 1): + print(f" {i}. {step1_text} → {step2_text}") + print() + + success = True + + elapsed_time = time.time() - start_time + + print(f"✅ 성공 - 총 소요 시간: {elapsed_time:.2f}초") + print() + print("최종 번역 결과:") + final_results = step2_results if step2_results else step1_results + for i, (original, translated) in enumerate(zip(ocr_results, final_results), 1): + print(f" {i}. {original['text']} → {translated}") + + except Exception as e: + elapsed_time = time.time() - start_time + error_msg = str(e) + print(f"❌ 실패 - 소요 시간: {elapsed_time:.2f}초") + print(f"오류: {error_msg}") + import traceback + traceback.print_exc() + + return DualModelTestResult( + step1_model_id=step1_model_id, + step2_model_id=step2_model_id or step1_model_id if steps == 2 else None, + elapsed_time=elapsed_time, + success=success, + step1_results=step1_results, + step2_results=step2_results, + error=error_msg + ) + + +def test_combined_translation( + api_key: str, + model_id: str, + ocr_results: List[Dict[str, Any]], + product_name: str = "테스트 상품", + category: str = "테스트 카테고리" +) -> DualModelTestResult: + """ + 통합 프롬프트를 사용한 번역 테스트 (한 번의 API 호출로 직역+마케팅톤 변환) + + Args: + api_key: OpenRouter API 키 + model_id: 사용할 모델 ID + ocr_results: OCR 결과 데이터 + product_name: 상품명 + category: 카테고리 + + Returns: + 테스트 결과 + """ + print_separator("통합 프롬프트 번역 테스트") + print(f"모델: {model_id}") + print(f"입력 텍스트 수: {len(ocr_results)}") + print(f"상품명: {product_name}") + print(f"카테고리: {category}") + print(f"사용 메서드: run_combined_llm_translation (직역+마케팅톤 변환 통합)") + print() + + start_time = time.time() + success = False + results = None + error_msg = None + + try: + translator = OpenRouterTranslator( + api_key=api_key, + model_id=model_id, + timeout=10, + logger=logger + ) + + print("번역 중...") + results = translator.run_combined_llm_translation( + product_name=product_name, + category=category, + ocr_results=ocr_results + ) + + success = True + elapsed_time = time.time() - start_time + + print(f"✅ 성공 - 소요 시간: {elapsed_time:.2f}초") + print("번역 결과:") + for i, (original, translated) in enumerate(zip(ocr_results, results), 1): + print(f" {i}. {original['text']} → {translated}") + + except Exception as e: + elapsed_time = time.time() - start_time + error_msg = str(e) + print(f"❌ 실패 - 소요 시간: {elapsed_time:.2f}초") + print(f"오류: {error_msg}") + import traceback + traceback.print_exc() + + return DualModelTestResult( + step1_model_id=model_id, + step2_model_id=None, + elapsed_time=elapsed_time, + success=success, + step1_results=results, + step2_results=None, + error=error_msg + ) + + +def main(): + """메인 테스트 함수""" + print_separator("OpenRouter 이중 모델 테스트") + + # ============================================================================= + # 설정 + # ============================================================================= + API_KEY = os.getenv("OPENROUTER_API_KEY", "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") + + # 테스트 데이터 + product_name = "NewPet 반려동물 House" + category = "반려동물용품" + test_sample = SAMPLE_1 # 또는 SAMPLE_2 등 + + # ============================================================================= + # 테스트 설정 + # ============================================================================= + + # 방법 선택 + USE_LLM_TRANSLATION = True # True: run_llm_translation 사용, False: translate_ocr_texts 사용 + STEPS = 2 # run_llm_translation 사용 시 번역 단계 (1=직역만, 2=직역+마케팅톤 변환) + + + # "xiaomi/mimo-v2-flash:free", + # "openai/gpt-oss-20b:deepinfra/fp4", + # "mistralai/devstral-2512:free", + # "mistralai/mistral-7b-instruct:free", + # "openai/gpt-oss-20b:gmicloud/fp4", + # "z-ai/glm-4.5-air:novita/bf16", + # "x-ai/grok-4.1-fast:xai", + # "deepseek/deepseek-v3.2:atlas-cloud/fp8", + # "openai/gpt-5-nano:azure", + # "google/gemma-3n-e4b-it:together", + # "google/gemma-3-4b-it:deepinfra/bf16", + # 추가 모델 ID를 여기에 추가하세요 + + + # 모델 설정 + STEP1_MODEL_ID = "qwen/qwen3-next-80b-a3b-instruct:gmicloud/fp8" # Step 1 (직역) 모델 + STEP2_MODEL_ID = "qwen/qwen3-next-80b-a3b-instruct:gmicloud/fp8" # Step 2 (마케팅톤) 모델 (None이면 Step1과 동일) + + + # 통합 프롬프트 테스트용 모델 (선택사항) + USE_COMBINED = False # True면 통합 프롬프트 테스트도 실행 + COMBINED_MODEL_ID = "google/gemma-3-4b-it:deepinfra/bf16" # 통합 프롬프트 테스트용 모델 + + # ============================================================================= + # 테스트 실행 + # ============================================================================= + + # 이중 모델 테스트 + result = test_dual_model_translation( + api_key=API_KEY, + step1_model_id=STEP1_MODEL_ID, + step2_model_id=STEP2_MODEL_ID, + ocr_results=test_sample, + product_name=product_name, + category=category, + use_llm_translation=USE_LLM_TRANSLATION, + steps=STEPS + ) + + # 통합 프롬프트 테스트 (선택사항) + if USE_COMBINED: + print_separator("통합 프롬프트 테스트") + combined_result = test_combined_translation( + api_key=API_KEY, + model_id=COMBINED_MODEL_ID, + ocr_results=test_sample, + product_name=product_name, + category=category + ) + + # 결과 비교 + if result.success and combined_result.success: + print_separator("결과 비교") + print("이중 모델 방식 vs 통합 프롬프트 방식") + print("-" * 80) + + final_dual = result.step2_results if result.step2_results else result.step1_results + final_combined = combined_result.step1_results + + differences = [] + for i, (dual_text, combined_text) in enumerate(zip(final_dual, final_combined), 1): + if dual_text != combined_text: + differences.append(i) + print(f"차이 {len(differences)}: 항목 {i}") + print(f" 이중 모델: {dual_text}") + print(f" 통합 프롬프트: {combined_text}") + + if not differences: + print("모든 번역 결과가 동일합니다.") + else: + print(f"총 {len(differences)}개 항목에서 차이 발견") + + print() + print(f"이중 모델 소요 시간: {result.elapsed_time:.2f}초") + print(f"통합 프롬프트 소요 시간: {combined_result.elapsed_time:.2f}초") + + print_separator("테스트 완료") + + +if __name__ == "__main__": + main() + + + diff --git a/setup_ob2.py b/setup_ob2.py new file mode 100644 index 0000000..de9493b --- /dev/null +++ b/setup_ob2.py @@ -0,0 +1,649 @@ +import sys +import os +import glob +import shutil +import subprocess +import logging +import time +from tqdm import tqdm + +import requests + +from cx_Freeze import setup, Executable +from setuptools import find_packages +from setuptools.command.build_ext import build_ext +from cx_Freeze.command.build_exe import build_exe as _build_exe + +from setuptools import setup as cy_setup, Extension +from Cython.Build import cythonize + + + +# 버전 및 메타데이터 가져오기 +from updater.__version__ import ( + __title__, __version__, __description__, __author__, + __author_email__, __license__, __install_requires__ +) + +# ============================================================================ +# [Configuration] 0. Gokapi 서버 설정 (업로드를 위해 필수) +# ============================================================================ +GOKAPI_URL = "https://go.wrmc.cc" # 사용자님의 Gokapi 주소로 변경하세요 +GOKAPI_APIKEY = "Pncy6s7pyi61rtUsV3kUwfPtOvU93I " # Gokapi 관리자 페이지에서 발급받은 API 키 + +# ============================================================================ +# [Configuration] 설정 및 상수 정의 +# ============================================================================ + +# 1. Cython으로 컴파일할 모듈 목록 (최소화하여 테스트) +CYTHON_MODULES = [ + # 최소한의 모듈만 테스트 + "loggerModule", + # "modules/image_worker", + # "modules/tray_app", +] + +# 2. 빌드 후 제거할 불필요한 파일/폴더 목록 +CLEANUP_TARGETS = [ + # 디렉토리 + "lib/modules/ocr_backends", # OCR 백엔드들 (필요시 유지) + "lib/modules/old_modules", # 구 버전 모듈들 + "lib/modules/test", # 테스트 파일들 + "lib/modules/debug_images", # 디버그 이미지들 + "lib/modules/img", # 샘플 이미지들 + "lib/modules/output", # 출력 샘플들 + "lib/modules/outputs", # 출력 샘플들 + "lib/modules/user_data", # 사용자 데이터 + "lib/modules/PP_Models", # Paddle 모델들 (이미 포함될 수 있음) + "lib/paddle", "lib/paddleocr", "lib/onnxruntime", "lib/skimage", "lib/scipy", + + # 파일 + "lib/modules/migan_traced.pt", + "lib/modules/*.pyc", + "lib/modules/*/*.pyc", + "lib/modules/*/*/*.pyc", + +] + +# 3. 소스 패키징에서 강제로 제외할 패키지들 +BASE_EXCLUDES = [ + 'tkinter', 'PyQt4', 'PyQt5', 'AppKit', 'Foundation', 'IPython', + 'OpenSSL', 'curses', 'test', 'matplotlib', 'asyncpg', + 'importlib._bootstrap', 'importlib.machinery', + 'pytest', 'hypothesis', 'mypy', 'coverage', 'tox', + 'sympy', 'mpmath', 'gmpy2', + 'paddle', 'paddleocr', 'paddlehub', 'onnxruntime', 'onnx', + 'skimage', 'scikit-image', 'pyclipper', 'shapely', + 'scipy', 'imgaug', 'albumentations', 'torch', 'tensorflow', 'keras', + "PySide6", + # 프로젝트 특정 제외 + # 참고: CYTHON_MODULES에 포함된 모듈들은 get_cython_freeze_config()에서 자동으로 제외됨 +] + +# 4. 강제 포함 패키지 +BASE_INCLUDES = [ + # 정말 최소한의 모듈만 포함하여 테스트 + 'json', 'os', 'sys', 'time', 'threading', +] + + +# ============================================================================ +# [Helper Functions] 로직 분리 +# ============================================================================ + +def run_setup_clean(): + """ + 기존 빌드찌꺼기 제거 + """ + print("\n>>> [Cleaner] 기존 빌드찌꺼기 제거 시작...") + # 자동으로 'y' 입력하여 확인 절차 생략 + result = subprocess.run(["python", "-c", "import sys; sys.path.insert(0, 'tests'); from setup_clean import clean_files_oswalk; clean_files_oswalk()"]) + if result.returncode == 0: + print(">>> [Cleaner] 기존 빌드찌꺼기 제거 완료!\n") + else: + print(">>> [Cleaner] 정리 중 오류 발생, 계속 진행합니다.\n") + + +def run_cython_build(): + """ + setup_cython.py를 별도로 실행하지 않고, + 여기서 직접 Cython 빌드를 수행합니다. (경로 꼬임 방지) + """ + print("\n>>> [Cython] 내부 빌드 프로세스 시작...") + + extensions = [] + + # 전역변수 CYTHON_MODULES 리스트를 사용 + for file_path in CYTHON_MODULES: + # 파일 확인 (.py가 없는 경우 붙여서 확인) + source_file = file_path + if not os.path.exists(source_file): + if os.path.exists(source_file + ".py"): + source_file += ".py" + else: + print(f" [Warning] 컴파일 대상 파일을 찾을 수 없음: {file_path}") + continue + + # 모듈 이름 생성 (경로 -> 점 표기법) + # 예: modules/image_worker -> modules.image_worker + no_ext = os.path.splitext(source_file)[0] + module_name = no_ext.replace("/", ".").replace("\\", ".") + + # Extension 객체 생성 + ext = Extension( + name=module_name, + sources=[source_file] + ) + extensions.append(ext) + + if not extensions: + print(">>> [Cython] 컴파일할 대상이 없습니다.") + return + + # setuptools의 setup을 직접 호출 (인자값으로 build_ext --inplace 전달) + try: + cy_setup( + name="CythonInternalBuild", + ext_modules=cythonize( + extensions, + compiler_directives={'language_level': "3"}, + quiet=True + ), + script_args=['build_ext', '--inplace'] + ) + print(">>> [Cython] 빌드 성공!\n") + except Exception as e: + print(f"\n>>> [Cython] 빌드 중 오류 발생: {e}") + sys.exit(1) + + +def get_cython_freeze_config(modules_list): + """ + Cython 모듈 리스트를 기반으로 cx_Freeze용 설정을 생성합니다. + Returns: + (excludes_list, include_files_list, include_packages_to_remove) + """ + excludes = [] # .py 소스 제외용 + include_files = [] # .pyd 파일 포함용 + module_names = set() + + for module_path in modules_list: + # 모듈 이름 변환 (modules/image_worker -> modules.image_worker) + clean_path = os.path.splitext(module_path)[0] + module_name = clean_path.replace("/", ".").replace("\\", ".") + module_names.add(module_name) + + excludes.append(module_name) + + # .pyd 파일 찾기 및 매핑 + dir_name = os.path.dirname(module_path) + base_name = os.path.basename(module_path) + pyd_pattern = os.path.join(dir_name, f"{base_name}*.pyd") + found_pyds = glob.glob(pyd_pattern) + + if found_pyds: + src_pyd = found_pyds[0] + # 라이브러리 구조 유지: lib/modules/... + dest_pyd = os.path.join("lib", dir_name, f"{base_name}.pyd") + include_files.append((src_pyd, dest_pyd)) + print(f" [Protect] {module_name}: .py 제외, .pyd 포함") + else: + print(f" [Warning] .pyd 없음: {module_path}. (원본 .py가 포함될 수 있음)") + + return excludes, include_files, module_names + + +def collect_include_files(): + """DLL, 리소스 파일 등 기타 include_files 리스트를 생성합니다.""" + # 디버그를 위해 최소한의 파일만 포함 + files = [] + + # VC Runtime Files만 포함 (최소한으로) + vc_runtimes = [ + ('C:/Windows/System32/vcruntime140.dll', 'vcruntime140.dll'), + ('C:/Windows/System32/msvcp140.dll', 'msvcp140.dll'), + ] + + # VC 런타임 파일 존재 여부 확인 후 추가 + for src, dest in vc_runtimes: + if os.path.exists(src): + files.append((src, dest)) + + print(f"DEBUG: Including {len(files)} files") + return files + + +# ============================================================================ +# [Main Logic] 실행 로직 (빌드 시에만 실행) +# ============================================================================ + +def prepare_build_options(): + """빌드 옵션을 준비하는 함수""" + global final_includes, final_excludes, final_include_files + + # 0. 기존 빌드찌꺼기 제거 + run_setup_clean() + + # 1. Cython 빌드 실행 + run_cython_build() + + # 2. cx_Freeze 설정 준비 + cy_excludes, cy_include_files, cy_module_names = get_cython_freeze_config(CYTHON_MODULES) + resource_include_files = collect_include_files() + + # 3. 최종 옵션 조합 + final_includes = [mod for mod in BASE_INCLUDES if mod not in cy_module_names] # 충돌 방지 + final_excludes = BASE_EXCLUDES + cy_excludes + final_include_files = resource_include_files + cy_include_files + + # 디버그: 문제가 되는 모듈들을 임시로 제외 + if EXCLUDE_PROBLEMATIC_MODULES and DEBUG_MODE: + print("=== EXCLUDING PROBLEMATIC MODULES FOR DEBUG ===") + + # 문제가 될 수 있는 모듈들 임시 제외 + problematic_modules = [ + 'onnx_ocr_module', 'onnx_ocr_wrapper', 'onnx_ocr_module.src.onnx_ocr_wrapper', + 'modules.onnx_ocr_module', 'modules.onnx_ocr_module.src.onnx_ocr_wrapper', + 'paddle', 'paddleocr', 'onnxruntime', 'onnx' + ] + + original_count = len(final_includes) + final_includes = [mod for mod in final_includes if not any(pm in mod for pm in problematic_modules)] + + # include_files에서도 제외 + final_include_files = [f for f in final_include_files if not any(pm in str(f) for pm in problematic_modules)] + + print(f"Excluded problematic modules. Includes: {original_count} -> {len(final_includes)}") + print(f"Excluded problematic files. Include files: {len(resource_include_files + cy_include_files)} -> {len(final_include_files)}") + print("=" * 50) + +# 디버그 모드 설정 +DEBUG_MODE = True + +# 문제가 되는 큰 모듈들을 임시로 제외하여 테스트 +EXCLUDE_PROBLEMATIC_MODULES = True + +# 0. 기존 빌드찌꺼기 제거 +run_setup_clean() + +# 1. Cython 빌드 실행 +run_cython_build() + +# 2. cx_Freeze 설정 준비 +cy_excludes, cy_include_files, cy_module_names = get_cython_freeze_config(CYTHON_MODULES) +resource_include_files = collect_include_files() + +# 3. 최종 옵션 조합 +final_includes = [mod for mod in BASE_INCLUDES if mod not in cy_module_names] # 충돌 방지 +final_excludes = BASE_EXCLUDES + cy_excludes +final_include_files = resource_include_files + cy_include_files + +# 디버그: 문제가 되는 모듈들을 임시로 제외 +if EXCLUDE_PROBLEMATIC_MODULES and DEBUG_MODE: + print("=== EXCLUDING PROBLEMATIC MODULES FOR DEBUG ===") + + # 문제가 될 수 있는 모듈들 임시 제외 + problematic_modules = [ + 'onnx_ocr_module', 'onnx_ocr_wrapper', 'onnx_ocr_module.src.onnx_ocr_wrapper', + 'modules.onnx_ocr_module', 'modules.onnx_ocr_module.src.onnx_ocr_wrapper', + 'paddle', 'paddleocr', 'onnxruntime', 'onnx' + ] + + original_count = len(final_includes) + final_includes = [mod for mod in final_includes if not any(pm in mod for pm in problematic_modules)] + + # include_files에서도 제외 + final_include_files = [f for f in final_include_files if not any(pm in str(f) for pm in problematic_modules)] + + print(f"Excluded problematic modules. Includes: {original_count} -> {len(final_includes)}") + print(f"Excluded problematic files. Include files: {len(resource_include_files + cy_include_files)} -> {len(final_include_files)}") + print("=" * 50) + +build_options = { + 'packages': [ + 'ctypes', 'asyncio', 'subprocess', 'pyperclip', 'numpy', + 'requests', 'PIL', 'bs4', 'psutil', + 'openai', 'httpx', 'pydantic', # fastapi, uvicorn 제외 (설치 안됨) + 'pandas', 'supabase', 'translatepy', 'markdown', + 'json', 'json.encoder', 'json.decoder', 'json.scanner', + 'dotenv', 'pathlib', 'logging', 'threading', 'multiprocessing', + # 'cv2', # OpenCV 제외 (DLL 문제) + ], + 'includes': final_includes, + 'excludes': final_excludes, + 'include_files': final_include_files, + 'zip_include_packages': [], + 'optimize': 0, + 'silent': False if DEBUG_MODE else True, # 디버그 모드에서는 silent 해제 + 'include_msvcr': True, +} + +# 디버그 모드 추가 설정 +if DEBUG_MODE: + print("=== DEBUG MODE ENABLED ===") + print(f"Final includes count: {len(final_includes)}") + print(f"Final excludes count: {len(final_excludes)}") + print(f"Final include_files count: {len(final_include_files)}") + + # 문제가 될 수 있는 큰 모듈들을 임시로 제외해서 테스트 + print("Checking for problematic modules...") + + # 큰 모듈들을 확인 + large_modules = [m for m in final_includes if any(x in m for x in ['onnx', 'paddle', 'torch', 'tensorflow'])] + if large_modules: + print(f"Large modules detected: {large_modules}") + + # 포함 파일들 확인 + print("Include files:") + for f in final_include_files[:10]: # 처음 10개만 + print(f" {f}") + if len(final_include_files) > 10: + print(f" ... and {len(final_include_files) - 10} more") + print("=" * 50) + + +# ============================================================================ +# [Custom Build Class] 빌드 프로세스 커스터마이징 +# ============================================================================ + +class CustomBuildExe(_build_exe): + def run(self): + # 전체 진행률: 100 + # 초기값 10: Cython 빌드는 이 클래스 실행 전(if __name__...)에 이미 완료됨 + print("\n" + "="*60) + print(" ImgWorker 통합 빌드 시스템") + print("="*60 + "\n") + try: + # 총 6단계로 구성 (Cython은 이미 완료됨 -> 10%) + with tqdm(total=100, initial=10, unit="pct", + bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}% [{elapsed}]", + ncols=80, colour='green') as pbar: + + # [Step 2] cx_Freeze 빌드 (10 -> 30%) + pbar.set_description("Step 2/6: cx_Freeze Packaging") + print(f"DEBUG: Starting cx_Freeze build with {len(build_options.get('includes', []))} includes") + print(f"DEBUG: {len(build_options.get('excludes', []))} excludes") + print(f"DEBUG: {len(build_options.get('include_files', []))} include_files") + print(f"DEBUG: {len(build_options.get('packages', []))} packages") + + # cx_Freeze 실행 전 타임스탬프 + import time + start_time = time.time() + print(f"DEBUG: Build start time: {start_time}") + + _build_exe.run(self) + + end_time = time.time() + print(f"DEBUG: Build end time: {end_time}") + print(f"DEBUG: Build duration: {end_time - start_time:.2f} seconds") + pbar.update(20) + + + # [Step 3] 빌드 결과물 정리 (30 -> 35%) + pbar.set_description("Step 3/6: Cleaning Build Output") + self._cleanup_build_output() + pbar.update(5) + + # [Step 4] Inno Setup 컴파일 (35 -> 70%) + pbar.set_description("Step 4/6: Inno Setup Compiling") + self._run_inno_setup() # .iss 생성 + self._compile_inno_installer() # .exe 생성 + pbar.update(35) + + + # [Step 5] 파일명 변경 (버전 정보 추가) (70 -> 75%) + pbar.set_description("Step 5/6: Renaming Installer") + final_installer_path = self._rename_installer_with_version() + pbar.update(5) + + # [Step 6] Gokapi 업로드 (75 -> 95%) + if final_installer_path and GOKAPI_URL != "https://gokapi.your-domain.com": + pbar.set_description("Step 6/6: Uploading to Gokapi") + self._upload_to_gokapi(final_installer_path) + else: + print("\n[Skip] Gokapi 설정이 없거나 파일이 없어 업로드를 건너뜁니다.") + pbar.update(20) + + # [Final] 소스 정리 (95 -> 100%) + pbar.set_description("Finalizing: Cleaning Source") + self._cleanup_cython_artifacts() + pbar.update(5) + + pbar.set_description("Build Complete!") + + except KeyboardInterrupt: + print("\n\n>>> 빌드가 취소되었습니다.") + sys.exit(1) + except Exception as e: + print(f"\n\n>>> 빌드 중 치명적인 오류 발생: {e}") + # 에러 상세 내용을 보기 위해 traceback 출력 + import traceback + traceback.print_exc() + sys.exit(1) + + def _get_dir_size(self, path): + total = 0 + for dirpath, _, filenames in os.walk(path): + for f in filenames: + total += os.path.getsize(os.path.join(dirpath, f)) + return total + + def _rename_installer_with_version(self): + """생성된 설치 파일 이름에 버전을 추가합니다.""" + # Inno Setup의 기본 출력 경로 (dist/installer) + dist_dir = os.path.join(os.path.dirname(__file__), "dist", "installer") + + # 원래 생성되는 파일명 (generate_iss.py 설정에 따름, 보통 Setup.exe) + # 로그에 찍힌 이름을 기준으로 찾습니다. + original_name = "ImgWorker Setup.exe" + original_path = os.path.join(dist_dir, original_name) + + if not os.path.exists(original_path): + print(f"\n[Error] 원본 설치 파일을 찾을 수 없습니다: {original_path}") + # 혹시 다른 이름일 수도 있으니 exe 파일을 검색해봅니다. + exe_files = glob.glob(os.path.join(dist_dir, "*.exe")) + if exe_files: + original_path = max(exe_files, key=os.path.getctime) # 가장 최신 파일 + else: + return None + + # 새 파일명: ImgWorker Setup_V3.12.15.exe + new_name = f"ImgWorker Setup_V{__version__}.exe" + new_path = os.path.join(dist_dir, new_name) + + try: + # 기존에 같은 버전 파일이 있으면 삭제 + if os.path.exists(new_path): + os.remove(new_path) + + os.rename(original_path, new_path) + print(f"\n[Rename] 파일명이 변경되었습니다:\n -> {new_name}") + return new_path + except Exception as e: + print(f"\n[Error] 파일명 변경 실패: {e}") + return original_path + + def _upload_to_gokapi(self, file_path): + """Gokapi 서버로 파일을 업로드합니다.""" + print("\n[Upload] Gokapi 서버로 업로드를 시작합니다...") + + if not os.path.exists(file_path): + print(" [Error] 업로드할 파일이 없습니다.") + return + + try: + url = f"{GOKAPI_URL}/api/v1/upload" + headers = { + "Authorization": f"Bearer {GOKAPI_APIKEY}" + } + + + with open(file_path, "rb") as f: + # 멀티파트 업로드 + files = {"file": (os.path.basename(file_path), f)} + data = { + "expire": 0 # ✅ 영구 저장 + } # 만료일 설정 (예: 0=무제한, 7d=7일) - 필요시 data={'expiry': '7d'} 추가 + + response = requests.post( + url, + headers=headers, + files=files, + data=data, + timeout=30 + ) + + if response.status_code in (200, 201): + data = response.json() + + # Gokapi 응답 구조 + hotlink = data.get("DownloadUrl") or data.get("File", {}).get("Url") + + print("\n" + "#" * 50) + print("업로드 성공!") + print(f"다운로드 링크: {hotlink}") + print("#" * 50 + "\n") + else: + print(f"\n[Error] 업로드 실패 (Status: {response.status_code})") + print("Server Response:", response.text) + + except Exception as e: + print(f"\n[Error] 업로드 중 예외 발생: {e}") + + def _cleanup_build_output(self): + """빌드된 exe 폴더 내부의 불필요한 파일 삭제""" + print("\n[Cleaner] 빌드 결과물 정리 중...") + build_dir = os.path.join(os.path.dirname(__file__), "build") + + if not os.path.exists(build_dir): return + + removed_count = 0 + total_saved = 0 + + for item in os.listdir(build_dir): + if not item.startswith("exe."): continue + + exe_dir = os.path.join(build_dir, item) + for unnecessary in CLEANUP_TARGETS: + target_path = os.path.join(exe_dir, unnecessary) + try: + if os.path.isdir(target_path): + size = self._get_dir_size(target_path) + shutil.rmtree(target_path) + total_saved += size + print(f" ✓ 디렉토리 삭제: {unnecessary}") + elif os.path.isfile(target_path): + size = os.path.getsize(target_path) + os.remove(target_path) + total_saved += size + print(f" ✓ 파일 삭제: {unnecessary}") + removed_count += 1 + except Exception: + pass # 없는 파일은 무시 + + print(f"[Cleaner] 정리 완료: {total_saved / (1024*1024):.1f} MB 절약\n") + + def _cleanup_cython_artifacts(self): + """소스 폴더의 .pyd, .c 임시 파일 삭제""" + print("[Cleaner] 소스 폴더 Cython 임시 파일 정리 중...") + deleted = 0 + for module_path in CYTHON_MODULES: + dir_name = os.path.dirname(module_path) + base_name = os.path.basename(module_path) + patterns = [ + os.path.join(dir_name, f"{base_name}*.pyd"), + os.path.join(dir_name, f"{base_name}.c") + ] + for pattern in patterns: + for f in glob.glob(pattern): + try: + os.remove(f) + deleted += 1 + except Exception: pass + print(f"[Cleaner] 소스 정리 완료: {deleted}개 파일 삭제\n") + + def _run_inno_setup(self): + """Inno Setup 스크립트 생성기 실행 (현재 프로젝트에는 없으므로 생략)""" + print("[Inno Setup] 설치 스크립트 생성 생략 (generate_iss.py 없음)...") + + def _compile_inno_installer(self): + """Inno Setup 컴파일 생략 (현재 프로젝트에는 설치 스크립트 없음)""" + print("[Inno Setup] 설치 파일 컴파일 생략...") + + +# ============================================================================ +# [Setup] 최종 실행 +# ============================================================================ + +# 디버그용 간단한 테스트 함수 +def test_build(): + """빌드 전 문제점을 미리 테스트""" + print("=== BUILD TEST ===") + + # 1. 모듈 import 테스트 + print("Testing module imports...") + test_modules = ['fastapi', 'uvicorn', 'pydantic', 'cv2', 'numpy', 'PIL'] + for mod in test_modules: + try: + __import__(mod) + print(f" OK {mod}") + except ImportError as e: + print(f" FAIL {mod}: {e}") + + # 2. 큰 파일들 확인 + print("\nChecking large files...") + large_files = [] + for root, dirs, dirs[:] in os.walk('.'): + for file in dirs: + if file in ['onnx_ocr_module', 'PP_Models', 'rembg_models', 'migan_onnx']: + path = os.path.join(root, file) + try: + size = sum(os.path.getsize(os.path.join(dirpath, f)) + for dirpath, _, files in os.walk(path) + for f in files) + large_files.append((path, size)) + except: + pass + + for path, size in sorted(large_files, key=lambda x: x[1], reverse=True): + print(f" {path}: {size / (1024*1024):.1f} MB") + + print("=" * 50) + +base = 'Win32GUI' if sys.platform == 'win32' else None + +# 명령행 인자 처리 +if __name__ == "__main__": + import sys + if len(sys.argv) > 1 and sys.argv[1] == 'test': + test_build() + sys.exit(0) + +# 빌드 옵션 준비 (빌드 시에만) +prepare_build_options() + +setup( + name=__title__, + version=__version__, + description=__description__, + author=__author__, + author_email=__author_email__, + license=__license__, + packages=find_packages(), + install_requires=__install_requires__, + python_requires='>=3.11', + include_package_data=True, + zip_safe=False, + options={'build_exe': build_options}, + executables=[ + Executable( + 'main.py', + base=base, + target_name='ImgWorker.exe' + # icon="Edit_PartTimer3.ico" # 아이콘 파일이 없으므로 기본 아이콘 사용 + ) + ], + cmdclass={ + "build_exe": CustomBuildExe, + }, +) diff --git a/tests/__pycache__/setup_clean.cpython-311.pyc b/tests/__pycache__/setup_clean.cpython-311.pyc new file mode 100644 index 0000000..b1eb908 Binary files /dev/null and b/tests/__pycache__/setup_clean.cpython-311.pyc differ diff --git a/tests/setup_clean.py b/tests/setup_clean.py new file mode 100644 index 0000000..c77da00 --- /dev/null +++ b/tests/setup_clean.py @@ -0,0 +1,148 @@ +import os +import glob +import fnmatch + +def clean_files_oswalk(): + """os.walk를 사용한 기존 방식 - 더 세밀한 컨트롤 가능""" + # 1. 삭제할 확장자 정의 + target_extensions = ('.c', '.pyd') + + # 2. 제외할 폴더 이름 (어디에 있든 이름이 일치하면 제외) + # 대소문자를 정확히 입력해주세요. 필요시 '.git', '__pycache__' 등 추가 + exclude_folder_names = { + 'scripts', 'build', 'Lib', '.git', '__pycache__', 'venv', + 'env', '.env', '.venv', 'virtualenv', '.virtualenv', + 'conda', 'miniconda', 'anaconda', 'miniforge', + 'node_modules', 'dist', 'build', 'target', + '.vscode', '.idea', '__pycache__', '.pytest_cache', + '.mypy_cache', '.tox', '.coverage', '.DS_Store' + } + + # 3. 제외할 특정 경로 (현재 위치 기준 상대 경로) + # 예: 'src/browsers'는 ./src/browsers 폴더 하위를 모두 제외함 + exclude_specific_paths = {'src/browsers'} + + # 경로 구분자 통일 (Windows '\', Mac/Linux '/' 호환성 확보) + exclude_specific_paths = {os.path.normpath(p) for p in exclude_specific_paths} + + current_dir = os.getcwd() # 현재 실행 위치 + print(f"작업 시작 위치: {current_dir}") + print("-" * 30) + + for root, dirs, files in os.walk(current_dir): + # [중요] dirs 리스트를 제자리에서 수정(slice assignment)하여 + # os.walk가 제외된 폴더로 진입하지 않도록 막습니다. + + # 1차 필터링: 폴더 이름으로 제외 (예: build, Lib) + dirs[:] = [d for d in dirs if d not in exclude_folder_names] + + # 2차 필터링: 특정 경로로 제외 (예: src/browsers) + allowed_dirs = [] + for d in dirs: + # 현재 탐색 중인 폴더(root) + 하위 폴더(d)의 전체 경로 생성 + full_path = os.path.join(root, d) + # 실행 위치 기준 상대 경로 계산 + rel_path = os.path.relpath(full_path, current_dir) + + # 제외할 경로 리스트에 포함되어 있는지 확인 + if rel_path not in exclude_specific_paths: + allowed_dirs.append(d) + else: + print(f"[제외됨] 경로: {rel_path}") + + dirs[:] = allowed_dirs + + # 파일 삭제 로직 + for file in files: + if file.endswith(target_extensions): + file_path = os.path.join(root, file) + try: + os.remove(file_path) + print(f"삭제됨: {file_path}") + except Exception as e: + print(f"오류 발생 ({file}): {e}") + + +def clean_files_glob(): + """glob을 사용한 방식 - 더 간단하지만 덜 세밀한 컨트롤""" + current_dir = os.getcwd() + print(f"작업 시작 위치: {current_dir}") + print("-" * 30) + + # 제외할 폴더 패턴들 + exclude_patterns = [ + '**/venv/**', '**/env/**', '**/.env/**', '**/.venv/**', + '**/virtualenv/**', '**/.virtualenv/**', '**/conda/**', + '**/miniconda/**', '**/anaconda/**', '**/miniforge/**', + '**/node_modules/**', '**/dist/**', '**/build/**', '**/target/**', + '**/.git/**', '**/__pycache__/**', '**/.vscode/**', '**/.idea/**', + '**/.pytest_cache/**', '**/.mypy_cache/**', '**/.tox/**', '**/.coverage/**' + ] + + deleted_count = 0 + total_size = 0 + + # .c 파일들 찾기 + for c_file in glob.glob("**/*.c", recursive=True): + if not _is_excluded_by_patterns(c_file, exclude_patterns): + try: + size = os.path.getsize(c_file) + os.remove(c_file) + print(f"삭제됨: {c_file} ({size} bytes)") + deleted_count += 1 + total_size += size + except Exception as e: + print(f"오류 발생 ({c_file}): {e}") + + # .pyd 파일들 찾기 + for pyd_file in glob.glob("**/*.pyd", recursive=True): + if not _is_excluded_by_patterns(pyd_file, exclude_patterns): + try: + size = os.path.getsize(pyd_file) + os.remove(pyd_file) + print(f"삭제됨: {pyd_file} ({size} bytes)") + deleted_count += 1 + total_size += size + except Exception as e: + print(f"오류 발생 ({pyd_file}): {e}") + + print(f"\n총 {deleted_count}개 파일 삭제, {total_size} bytes 정리됨") + + +def _is_excluded_by_patterns(file_path, exclude_patterns): + """파일 경로가 제외 패턴에 매칭되는지 확인""" + for pattern in exclude_patterns: + # glob 패턴을 fnmatch 스타일로 변환 + if fnmatch.fnmatch(file_path, pattern): + return True + return False + + +def clean_files(): + """메인 정리 함수 - 기본적으로 oswalk 방식을 사용 (더 안전하고 세밀한 컨트롤)""" + print("=== Cython 빌드 파일 정리기 ===") + print("두 가지 정리 방식이 있습니다:") + print("1: os.walk 방식 (세밀한 컨트롤, 폴더별 제외, 추천)") + print("2: glob 방식 (간단하지만 덜 정밀)") + + try: + choice = input("방식을 선택하세요 (1 또는 2, 기본값: 1): ").strip() + if choice == "2": + print("glob 방식을 선택했습니다.") + clean_files_glob() + else: + print("os.walk 방식을 선택했습니다.") + clean_files_oswalk() + except KeyboardInterrupt: + print("\n\n작업이 취소되었습니다.") + return + + +if __name__ == "__main__": + # 실수로 실행하는 것을 방지하기 위해 사용자 확인을 추가할 수 있습니다. + confirm = input("현재 폴더 내의 모든 .c, .pyd 파일을 삭제하시겠습니까? (y/n): ") + if confirm.lower() == 'y': + clean_files() + print("\n작업 완료.") + else: + print("취소되었습니다.") \ No newline at end of file diff --git a/tests/setup_ob.py b/tests/setup_ob.py new file mode 100644 index 0000000..cbbd853 --- /dev/null +++ b/tests/setup_ob.py @@ -0,0 +1,704 @@ +import sys +import os +import glob +import shutil +import subprocess +import logging +import time +from tqdm import tqdm + +import requests + +from cx_Freeze import setup, Executable +from setuptools import find_packages +from setuptools.command.build_ext import build_ext +from cx_Freeze.command.build_exe import build_exe as _build_exe + +from setuptools import setup as cy_setup, Extension +from Cython.Build import cythonize + + + +# 버전 및 메타데이터 가져오기 +from updateManager.__version__ import ( + __title__, __version__, __description__, __author__, + __author_email__, __license__, __install_requires__ +) + +# ============================================================================ +# [Configuration] 0. Gokapi 서버 설정 (업로드를 위해 필수) +# ============================================================================ +GOKAPI_URL = "https://go.wrmc.cc" # 사용자님의 Gokapi 주소로 변경하세요 +GOKAPI_APIKEY = "Pncy6s7pyi61rtUsV3kUwfPtOvU93I " # Gokapi 관리자 페이지에서 발급받은 API 키 + +# ============================================================================ +# [Configuration] 설정 및 상수 정의 +# ============================================================================ + +# 1. Cython으로 컴파일할 모듈 목록 +CYTHON_MODULES = [ + # "browser_control", + "locatorManager_by_SP", + "src/contents/details", + "src/contents/option", + "src/contents/price", + "src/contents/tags", + "src/contents/thumb", + "src/contents/titleGenerator", + "src/img_module/image_processor_dialog", + "src/img_module/image_processor_manager", + "src/modules/image_worker_client", + "src/lens/aliprice_lens_client", + "src/lens/naver_lens_adapter", + "src/lens/naver_lens_client", + "src/lens/naver_lens_parser", + "src/sp_manager", + "src/titleManager/gpt_client", + "src/titleManager/grok_client", + "src/titleManager/naverAPI", + "src/titleManager/naver_parser", + "src/titleManager/sp_ForbiddenM", + "src/translator/chinese_dict_manager", + "src/translator/papago_translator", + "src/AI_Module/ai_client", + "src/AI_Module/baseAIProvider", + "src/AI_Module/gpt_provider", + "src/AI_Module/grok_provider", + "src/AI_Module/openRouter_provider", + "src/AI_Module/gemini_provider", +] + +# 2. 빌드 후 제거할 불필요한 파일/폴더 목록 (ImageProcessor3 관련 등) +CLEANUP_TARGETS = [ + # 디렉토리 + "lib/src/modules/briaaiModel", "lib/src/modules/migan_onnx", "lib/src/modules/modules", + "lib/src/modules/ocr_backends", "lib/src/modules/onnx_ocr_module", "lib/src/modules/output", + "lib/src/modules/outputs", "lib/src/modules/PP_Models", "lib/src/modules/rembg_models", + "lib/src/PP_Models", "lib/paddle", "lib/paddleocr", "lib/onnxruntime", "lib/skimage", "lib/scipy", + # 파일 + "lib/src/modules/migan_traced.pt", + "lib/src/modules/image_processor3.py", "lib/src/modules/image_processor4.py", + "lib/src/modules/image_worker.py", "lib/src/modules/image_worker_manager.py", + "lib/src/modules/ocr_module.py", "lib/src/modules/mask_module_for_paddle.py", + "lib/src/modules/text_rendering_module.py", "lib/src/modules/postImageManager.py", + "lib/src/modules/request_inpaint.py", "lib/src/modules/migan_module.py", + "lib/src/modules/background_removal_module.py", "lib/src/modules/bria_background_removal_module.py", + "lib/src/modules/gemma_client.py", + # 컴파일된 잔재 (.pyc) + "lib/src/modules/image_processor3.pyc", "lib/src/modules/image_processor4.pyc", + "lib/src/modules/image_worker.pyc", "lib/src/modules/image_worker_manager.pyc", + "lib/src/modules/ocr_module.pyc", "lib/src/modules/mask_module_for_paddle.pyc", + "lib/src/modules/text_rendering_module.pyc", "lib/src/modules/postImageManager.pyc", + "lib/src/modules/request_inpaint.pyc", "lib/src/modules/migan_module.pyc", + "lib/src/modules/background_removal_module.pyc", "lib/src/modules/bria_background_removal_module.pyc", + "lib/src/modules/gemma_client.pyc", + + # [PySide6 다이어트] + # 1. 번역 파일 (한국어/영어 외 제거하려면 통째로 지우거나 선별) + # 보통 프로그램 내 텍스트가 한글이라면 Qt 자체 번역 파일은 없어도 됨 + "lib/PySide6/translations", + + # 2. 불필요한 플러그인 (사용 안 하는 기능) + # 주의: 'platforms', 'styles', 'imageformats'는 지우면 안 됩니다! + "lib/PySide6/plugins/sqldrivers", # DB 안 쓰면 삭제 + "lib/PySide6/plugins/multimedia", # 오디오/비디오 안 쓰면 삭제 + "lib/PySide6/plugins/positioning", # GPS 안 쓰면 삭제 + "lib/PySide6/plugins/sensors", # 센서 안 쓰면 삭제 + "lib/PySide6/plugins/texttospeech", # TTS 안 쓰면 삭제 + "lib/PySide6/plugins/webview", # WebView 안 쓰면 삭제 (중요) + + # 3. Qt Quick / QML 관련 (위젯 기반 앱이면 필요 없음) + "lib/PySide6/qml", + "lib/PySide6/Qt/qml", + + # 4. 개발용/디자이너용 도구 (배포 시 불필요) + "lib/PySide6/designer", + "lib/PySide6/scripts", + "lib/PySide6/examples", + "lib/PySide6/glue", + "lib/PySide6/include", + + # 5. 대용량 DLL (사용 여부 확인 필요) + # OpenGL 소프트웨어 렌더러 (그래픽 카드 없는 PC용, 보통 없어도 됨) + "lib/PySide6/opengl32sw.dll", + # QtWebEngine (크롬 브라우저 내장). 만약 Selenium/Playwright만 쓰고 + # Qt 위젯 내에서 브라우저를 띄우지 않는다면 지워도 됨 (엄청 큼!) + "lib/PySide6/Qt6WebEngineCore.dll", + "lib/PySide6/Qt6WebEngineCore.pyd", + "lib/PySide6/Qt6WebEngineWidgets.dll", + +] + +# 3. 소스 패키징에서 강제로 제외할 패키지들 +BASE_EXCLUDES = [ + 'tkinter', 'PyQt4', 'PyQt5', 'AppKit', 'Foundation', 'IPython', + 'OpenSSL', 'curses', 'test', 'matplotlib', 'asyncpg', + 'importlib._bootstrap', 'importlib.machinery', + 'pytest', 'hypothesis', 'mypy', 'coverage', 'tox', + 'sympy', 'mpmath', 'gmpy2', + 'paddle', 'paddleocr', 'paddlehub', 'onnxruntime', 'onnx', + 'skimage', 'scikit-image', 'pyclipper', 'shapely', + 'scipy', 'imgaug', 'albumentations', 'torch', 'tensorflow', 'keras', + 'src.modules.image_processor3', 'src.modules.image_processor4', + 'src.modules.image_worker', 'src.modules.image_worker_manager', + 'src.modules.ocr_module', 'src.modules.mask_module_for_paddle', + 'src.modules.text_rendering_module', 'src.modules.postImageManager', + 'src.modules.request_inpaint', 'src.modules.migan_module', + 'src.modules.background_removal_module', 'src.modules.bria_background_removal_module', + 'src.modules.gemma_client', 'src.modules.onnx_ocr_module', +] + +# 4. 강제 포함 패키지 +BASE_INCLUDES = [ + 'browser_control', + 'loggerModule', 'toggleSwitch', + 'src.cmdDiag', 'src.inputDiag', 'src.keyword', 'src.priceSetDiag', + # 'src.titleManager', + # 'src.titleManager.naver_parser', 'src.titleManager.naverAPI', 'src.titleManager.gpt_client', 'src.titleManager.grok_client', + # 'src.translator', + # 'src.translator.chinese_dict_manager', 'src.translator.papago_translator', + 'src.discord_manager', 'src.unwantedDiag', 'src.unwantedDiag.unwanted_words_dialog', + 'src.logDialog', 'src.logDialog.log_dialog', 'src.logDialog.log_filter', + 'src.modules.settings_manager', + 'src.modules.gpu_status_checker', 'src.modules.gpu_utils', 'src.gpuDiag', + # 'src.modules.image_worker_client', 'src.img_module.image_processor_manager', 'src.img_module.image_processor_dialog', + 'src.modules.fonts.fontSelectDialog', + # 'src.lens.naver_lens_client', 'src.lens.naver_lens_parser', 'src.lens.naver_lens_adapter', 'src.lens.aliprice_lens_client', + 'translatepy', 'translatepy.translators', 'translatepy.translators.google', + 'PIL', 'PIL.Image', 'PIL.ImageOps', 'PIL.ImageEnhance', 'PIL.ImageFilter', 'PIL.features', 'cv2', + 'numpy', 'numpy.core', 'numpy.random', + 'supabase', 'gotrue', 'storage3', 'postgrest', 'supafunc', 'realtime', + 'pydantic', 'pydantic_core', + 'json', 'json.encoder', 'json.decoder', 'json.scanner', + 'httpx', 'httpx.__version__', 'httpx._models', 'httpx._client', 'httpx._config', + 'curl_cffi', 'curl_cffi.requests', + 'pathlib', + 'shiboken6', + 'greenlet', + # 'playwright','playwright.async_api', 'playwright._impl', + 'PySide6.QtCore', 'PySide6.QtGui', 'PySide6.QtWidgets', 'PySide6.QtNetwork', + 'requests', + 'pandas', + 'sqlite3', + 'packaging', + 'markdown', + 'pyperclip', + 'psutil', + 'comtypes', + 'comtypes.stream', + 'win32com', + 'win32com.client', + 'win32com.server', + 'pythoncom', +] + + +# ============================================================================ +# [Helper Functions] 로직 분리 +# ============================================================================ + +def run_setup_clean(): + """ + 기존 빌드찌꺼기 제거 + """ + print("\n>>> [Cleaner] 기존 빌드찌꺼기 제거 시작...") + subprocess.run(["python", "setup_clean.py"]) + print(">>> [Cleaner] 기존 빌드찌꺼기 제거 완료!\n") + + +def run_cython_build(): + """ + setup_cython.py를 별도로 실행하지 않고, + 여기서 직접 Cython 빌드를 수행합니다. (경로 꼬임 방지) + """ + print("\n>>> [Cython] 내부 빌드 프로세스 시작...") + + extensions = [] + + # 전역변수 CYTHON_MODULES 리스트를 사용 + for file_path in CYTHON_MODULES: + # 파일 확인 (.py가 없는 경우 붙여서 확인) + source_file = file_path + if not os.path.exists(source_file): + if os.path.exists(source_file + ".py"): + source_file += ".py" + else: + print(f" [Warning] 컴파일 대상 파일을 찾을 수 없음: {file_path}") + continue + + # 모듈 이름 생성 (경로 -> 점 표기법) + # 예: src/contents/option -> src.contents.option + # 이렇게 해야 'src' 패키지 안의 모듈로 정확히 인식됩니다. + no_ext = os.path.splitext(source_file)[0] + module_name = no_ext.replace("/", ".").replace("\\", ".") + + # Extension 객체 생성 + ext = Extension( + name=module_name, + sources=[source_file] + ) + extensions.append(ext) + + if not extensions: + print(">>> [Cython] 컴파일할 대상이 없습니다.") + return + + # setuptools의 setup을 직접 호출 (인자값으로 build_ext --inplace 전달) + try: + cy_setup( + name="CythonInternalBuild", + ext_modules=cythonize( + extensions, + compiler_directives={'language_level': "3"}, + quiet=True + ), + script_args=['build_ext', '--inplace'] + ) + print(">>> [Cython] 빌드 성공!\n") + except Exception as e: + print(f"\n>>> [Cython] 빌드 중 오류 발생: {e}") + sys.exit(1) + +def get_cython_freeze_config(modules_list): + """ + Cython 모듈 리스트를 기반으로 cx_Freeze용 설정을 생성합니다. + Returns: + (excludes_list, include_files_list, include_packages_to_remove) + """ + excludes = [] # .py 소스 제외용 + include_files = [] # .pyd 파일 포함용 + module_names = set() + + for module_path in modules_list: + # 모듈 이름 변환 (src/contents/price -> src.contents.price) + clean_path = os.path.splitext(module_path)[0] + module_name = clean_path.replace("/", ".").replace("\\", ".") + module_names.add(module_name) + + excludes.append(module_name) + + # .pyd 파일 찾기 및 매핑 + dir_name = os.path.dirname(module_path) + base_name = os.path.basename(module_path) + pyd_pattern = os.path.join(dir_name, f"{base_name}*.pyd") + found_pyds = glob.glob(pyd_pattern) + + if found_pyds: + src_pyd = found_pyds[0] + # 라이브러리 구조 유지: lib/src/... + dest_pyd = os.path.join("lib", dir_name, f"{base_name}.pyd") + include_files.append((src_pyd, dest_pyd)) + print(f" [Protect] {module_name}: .py 제외, .pyd 포함") + else: + print(f" [Warning] .pyd 없음: {module_path}. (원본 .py가 포함될 수 있음)") + + return excludes, include_files, module_names + +def collect_include_files(): + """DLL, 리소스 파일 등 기타 include_files 리스트를 생성합니다.""" + base_dir = os.path.dirname(__file__) + updater_file = os.path.join(base_dir, 'updateManager', 'updater.exe') + + # 기본 리소스 파일들 + files = [ + ('src/Edit_PartTimer3.ico', 'lib/src/Edit_PartTimer3.ico'), + ('kiprisCategories.json', 'kiprisCategories.json'), + ('src/keyword/kiprisCategories.json', 'lib/src/keyword/kiprisCategories.json'), + ('src/modules/fonts', 'lib/src/modules/fonts'), + (updater_file, 'updater.exe'), + ('퍼센티 다양한 카테고리 엑셀 수집(스스 기준).xlsx', '퍼센티 다양한 카테고리 엑셀 수집(스스 기준).xlsx'), + ('src/Percenty_SS_Code.json', 'lib/src/Percenty_SS_Code.json'), + ('src/browsers/chromium-1200', 'lib/src/browsers/chromium-1200'), + ('src/browsers/extensions', 'lib/src/browsers/extensions'), + ('C:/Windows/System32/vcomp140.dll', 'vcomp140.dll'), + ] + + # VC Runtime Files + vc_runtimes = [ + ('C:/Windows/System32/vcruntime140.dll', 'vcruntime140.dll'), + ('C:/Windows/System32/vcruntime140_1.dll', 'vcruntime140_1.dll'), + ('C:/Windows/System32/msvcp140.dll', 'msvcp140.dll'), + ('C:/Windows/System32/msvcp140_1.dll', 'msvcp140_1.dll'), + ('C:/Windows/System32/msvcp140_2.dll', 'msvcp140_2.dll'), + ('C:/Windows/System32/concrt140.dll', 'concrt140.dll'), + ('C:/Windows/System32/vcomp140.dll', 'vcomp140.dll'), + ] + files.extend(vc_runtimes) + + dll_files = [ + # "LIBPQ.dll", + # "MIMAPI64.dll", + # "Qt63DQuickScene3D.dll", + "api-ms-win-core-com-l1-1-0.dll", + "api-ms-win-core-debug-l1-1-0.dll", + "api-ms-win-core-errorhandling-l1-1-0.dll", + "api-ms-win-core-handle-l1-1-0.dll", + "api-ms-win-core-heap-l1-1-0.dll", + # "api-ms-win-core-heap-l2-1-0.dll", + "api-ms-win-core-interlocked-l1-1-0.dll", + # "api-ms-win-core-libraryloader-l1-2-0.dll", + # "api-ms-win-core-libraryloader-l1-2-1.dll", + "api-ms-win-core-localization-l1-2-0.dll", + # "api-ms-win-core-path-l1-1-0.dll", + "api-ms-win-core-processthreads-l1-1-0.dll", + "api-ms-win-core-processthreads-l1-1-1.dll", + "api-ms-win-core-profile-l1-1-0.dll", + # "api-ms-win-core-realtime-l1-1-1.dll", + "api-ms-win-core-rtlsupport-l1-1-0.dll", + "api-ms-win-core-synch-l1-1-0.dll", + "api-ms-win-core-synch-l1-2-0.dll", + "api-ms-win-core-sysinfo-l1-1-0.dll", + # "api-ms-win-core-winrt-error-l1-1-0.dll", + # "api-ms-win-core-winrt-l1-1-0.dll", + # "api-ms-win-core-winrt-string-l1-1-0.dll", + "api-ms-win-crt-conio-l1-1-0.dll", + "api-ms-win-crt-environment-l1-1-0.dll", + "api-ms-win-crt-filesystem-l1-1-0.dll", + "api-ms-win-crt-multibyte-l1-1-0.dll", + "api-ms-win-crt-private-l1-1-0.dll", + "api-ms-win-crt-process-l1-1-0.dll", + "api-ms-win-crt-time-l1-1-0.dll", + "api-ms-win-crt-utility-l1-1-0.dll", + # "api-ms-win-power-base-l1-1-0.dll", + # "api-ms-win-power-setting-l1-1-0.dll", + # "api-ms-win-shcore-scaling-l1-1-1.dll", + ] + + # DLL 파일 처리 + system32_path = "C:/Windows/System32/downlevel" + dll_include_files = [(os.path.join(system32_path, dll), dll) for dll in dll_files] + files.extend(dll_include_files) + + # 경로 존재 확인 + final_files = [] + for src, dest in files: + if os.path.exists(src): + final_files.append((src, dest)) + else: + print(f" [Error] 경로 없음(Skip): {src}") + + return final_files + +# ============================================================================ +# [Main Logic] 실행 로직 +# ============================================================================ + +# 0. 기존 빌드찌꺼기 제거 + +run_setup_clean() + +# 1. Cython 빌드 실행 +run_cython_build() + +# 2. cx_Freeze 설정 준비 +cy_excludes, cy_include_files, cy_module_names = get_cython_freeze_config(CYTHON_MODULES) +resource_include_files = collect_include_files() + +# 3. 최종 옵션 조합 +final_includes = [mod for mod in BASE_INCLUDES if mod not in cy_module_names] # 충돌 방지 +final_excludes = BASE_EXCLUDES + cy_excludes +final_include_files = resource_include_files + cy_include_files + +build_options = { + 'packages': [ + 'ctypes', 'asyncio', 'subprocess', 'pyperclip', 'numpy', + 'requests', 'PIL', 'bs4', 'psutil', + 'openai', + 'pandas', 'supabase', 'translatepy', 'markdown', + 'json', 'json.encoder', 'json.decoder', 'json.scanner', + 'playwright', + # 'PySide6', + ], + 'includes': final_includes, + 'excludes': final_excludes, + 'include_files': final_include_files, + 'zip_include_packages': [], + 'optimize': 0, + 'silent': True, + 'include_msvcr': True, +} + +# ============================================================================ +# [Custom Build Class] 빌드 프로세스 커스터마이징 +# ============================================================================ + +class CustomBuildExe(_build_exe): + def run(self): + # 전체 진행률: 100 + # 초기값 10: Cython 빌드는 이 클래스 실행 전(if __name__...)에 이미 완료됨 + print("\n" + "="*60) + print(" AutoPercenty3 통합 빌드 시스템 시작") + print("="*60 + "\n") + try: + # 총 6단계로 구성 (Cython은 이미 완료됨 -> 10%) + with tqdm(total=100, initial=10, unit="pct", + bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}% [{elapsed}]", + ncols=80, colour='green') as pbar: + + # [Step 2] cx_Freeze 빌드 (10 -> 30%) + pbar.set_description("Step 2/6: cx_Freeze Packaging") + _build_exe.run(self) + pbar.update(20) + + + # [Step 3] 빌드 결과물 정리 (30 -> 35%) + pbar.set_description("Step 3/6: Cleaning Build Output") + self._cleanup_build_output() + pbar.update(5) + + # [Step 4] Inno Setup 컴파일 (35 -> 70%) + pbar.set_description("Step 4/6: Inno Setup Compiling") + self._run_inno_setup() # .iss 생성 + self._compile_inno_installer() # .exe 생성 + pbar.update(35) + + + # [Step 5] 파일명 변경 (버전 정보 추가) (70 -> 75%) + pbar.set_description("Step 5/6: Renaming Installer") + final_installer_path = self._rename_installer_with_version() + pbar.update(5) + + # [Step 6] Gokapi 업로드 (75 -> 95%) + if final_installer_path and GOKAPI_URL != "https://gokapi.your-domain.com": + pbar.set_description("Step 6/6: Uploading to Gokapi") + self._upload_to_gokapi(final_installer_path) + else: + print("\n[Skip] Gokapi 설정이 없거나 파일이 없어 업로드를 건너뜁니다.") + pbar.update(20) + + # [Final] 소스 정리 (95 -> 100%) + pbar.set_description("Finalizing: Cleaning Source") + self._cleanup_cython_artifacts() + pbar.update(5) + + pbar.set_description("Build Complete!") + + except KeyboardInterrupt: + print("\n\n>>> 빌드가 취소되었습니다.") + sys.exit(1) + except Exception as e: + print(f"\n\n>>> 빌드 중 치명적인 오류 발생: {e}") + # 에러 상세 내용을 보기 위해 traceback 출력 + import traceback + traceback.print_exc() + sys.exit(1) + + def _get_dir_size(self, path): + total = 0 + for dirpath, _, filenames in os.walk(path): + for f in filenames: + total += os.path.getsize(os.path.join(dirpath, f)) + return total + + def _rename_installer_with_version(self): + """생성된 설치 파일 이름에 버전을 추가합니다.""" + # Inno Setup의 기본 출력 경로 (dist/installer) + dist_dir = os.path.join(os.path.dirname(__file__), "dist", "installer") + + # 원래 생성되는 파일명 (generate_iss.py 설정에 따름, 보통 Setup.exe) + # 로그에 찍힌 이름을 기준으로 찾습니다. + original_name = "Edit_PartTimer Setup.exe" + original_path = os.path.join(dist_dir, original_name) + + if not os.path.exists(original_path): + print(f"\n[Error] 원본 설치 파일을 찾을 수 없습니다: {original_path}") + # 혹시 다른 이름일 수도 있으니 exe 파일을 검색해봅니다. + exe_files = glob.glob(os.path.join(dist_dir, "*.exe")) + if exe_files: + original_path = max(exe_files, key=os.path.getctime) # 가장 최신 파일 + else: + return None + + # 새 파일명: Edit_PartTimer Setup_V3.12.15.exe + new_name = f"Edit_PartTimer Setup_V{__version__}.exe" + new_path = os.path.join(dist_dir, new_name) + + try: + # 기존에 같은 버전 파일이 있으면 삭제 + if os.path.exists(new_path): + os.remove(new_path) + + os.rename(original_path, new_path) + print(f"\n[Rename] 파일명이 변경되었습니다:\n -> {new_name}") + return new_path + except Exception as e: + print(f"\n[Error] 파일명 변경 실패: {e}") + return original_path + + def _upload_to_gokapi(self, file_path): + """Gokapi 서버로 파일을 업로드합니다.""" + print("\n[Upload] Gokapi 서버로 업로드를 시작합니다...") + + if not os.path.exists(file_path): + print(" [Error] 업로드할 파일이 없습니다.") + return + + try: + url = f"{GOKAPI_URL}/api/v1/upload" + headers = { + "Authorization": f"Bearer {GOKAPI_APIKEY}" + } + + + with open(file_path, "rb") as f: + # 멀티파트 업로드 + files = {"file": (os.path.basename(file_path), f)} + data = { + "expire": 0 # ✅ 영구 저장 + } # 만료일 설정 (예: 0=무제한, 7d=7일) - 필요시 data={'expiry': '7d'} 추가 + + response = requests.post( + url, + headers=headers, + files=files, + data=data, + timeout=30 + ) + + if response.status_code in (200, 201): + data = response.json() + + # Gokapi 응답 구조 + hotlink = data.get("DownloadUrl") or data.get("File", {}).get("Url") + + print("\n" + "#" * 50) + print("업로드 성공!") + print(f"다운로드 링크: {hotlink}") + print("#" * 50 + "\n") + else: + print(f"\n[Error] 업로드 실패 (Status: {response.status_code})") + print("Server Response:", response.text) + + except Exception as e: + print(f"\n[Error] 업로드 중 예외 발생: {e}") + + def _cleanup_build_output(self): + """빌드된 exe 폴더 내부의 불필요한 파일 삭제""" + print("\n[Cleaner] 빌드 결과물 정리 중...") + build_dir = os.path.join(os.path.dirname(__file__), "build") + + if not os.path.exists(build_dir): return + + removed_count = 0 + total_saved = 0 + + for item in os.listdir(build_dir): + if not item.startswith("exe."): continue + + exe_dir = os.path.join(build_dir, item) + for unnecessary in CLEANUP_TARGETS: + target_path = os.path.join(exe_dir, unnecessary) + try: + if os.path.isdir(target_path): + size = self._get_dir_size(target_path) + shutil.rmtree(target_path) + total_saved += size + print(f" ✓ 디렉토리 삭제: {unnecessary}") + elif os.path.isfile(target_path): + size = os.path.getsize(target_path) + os.remove(target_path) + total_saved += size + print(f" ✓ 파일 삭제: {unnecessary}") + removed_count += 1 + except Exception: + pass # 없는 파일은 무시 + + print(f"[Cleaner] 정리 완료: {total_saved / (1024*1024):.1f} MB 절약\n") + + def _cleanup_cython_artifacts(self): + """소스 폴더의 .pyd, .c 임시 파일 삭제""" + print("[Cleaner] 소스 폴더 Cython 임시 파일 정리 중...") + deleted = 0 + for module_path in CYTHON_MODULES: + dir_name = os.path.dirname(module_path) + base_name = os.path.basename(module_path) + patterns = [ + os.path.join(dir_name, f"{base_name}*.pyd"), + os.path.join(dir_name, f"{base_name}.c") + ] + for pattern in patterns: + for f in glob.glob(pattern): + try: + os.remove(f) + deleted += 1 + except Exception: pass + print(f"[Cleaner] 소스 정리 완료: {deleted}개 파일 삭제\n") + + def _run_inno_setup(self): + """Inno Setup 스크립트 생성기 실행""" + print("[Inno Setup] 설치 스크립트 생성 시작...") + try: + result = subprocess.run([sys.executable, "generate_iss.py"], capture_output=True, text=True) + if result.returncode == 0: + print("Inno Setup 스크립트 생성 완료!") + else: + print(f"Error: {result.stderr}") + except Exception as e: + print(f"Exception: {e}") + + def _compile_inno_installer(self): + """ + 생성된 .iss 파일을 ISCC.exe로 컴파일하여 최종 Setup.exe를 만듭니다. + """ + print("\n[Inno Setup] 최종 설치 파일(Setup.exe) 컴파일 시작...") + + # 1. ISCC.exe 경로 설정 (Inno Setup 6 기준 기본 경로) + # 만약 설치 경로가 다르다면 이 부분을 수정해주세요. + iscc_path = r"C:\Program Files (x86)\Inno Setup 6\ISCC.exe" + + if not os.path.exists(iscc_path): + print(f" [Error] Inno Setup 컴파일러를 찾을 수 없습니다: {iscc_path}") + print(" Inno Setup 6가 설치되어 있는지 확인하거나, iscc_path를 수정하세요.") + return + + # 2. 가장 최신 .iss 파일 찾기 (AutoPercenty_날짜.iss 패턴) + # generate_iss.py가 매번 새로운 이름으로 만들기 때문에 최신 파일을 찾아야 함 + iss_files = glob.glob("AutoPercenty_*.iss") + if not iss_files: + print(" [Error] 컴파일할 .iss 파일을 찾을 수 없습니다.") + return + + # 파일 생성 시간 기준으로 정렬하여 가장 마지막(최신) 파일 선택 + latest_iss = max(iss_files, key=os.path.getctime) + print(f" Target Script: {latest_iss}") + + # 3. 컴파일 명령어 실행 + try: + # subprocess로 ISCC 실행 + print(" Compiling... (시간이 조금 걸릴 수 있습니다)") + subprocess.run([iscc_path, latest_iss], check=True) + print(" [Success] ★★★ 모든 작업 완료! 설치 파일이 생성되었습니다. ★★★\n") + except subprocess.CalledProcessError as e: + print(f" [Error] Inno Setup 컴파일 실패: {e}") + +# ============================================================================ +# [Setup] 최종 실행 +# ============================================================================ + +base = 'Win32GUI' if sys.platform == 'win32' else None + +setup( + name=__title__, + version=__version__, + description=__description__, + author=__author__, + author_email=__author_email__, + license=__license__, + packages=find_packages(), + install_requires=__install_requires__, + python_requires='>=3.11', + include_package_data=True, + zip_safe=False, + options={'build_exe': build_options}, + executables=[ + Executable( + 'main.py', + base=base, + target_name='Edit_PartTimer3.exe', + icon="Edit_PartTimer3.ico" + ) + ], + cmdclass={ + "build_exe": CustomBuildExe, + }, +) \ No newline at end of file diff --git a/updater/__pycache__/__init__.cpython-311.pyc b/updater/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..2ae240b Binary files /dev/null and b/updater/__pycache__/__init__.cpython-311.pyc differ diff --git a/updater/__pycache__/__version__.cpython-311.pyc b/updater/__pycache__/__version__.cpython-311.pyc new file mode 100644 index 0000000..1ddb33f Binary files /dev/null and b/updater/__pycache__/__version__.cpython-311.pyc differ diff --git a/updater/__version__.py b/updater/__version__.py index 1794957..c791999 100644 --- a/updater/__version__.py +++ b/updater/__version__.py @@ -1,2 +1,13 @@ -__version__ = "1.3.0" +__version__ = "1.3.6" + +__title__ = "ImgWorker" +__description__ = "Image Worker" +__author__ = "WhenRideMyCar" +__author_email__ = "kkebiini@gmail.com" +__license__ = "MIT" +__install_requires__ = [ + "fastapi", + "uvicorn", + "pydantic", +] diff --git a/updater/update_Log.MD b/updater/update_Log.MD index 3fbb4b0..fd7801d 100644 --- a/updater/update_Log.MD +++ b/updater/update_Log.MD @@ -1,3 +1,17 @@ +###1.3.5 ChangeLog + - MIGAN 모델 경로를 내부 고정 경로로 변경 (toggle_states 의존성 제거) + - MIGAN 초기화 실패 시 OpenCV(Telea) 인페인팅으로 자동 폴백 + - 인페인팅 폴백 로직 강화 (다양한 마스크 형태 지원) + - 워커 재시작 전까지 안정적인 CV 모드 유지 + - Windows 로그 파일 롤링 문제 해결 (10MB 초과 시 0KB 되는 문제 수정) + +###1.3.4 ChangeLog + - 병렬 작업 처리(Concurrency) 개선 및 안정화 + - DirectML(GPU) 환경 교착상태(Deadlock) 해결을 위한 스마트 락(Lock) 적용 + - CPU 모드 시 병렬 처리 허용 및 점유율 최적화 + - 외부 인페인팅 서버 헬스 체크 기능 추가 + - 로그 파일 교착 상태 방지를 위한 프로세스별 로그 분리(PID 적용) + ###1.3.0 ChangeLog - 서버코드정리 - 메모리관리 최적화 diff --git a/user_logs/1.log b/user_logs/1.log new file mode 100644 index 0000000..a4d28cb --- /dev/null +++ b/user_logs/1.log @@ -0,0 +1,1220 @@ +[2026-03-02 20:46:43,629] [MainThread] [INFO] [loggerModule.py:info:455] API 서버 시작 +[2026-03-02 20:46:43,643] [MainThread] [INFO] [loggerModule.py:info:455] 워커 프로세스 기동: PID=6696 +[2026-03-02 20:46:44,691] [LogListener] [DEBUG] [loggerModule.py:debug:449] ImageWorker 프로세스 기동 (PID=6696, Name=ImageWorkerProcess) +[2026-03-02 20:46:44,725] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔧 ImageProcessor3 초기화 시작... +[2026-03-02 20:46:44,725] [LogListener] [DEBUG] [loggerModule.py:debug:449] tracemalloc 메모리 추적 시작 +[2026-03-02 20:46:44,764] [LogListener] [DEBUG] [loggerModule.py:debug:449] ✅ DirectML 환경 준비 완료 (Windows DirectX 12 기반) +[2026-03-02 20:46:44,765] [LogListener] [DEBUG] [loggerModule.py:debug:449] === 🚀 DirectML GPU 상태 초기화 시작 🚀 === +[2026-03-02 20:46:44,765] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🎯 사용자 GPU 가속 요청: False +[2026-03-02 20:46:44,765] [LogListener] [DEBUG] [loggerModule.py:debug:449] 💻 현재 운영체제: Windows +[2026-03-02 20:46:44,765] [LogListener] [DEBUG] [loggerModule.py:debug:449] GPU 가속이 비활성화됨 (toggle_states['use_cuda'] = False) +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔒 안전한 CPU 모드로 모든 GPU 설정 강제 비활성화 +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔧 ImageProcessor3 GPU 상태 요약: +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] - CUDA 사용 가능: False +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] - toggle_states['use_cuda']: NOT_SET +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] - GPU 하드웨어 정보: {} +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] ImageProcessor3 Init toggle_states: {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': True, 'local_rembg_model_path': 'C:\\Program Files\\ImgWorker\\lib\\modules\\rembg_models', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\ImgWorker\\lib\\modules\\migan_onnx\\migan_pipeline_v2.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto'} +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: False +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] debug_images 디렉토리 이미 존재: C:\Program Files\ImgWorker\lib\modules\debug_images +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] self.font_path: C:\Program Files\ImgWorker\lib\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2026-03-02 20:46:44,766] [LogListener] [DEBUG] [loggerModule.py:debug:449] toggle_states font_path: C:\Program Files\ImgWorker\lib\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] self.TEMP_IMAGE_DIR: C:\ProgramData\ImgWorker\work +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] self.debugging_save_Dir: C:\Program Files\ImgWorker\lib\modules\debug_images +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] self.unwanted_texts: {} +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] self.inpaint_method: migan +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] Image.MAX_IMAGE_PIXELS set to 20000000 +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] ONNX 모델 타입 설정값: 자동 선택, GPU 정보: {} +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] 자동 선택 모드: GPU 추천 모델 simp 사용 +[2026-03-02 20:46:44,767] [LogListener] [DEBUG] [loggerModule.py:debug:449] ONNX OCR 모델 타입 결정: simp (GPU: False) +[2026-03-02 20:46:44,769] [LogListener] [DEBUG] [loggerModule.py:debug:449] ONNX OCR 모듈 CPU 모드로 설정 +[2026-03-02 20:46:44,769] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2026-03-02 20:46:44,769] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 ONNX TextSystem 초기화 시작 (CPU 모드) +[2026-03-02 20:46:47,696] [LogListener] [DEBUG] [loggerModule.py:debug:449] 문자 사전 파일 UTF-8 확인 완료: C:\Program Files\ImgWorker\lib\modules\onnx_ocr_module\dict\ppocr_keys_v1.txt +[2026-03-02 20:46:47,873] [LogListener] [DEBUG] [loggerModule.py:debug:449] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP (호환성) 모델) +[2026-03-02 20:46:47,873] [LogListener] [DEBUG] [loggerModule.py:debug:449] ✅ ONNX TextSystem 초기화 완료 (CPU + SIMP 모델) +[2026-03-02 20:46:47,874] [LogListener] [DEBUG] [loggerModule.py:debug:449] ✅ ONNX OCR 모듈 초기화 성공 (CPU 모드) +[2026-03-02 20:46:47,875] [LogListener] [DEBUG] [loggerModule.py:debug:449] ✅ ONNX OCR 모듈 초기화 성공 +[2026-03-02 20:46:47,875] [LogListener] [DEBUG] [loggerModule.py:debug:449] gemma_api_base_url: http://192.168.0.146:8008 +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] GemmaTranslator 연결: base=http://192.168.0.146:8008 +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 모듈 초기화 완료 +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] MaskModule 초기화 성공 +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 모듈 초기화 완료 +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] 기본 폰트: C:\Program Files\ImgWorker\lib\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] TextRenderingModule 초기화 성공 +[2026-03-02 20:46:47,876] [LogListener] [DEBUG] [loggerModule.py:debug:449] 폰트 로드 성공: C:\Program Files\ImgWorker\lib\modules\fonts\HakgyoansimDunggeunmisoTTFB.ttf +[2026-03-02 20:46:47,877] [LogListener] [DEBUG] [loggerModule.py:debug:449] PostImageManager 초기화 성공 +[2026-03-02 20:46:47,877] [LogListener] [DEBUG] [loggerModule.py:debug:449] Request_AI_Server GPU 상태: CUDA 사용 가능=False +[2026-03-02 20:46:47,877] [LogListener] [DEBUG] [loggerModule.py:debug:449] Request_AI_Server 초기화 성공 +[2026-03-02 20:46:47,877] [LogListener] [DEBUG] [loggerModule.py:debug:449] GoogleTranslate 초기화 성공 +[2026-03-02 20:46:47,878] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 모델 경로 확인: C:\Program Files\ImgWorker\lib\modules\migan_onnx\migan_pipeline_v2_simplified.onnx +[2026-03-02 20:46:47,878] [LogListener] [DEBUG] [loggerModule.py:debug:449] MIGAN CUDA 사용 불가 - CPU 모드로 설정 +[2026-03-02 20:46:47,878] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] GPU 관리자 전달: GPUManager, can_use_cuda: False +[2026-03-02 20:46:47,913] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] GPU 관리자 사용 가능: False +[2026-03-02 20:46:48,142] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 사용 가능한 providers: ['DmlExecutionProvider', 'CPUExecutionProvider'] +[2026-03-02 20:46:48,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] DirectML 가속 활성화 +[2026-03-02 20:46:48,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 최종 providers: [('DmlExecutionProvider', {}), ('CPUExecutionProvider', {})] +[2026-03-02 20:46:48,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] DirectML 가속 시도: [('DmlExecutionProvider', {}), ('CPUExecutionProvider', {})] +[2026-03-02 20:46:48,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] DirectML 가속 성공! 실제 providers: ['DmlExecutionProvider', 'CPUExecutionProvider'] +[2026-03-02 20:46:48,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 입력 0: image, 형태: ['batch_size', 3, 'height', 'width'], 타입: tensor(uint8) +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 입력 1: mask, 형태: ['batch_size', 1, 'height', 'width'], 타입: tensor(uint8) +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 출력 0: result, 형태: ['ScatterNDresult_dim_0', 3, 'ScatterNDresult_dim_2', 'ScatterNDresult_dim_3'], 타입: tensor(uint8) +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 세션 준비 완료. providers=['DmlExecutionProvider', 'CPUExecutionProvider'] +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] GPU 관리자 연결 완료: GPUManager +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 파이프라인 gpu_manager 속성: True, 값: +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [MIGAN] 초기화 완료: gpu_manager 속성=True, 값= +[2026-03-02 20:46:48,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔰 OCR 모듈 Warm-up 시작... +[2026-03-02 20:46:48,148] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:46:48,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 9.0ms +[2026-03-02 20:46:48,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 7.0ms, 인식: 0.0ms, 분류: 0.0ms +[2026-03-02 20:46:48,158] [LogListener] [WARNING] [loggerModule.py:warning:461] ⚠️ ONNX OCR 결과가 비어있습니다 +[2026-03-02 20:46:48,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] ✅ OCR 모듈 Warm-up 성공 +[2026-03-02 20:46:48,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔰 ImageProcessor Warm‑up 완료 +[2026-03-02 20:46:48,165] [ResultListener] [INFO] [loggerModule.py:info:455] 워커 READY 수신 +[2026-03-02 20:46:48,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] 워커 READY 신호 전송 +[2026-03-02 20:46:48,166] [ResultListener] [INFO] [loggerModule.py:info:455] 워커 READY 수신 +[2026-03-02 20:46:48,166] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📡 추가 READY 신호 전송 완료 +[2026-03-02 20:46:48,167] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 Async Worker Loop 시작 +[2026-03-02 20:46:48,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=__PING__, uid=0aebc2db-3db9-4201-b052-ad08d1a75b92 +[2026-03-02 20:46:48,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=__PING__ +[2026-03-02 20:46:48,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=0aebc2db-3db9-4201-b052-ad08d1a75b92 +[2026-03-02 20:46:48,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=0aebc2db-3db9-4201-b052-ad08d1a75b92 +[2026-03-02 20:46:48,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] 대기 중(유휴) +[2026-03-02 20:48:28,313] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=update_toggle_states, uid=1ec9b56c-71ce-415e-8f15-70db5d40b030 +[2026-03-02 20:48:28,316] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 모듈 초기화 완료 +[2026-03-02 20:48:28,316] [LogListener] [DEBUG] [loggerModule.py:debug:449] 기본 폰트: C:\Program Files\ImgWorker\lib\modules\fonts\NanumBarunGothic.ttf +[2026-03-02 20:48:28,316] [LogListener] [DEBUG] [loggerModule.py:debug:449] 폰트 변경으로 텍스트 렌더링 모듈 재생성: C:\Program Files\ImgWorker\lib\modules\fonts\NanumBarunGothic.ttf +[2026-03-02 20:48:28,317] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\ImgWorker\\lib\\modules\\fonts\\NanumBarunGothic.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중'} +[2026-03-02 20:48:28,317] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:48:28,317] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=update_toggle_states +[2026-03-02 20:48:28,317] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=1ec9b56c-71ce-415e-8f15-70db5d40b030 +[2026-03-02 20:48:28,317] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=1ec9b56c-71ce-415e-8f15-70db5d40b030 +[2026-03-02 20:48:46,535] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=remove_background, uid=bacb9a26-96ec-4f06-9178-bd9ea9f2214b +[2026-03-02 20:48:46,539] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중'} +[2026-03-02 20:48:46,539] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:48:46,539] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=remove_background +[2026-03-02 20:48:46,539] [LogListener] [DEBUG] [loggerModule.py:debug:449] remove_background 호출 직전 +[2026-03-02 20:48:46,539] [LogListener] [DEBUG] [loggerModule.py:debug:449] request_rembg 호출: use_local_rembg=False, local_model_name=birefnet-general-lite +[2026-03-02 20:48:46,542] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔧 백업 rembg 시작: model_name=birefnet-general-lite, object_ratio=0.95, debug_save=True, force_cpu=False +[2026-03-02 20:48:46,543] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📁 디버그 이미지 저장 디렉토리: C:\Users\컴퓨터\AppData\Local\Temp\wrong_shape_rembg_debug_qhgxbzgy +[2026-03-02 20:48:46,543] [LogListener] [DEBUG] [loggerModule.py:debug:449] 💾 1단계 저장 완료: 입력 이미지 (600, 830, 3) → C:\Users\컴퓨터\AppData\Local\Temp\wrong_shape_rembg_debug_qhgxbzgy\01_input_image.png +[2026-03-02 20:48:46,543] [LogListener] [DEBUG] [loggerModule.py:debug:449] BriaAI 배경제거 모듈 초기화 시작 +[2026-03-02 20:48:46,544] [LogListener] [DEBUG] [loggerModule.py:debug:449] ONNX Runtime 사용 가능한 프로바이더: ['DmlExecutionProvider', 'CPUExecutionProvider'] +[2026-03-02 20:48:46,544] [LogListener] [DEBUG] [loggerModule.py:debug:449] BriaAI CPU 모드로 설정 +[2026-03-02 20:48:46,544] [LogListener] [DEBUG] [loggerModule.py:debug:449] BriaAI 배경제거 모듈 초기화 완료 +[2026-03-02 20:48:46,544] [LogListener] [DEBUG] [loggerModule.py:debug:449] 백업용 내장 rembg 모듈 초기화됨 +[2026-03-02 20:48:46,544] [LogListener] [WARNING] [loggerModule.py:warning:461] 지원하지 않는 모델명 (birefnet-general-lite). bria-rmbg-1.4로 대체 사용 +[2026-03-02 20:48:46,544] [LogListener] [ERROR] [loggerModule.py:error:467] 임시 이미지 파일 생성 실패 +[2026-03-02 20:48:46,545] [LogListener] [ERROR] [loggerModule.py:error:467] RemoveBG 실패 +[2026-03-02 20:48:46,545] [LogListener] [DEBUG] [loggerModule.py:debug:449] remove_background 호출 완료 +[2026-03-02 20:48:46,545] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=bacb9a26-96ec-4f06-9178-bd9ea9f2214b +[2026-03-02 20:48:46,546] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=bacb9a26-96ec-4f06-9178-bd9ea9f2214b +[2026-03-02 20:50:33,067] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=55bbca51-1d6c-4509-9c4e-99d63c335844 +[2026-03-02 20:50:33,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:33,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:33,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:33,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:33,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:33,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ 실행 중인 작업(1): 55bbca51-1d6c-4509-9c4e-99d63c335844(0.0s) +[2026-03-02 20:50:33,327] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=d25a3ed9-7edd-4496-bc07-3b991d9917ab +[2026-03-02 20:50:33,329] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:33,330] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:33,330] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:33,330] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:33,330] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:33,387] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 1 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_000_O1CN01cycCsb1FsjxfYsQ1n_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:33,387] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_000_O1CN01cycCsb1FsjxfYsQ1n_!!692310543.jpg +[2026-03-02 20:50:33,393] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 1 원본 크기: 750x1283 +[2026-03-02 20:50:33,407] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 1 가로 크기 조정: 750x1283 → 860x1471 +[2026-03-02 20:50:33,415] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 1 크기 조정 완료: 860x1471 +[2026-03-02 20:50:33,416] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 1 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_000_O1CN01cycCsb1FsjxfYsQ1n_!!692310543_resized.jpg +[2026-03-02 20:50:33,423] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:34,960] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 1530.7ms +[2026-03-02 20:50:34,961] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 250.0ms, 인식: 1229.7ms, 분류: 39.0ms +[2026-03-02 20:50:34,984] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 10802.1MB -> 11008.9MB (+206.8MB, +1.9%) - 이미지 1 +[2026-03-02 20:50:34,999] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '你的这些苦恼', 'confidence': 0.9820561408996582, 'polygon': [[264.0, 115.0], [596.0, 115.0], [596.0, 169.0], [264.0, 169.0]], 'bbox': (264, 115, 333, 55), 'method': 'polygon'}, {'text': '交给我来帮你解决', 'confidence': 0.9901595115661621, 'polygon': [[203.0, 215.0], [652.0, 215.0], [652.0, 262.0], [203.0, 262.0]], 'bbox': (203, 215, 450, 48), 'method': 'polygon'}, {'text': '不知道', 'confidence': 0.9998881220817566, 'polygon': [[110.0, 418.0], [211.0, 418.0], [211.0, 457.0], [110.0, 457.0]], 'bbox': (110, 418, 102, 40), 'method': 'polygon'}, {'text': '如何选电池型号？', 'confidence': 0.995311439037323, 'polygon': [[112.0, 461.0], [354.0, 458.0], [354.0, 495.0], [112.0, 498.0]], 'bbox': (112, 458, 243, 41), 'method': 'polygon'}, {'text': '专业客服解答您的各种问题', 'confidence': 0.9953719973564148, 'polygon': [[118.0, 535.0], [391.0, 535.0], [391.0, 561.0], [118.0, 561.0]], 'bbox': (118, 535, 274, 27), 'method': 'polygon'}, {'text': '笔记本电池', 'confidence': 0.9978134036064148, 'polygon': [[512.0, 654.0], [597.0, 654.0], [597.0, 680.0], [512.0, 680.0]], 'bbox': (512, 654, 86, 27), 'method': 'polygon'}, {'text': '不知道', 'confidence': 0.9998703002929688, 'polygon': [[113.0, 683.0], [209.0, 683.0], [209.0, 717.0], [113.0, 717.0]], 'bbox': (113, 683, 97, 35), 'method': 'polygon'}, {'text': '分期免息', 'confidence': 0.9991531372070312, 'polygon': [[485.0, 702.0], [542.0, 702.0], [542.0, 723.0], [485.0, 723.0]], 'bbox': (485, 702, 58, 22), 'method': 'polygon'}, {'text': '去哪家店铺购买好？', 'confidence': 0.9812180995941162, 'polygon': [[115.0, 726.0], [387.0, 726.0], [387.0, 758.0], [115.0, 758.0]], 'bbox': (115, 726, 273, 33), 'method': 'polygon'}, {'text': '专业售前售后帮助你选购', 'confidence': 0.9944560527801514, 'polygon': [[119.0, 795.0], [369.0, 795.0], [369.0, 821.0], [119.0, 821.0]], 'bbox': (119, 795, 251, 27), 'method': 'polygon'}, {'text': '不知道', 'confidence': 0.9998777508735657, 'polygon': [[112.0, 941.0], [212.0, 941.0], [212.0, 979.0], [112.0, 979.0]], 'bbox': (112, 941, 101, 39), 'method': 'polygon'}, {'text': '电池质量好不好？', 'confidence': 0.9637632369995117, 'polygon': [[116.0, 984.0], [354.0, 984.0], [354.0, 1016.0], [116.0, 1016.0]], 'bbox': (116, 984, 239, 33), 'method': 'polygon'}, {'text': '大牌有保障高品质值得信赖', 'confidence': 0.9967874884605408, 'polygon': [[116.0, 1053.0], [393.0, 1053.0], [393.0, 1083.0], [116.0, 1083.0]], 'bbox': (116, 1053, 278, 31), 'method': 'polygon'}, {'text': '看了好几家', 'confidence': 0.9982882738113403, 'polygon': [[116.0, 1181.0], [276.0, 1181.0], [276.0, 1214.0], [116.0, 1214.0]], 'bbox': (116, 1181, 161, 34), 'method': 'polygon'}, {'text': '缺迟迟不下单？', 'confidence': 0.9865140318870544, 'polygon': [[116.0, 1221.0], [324.0, 1221.0], [324.0, 1253.0], [116.0, 1253.0]], 'bbox': (116, 1221, 209, 33), 'method': 'polygon'}, {'text': '本店产品性价比高，购买无忧', 'confidence': 0.9975700974464417, 'polygon': [[111.0, 1310.0], [429.0, 1312.0], [428.0, 1342.0], [110.0, 1341.0]], 'bbox': (110, 1310, 320, 33), 'method': 'polygon'}] +[2026-03-02 20:50:35,015] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 1 OCR raw 데이터 메모리 저장 완료: 16개 텍스트 +[2026-03-02 20:50:35,046] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.2%): '你的这些苦恼' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.0%): '交给我来帮你解决' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '不知道' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '如何选电池型号？' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '专业客服解答您的各种问题' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '笔记本电池' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '不知道' +[2026-03-02 20:50:35,048] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '分期免息' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.1%): '去哪家店铺购买好？' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '专业售前售后帮助你选购' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '不知道' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 96.4%): '电池质量好不好？' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '大牌有保障高品质值得信赖' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '看了好几家' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.7%): '缺迟迟不下单？' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '本店产品性价比高，购买无忧' +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 16/16개 (신뢰도 + & 중국어) +[2026-03-02 20:50:35,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '你的这些苦恼', 'confidence': 0.9820561408996582, 'polygon': [[264.0, 115.0], [596.0, 115.0], [596.0, 169.0], [264.0, 169.0]], 'bbox': (264, 115, 333, 55), 'method': 'polygon'}, {'text': '交给我来帮你解决', 'confidence': 0.9901595115661621, 'polygon': [[203.0, 215.0], [652.0, 215.0], [652.0, 262.0], [203.0, 262.0]], 'bbox': (203, 215, 450, 48), 'method': 'polygon'}, {'text': '不知道', 'confidence': 0.9998881220817566, 'polygon': [[110.0, 418.0], [211.0, 418.0], [211.0, 457.0], [110.0, 457.0]], 'bbox': (110, 418, 102, 40), 'method': 'polygon'}, {'text': '如何选电池型号？', 'confidence': 0.995311439037323, 'polygon': [[112.0, 461.0], [354.0, 458.0], [354.0, 495.0], [112.0, 498.0]], 'bbox': (112, 458, 243, 41), 'method': 'polygon'}, {'text': '专业客服解答您的各种问题', 'confidence': 0.9953719973564148, 'polygon': [[118.0, 535.0], [391.0, 535.0], [391.0, 561.0], [118.0, 561.0]], 'bbox': (118, 535, 274, 27), 'method': 'polygon'}, {'text': '笔记本电池', 'confidence': 0.9978134036064148, 'polygon': [[512.0, 654.0], [597.0, 654.0], [597.0, 680.0], [512.0, 680.0]], 'bbox': (512, 654, 86, 27), 'method': 'polygon'}, {'text': '不知道', 'confidence': 0.9998703002929688, 'polygon': [[113.0, 683.0], [209.0, 683.0], [209.0, 717.0], [113.0, 717.0]], 'bbox': (113, 683, 97, 35), 'method': 'polygon'}, {'text': '分期免息', 'confidence': 0.9991531372070312, 'polygon': [[485.0, 702.0], [542.0, 702.0], [542.0, 723.0], [485.0, 723.0]], 'bbox': (485, 702, 58, 22), 'method': 'polygon'}, {'text': '去哪家店铺购买好？', 'confidence': 0.9812180995941162, 'polygon': [[115.0, 726.0], [387.0, 726.0], [387.0, 758.0], [115.0, 758.0]], 'bbox': (115, 726, 273, 33), 'method': 'polygon'}, {'text': '专业售前售后帮助你选购', 'confidence': 0.9944560527801514, 'polygon': [[119.0, 795.0], [369.0, 795.0], [369.0, 821.0], [119.0, 821.0]], 'bbox': (119, 795, 251, 27), 'method': 'polygon'}, {'text': '不知道', 'confidence': 0.9998777508735657, 'polygon': [[112.0, 941.0], [212.0, 941.0], [212.0, 979.0], [112.0, 979.0]], 'bbox': (112, 941, 101, 39), 'method': 'polygon'}, {'text': '电池质量好不好？', 'confidence': 0.9637632369995117, 'polygon': [[116.0, 984.0], [354.0, 984.0], [354.0, 1016.0], [116.0, 1016.0]], 'bbox': (116, 984, 239, 33), 'method': 'polygon'}, {'text': '大牌有保障高品质值得信赖', 'confidence': 0.9967874884605408, 'polygon': [[116.0, 1053.0], [393.0, 1053.0], [393.0, 1083.0], [116.0, 1083.0]], 'bbox': (116, 1053, 278, 31), 'method': 'polygon'}, {'text': '看了好几家', 'confidence': 0.9982882738113403, 'polygon': [[116.0, 1181.0], [276.0, 1181.0], [276.0, 1214.0], [116.0, 1214.0]], 'bbox': (116, 1181, 161, 34), 'method': 'polygon'}, {'text': '缺迟迟不下单？', 'confidence': 0.9865140318870544, 'polygon': [[116.0, 1221.0], [324.0, 1221.0], [324.0, 1253.0], [116.0, 1253.0]], 'bbox': (116, 1221, 209, 33), 'method': 'polygon'}, {'text': '本店产品性价比高，购买无忧', 'confidence': 0.9975700974464417, 'polygon': [[111.0, 1310.0], [429.0, 1312.0], [428.0, 1342.0], [110.0, 1341.0]], 'bbox': (110, 1310, 320, 33), 'method': 'polygon'}] +[2026-03-02 20:50:35,063] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 16개 필터링 완료 +[2026-03-02 20:50:35,063] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:35,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 2 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_001_O1CN01d1GvR51Fsjxgj5xM9_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:35,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_001_O1CN01d1GvR51Fsjxgj5xM9_!!692310543.jpg +[2026-03-02 20:50:35,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 2 원본 크기: 750x1052 +[2026-03-02 20:50:35,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 2 가로 크기 조정: 750x1052 → 860x1206 +[2026-03-02 20:50:35,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 2 크기 조정 완료: 860x1206 +[2026-03-02 20:50:35,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 2 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_001_O1CN01d1GvR51Fsjxgj5xM9_!!692310543_resized.jpg +[2026-03-02 20:50:35,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:36,795] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 1615.9ms +[2026-03-02 20:50:36,816] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 320.0ms, 인식: 1249.0ms, 분류: 34.0ms +[2026-03-02 20:50:36,834] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11009.4MB -> 11027.6MB (+18.2MB, +0.2%) - 이미지 2 +[2026-03-02 20:50:36,838] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '放心买放心用', 'confidence': 0.998256504535675, 'polygon': [[163.0, 87.0], [683.0, 87.0], [683.0, 163.0], [163.0, 163.0]], 'bbox': (163, 87, 521, 77), 'method': 'polygon'}, {'text': '请相信我们的售后保障！', 'confidence': 0.9939752817153931, 'polygon': [[203.0, 190.0], [645.0, 190.0], [645.0, 229.0], [203.0, 229.0]], 'bbox': (203, 190, 443, 40), 'method': 'polygon'}, {'text': '30', 'confidence': 0.9991095066070557, 'polygon': [[321.0, 384.0], [523.0, 384.0], [523.0, 553.0], [321.0, 553.0]], 'bbox': (321, 384, 203, 170), 'method': 'polygon'}, {'text': '天', 'confidence': 0.999758780002594, 'polygon': [[525.0, 489.0], [572.0, 489.0], [572.0, 536.0], [525.0, 536.0]], 'bbox': (525, 489, 48, 48), 'method': 'polygon'}, {'text': '无理由退换货', 'confidence': 0.9947476983070374, 'polygon': [[217.0, 581.0], [640.0, 578.0], [640.0, 638.0], [218.0, 641.0]], 'bbox': (217, 578, 424, 64), 'method': 'polygon'}, {'text': '质量问题直接换，要买就买个好的', 'confidence': 0.9911738634109497, 'polygon': [[219.0, 710.0], [627.0, 710.0], [627.0, 739.0], [219.0, 739.0]], 'bbox': (219, 710, 409, 30), 'method': 'polygon'}, {'text': '赔', 'confidence': 0.9869441986083984, 'polygon': [[120.0, 912.0], [161.0, 912.0], [161.0, 957.0], [120.0, 957.0]], 'bbox': (120, 912, 42, 46), 'method': 'polygon'}, {'text': '30', 'confidence': 0.9988932609558105, 'polygon': [[394.0, 913.0], [450.0, 913.0], [450.0, 956.0], [394.0, 956.0]], 'bbox': (394, 913, 57, 44), 'method': 'polygon'}, {'text': '退', 'confidence': 0.9891166090965271, 'polygon': [[678.0, 913.0], [721.0, 913.0], [721.0, 956.0], [678.0, 956.0]], 'bbox': (678, 913, 44, 44), 'method': 'polygon'}, {'text': '品质承诺', 'confidence': 0.9982619285583496, 'polygon': [[82.0, 1009.0], [206.0, 1009.0], [206.0, 1044.0], [82.0, 1044.0]], 'bbox': (82, 1009, 125, 36), 'method': 'polygon'}, {'text': '服务承诺', 'confidence': 0.9989551305770874, 'polygon': [[362.0, 1008.0], [486.0, 1008.0], [486.0, 1043.0], [362.0, 1043.0]], 'bbox': (362, 1008, 125, 36), 'method': 'polygon'}, {'text': '售后承诺', 'confidence': 0.998520016670227, 'polygon': [[641.0, 1009.0], [765.0, 1009.0], [765.0, 1044.0], [641.0, 1044.0]], 'bbox': (641, 1009, 125, 36), 'method': 'polygon'}, {'text': '二十多年品质用芯定制', 'confidence': 0.9984818696975708, 'polygon': [[51.0, 1062.0], [244.0, 1062.0], [244.0, 1083.0], [51.0, 1083.0]], 'bbox': (51, 1062, 194, 22), 'method': 'polygon'}, {'text': '30天内无理由退换货', 'confidence': 0.9980495572090149, 'polygon': [[331.0, 1062.0], [509.0, 1062.0], [509.0, 1083.0], [331.0, 1083.0]], 'bbox': (331, 1062, 179, 22), 'method': 'polygon'}, {'text': '质量问题直接换货', 'confidence': 0.9962954521179199, 'polygon': [[623.0, 1062.0], [778.0, 1062.0], [778.0, 1083.0], [623.0, 1083.0]], 'bbox': (623, 1062, 156, 22), 'method': 'polygon'}, {'text': '做更好更耐用的笔记本电池', 'confidence': 0.9981363415718079, 'polygon': [[31.0, 1095.0], [262.0, 1095.0], [262.0, 1117.0], [31.0, 1117.0]], 'bbox': (31, 1095, 232, 23), 'method': 'polygon'}, {'text': '联系客服处理到您满意', 'confidence': 0.9940294027328491, 'polygon': [[323.0, 1092.0], [521.0, 1093.0], [521.0, 1118.0], [322.0, 1117.0]], 'bbox': (322, 1092, 200, 27), 'method': 'polygon'}, {'text': '售后客服随时帮助您处理', 'confidence': 0.9958204030990601, 'polygon': [[593.0, 1092.0], [809.0, 1093.0], [809.0, 1118.0], [592.0, 1117.0]], 'bbox': (592, 1092, 218, 27), 'method': 'polygon'}] +[2026-03-02 20:50:36,839] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 2 OCR raw 데이터 메모리 저장 완료: 18개 텍스트 +[2026-03-02 20:50:36,839] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '放心买放心用' +[2026-03-02 20:50:36,839] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '请相信我们的售后保障！' +[2026-03-02 20:50:36,839] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '30' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '天' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '无理由退换货' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.1%): '质量问题直接换，要买就买个好的' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.7%): '赔' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '30' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.9%): '退' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '品质承诺' +[2026-03-02 20:50:36,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '服务承诺' +[2026-03-02 20:50:36,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '售后承诺' +[2026-03-02 20:50:36,843] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '二十多年品质用芯定制' +[2026-03-02 20:50:36,843] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '30天内无理由退换货' +[2026-03-02 20:50:36,844] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '质量问题直接换货' +[2026-03-02 20:50:36,844] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '做更好更耐用的笔记本电池' +[2026-03-02 20:50:36,844] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '联系客服处理到您满意' +[2026-03-02 20:50:36,844] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '售后客服随时帮助您处理' +[2026-03-02 20:50:36,844] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 16/18개 (신뢰도 + & 중국어) +[2026-03-02 20:50:36,844] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '放心买放心用', 'confidence': 0.998256504535675, 'polygon': [[163.0, 87.0], [683.0, 87.0], [683.0, 163.0], [163.0, 163.0]], 'bbox': (163, 87, 521, 77), 'method': 'polygon'}, {'text': '请相信我们的售后保障！', 'confidence': 0.9939752817153931, 'polygon': [[203.0, 190.0], [645.0, 190.0], [645.0, 229.0], [203.0, 229.0]], 'bbox': (203, 190, 443, 40), 'method': 'polygon'}, {'text': '天', 'confidence': 0.999758780002594, 'polygon': [[525.0, 489.0], [572.0, 489.0], [572.0, 536.0], [525.0, 536.0]], 'bbox': (525, 489, 48, 48), 'method': 'polygon'}, {'text': '无理由退换货', 'confidence': 0.9947476983070374, 'polygon': [[217.0, 581.0], [640.0, 578.0], [640.0, 638.0], [218.0, 641.0]], 'bbox': (217, 578, 424, 64), 'method': 'polygon'}, {'text': '质量问题直接换，要买就买个好的', 'confidence': 0.9911738634109497, 'polygon': [[219.0, 710.0], [627.0, 710.0], [627.0, 739.0], [219.0, 739.0]], 'bbox': (219, 710, 409, 30), 'method': 'polygon'}, {'text': '赔', 'confidence': 0.9869441986083984, 'polygon': [[120.0, 912.0], [161.0, 912.0], [161.0, 957.0], [120.0, 957.0]], 'bbox': (120, 912, 42, 46), 'method': 'polygon'}, {'text': '退', 'confidence': 0.9891166090965271, 'polygon': [[678.0, 913.0], [721.0, 913.0], [721.0, 956.0], [678.0, 956.0]], 'bbox': (678, 913, 44, 44), 'method': 'polygon'}, {'text': '品质承诺', 'confidence': 0.9982619285583496, 'polygon': [[82.0, 1009.0], [206.0, 1009.0], [206.0, 1044.0], [82.0, 1044.0]], 'bbox': (82, 1009, 125, 36), 'method': 'polygon'}, {'text': '服务承诺', 'confidence': 0.9989551305770874, 'polygon': [[362.0, 1008.0], [486.0, 1008.0], [486.0, 1043.0], [362.0, 1043.0]], 'bbox': (362, 1008, 125, 36), 'method': 'polygon'}, {'text': '售后承诺', 'confidence': 0.998520016670227, 'polygon': [[641.0, 1009.0], [765.0, 1009.0], [765.0, 1044.0], [641.0, 1044.0]], 'bbox': (641, 1009, 125, 36), 'method': 'polygon'}, {'text': '二十多年品质用芯定制', 'confidence': 0.9984818696975708, 'polygon': [[51.0, 1062.0], [244.0, 1062.0], [244.0, 1083.0], [51.0, 1083.0]], 'bbox': (51, 1062, 194, 22), 'method': 'polygon'}, {'text': '30天内无理由退换货', 'confidence': 0.9980495572090149, 'polygon': [[331.0, 1062.0], [509.0, 1062.0], [509.0, 1083.0], [331.0, 1083.0]], 'bbox': (331, 1062, 179, 22), 'method': 'polygon'}, {'text': '质量问题直接换货', 'confidence': 0.9962954521179199, 'polygon': [[623.0, 1062.0], [778.0, 1062.0], [778.0, 1083.0], [623.0, 1083.0]], 'bbox': (623, 1062, 156, 22), 'method': 'polygon'}, {'text': '做更好更耐用的笔记本电池', 'confidence': 0.9981363415718079, 'polygon': [[31.0, 1095.0], [262.0, 1095.0], [262.0, 1117.0], [31.0, 1117.0]], 'bbox': (31, 1095, 232, 23), 'method': 'polygon'}, {'text': '联系客服处理到您满意', 'confidence': 0.9940294027328491, 'polygon': [[323.0, 1092.0], [521.0, 1093.0], [521.0, 1118.0], [322.0, 1117.0]], 'bbox': (322, 1092, 200, 27), 'method': 'polygon'}, {'text': '售后客服随时帮助您处理', 'confidence': 0.9958204030990601, 'polygon': [[593.0, 1092.0], [809.0, 1093.0], [809.0, 1118.0], [592.0, 1117.0]], 'bbox': (592, 1092, 218, 27), 'method': 'polygon'}] +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 16개 필터링 완료 +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['당신의 이러한 문제', '나에게 맡겨서 해결하는 데 도움을 받으세요.', '모른다', '배터리 모델을 선택하는 방법은 무엇입니까?', '다양한 질문에 답해드리는 전문적인 고객 서비스', '노트북 배터리', '모른다', '무이자할부', '어느 매장에서 구매하는 것이 가장 좋나요?', '전문적인 사전 판매 및 판매 후 선택에 도움이 됩니다.', '모른다', '배터리 품질은 좋은가요?', '대형 브랜드는 높은 품질을 보장하고 신뢰할 수 있습니다.', '여러개 봤어', '아직도 주문을 하지 않으셨나요?', '당사의 제품은 구매 시 비용 효율적이며 걱정이 없습니다.'] +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '당신의 이러한 문제' +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['당신의', '이러한', '문제'] +[2026-03-02 20:50:36,845] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '당신의 이러한 문제' +[2026-03-02 20:50:36,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '나에게 맡겨서 해결하는 데 도움을 받으세요.' +[2026-03-02 20:50:36,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['나에게', '맡겨서', '해결하는', '데', '도움을', '받으세요.'] +[2026-03-02 20:50:36,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '나에게 맡겨서 해결하는 데 도움을 받으세요.' +[2026-03-02 20:50:36,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '모른다' +[2026-03-02 20:50:36,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['모른다'] +[2026-03-02 20:50:36,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '모른다' +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '배터리 모델을 선택하는 방법은 무엇입니까?' +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['배터리', '모델을', '선택하는', '방법은', '무엇입니까?'] +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '배터리 모델을 선택하는 방법은 무엇입니까?' +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '다양한 질문에 답해드리는 전문적인 고객 서비스' +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['다양한', '질문에', '답해드리는', '전문적인', '고객', '서비스'] +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '다양한 질문에 답해드리는 전문적인 고객 서비스' +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '노트북 배터리' +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['노트북', '배터리'] +[2026-03-02 20:50:36,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '노트북 배터리' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '모른다' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['모른다'] +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '모른다' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '무이자할부' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['무이자할부'] +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '무이자할부' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '어느 매장에서 구매하는 것이 가장 좋나요?' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['어느', '매장에서', '구매하는', '것이', '가장', '좋나요?'] +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '어느 매장에서 구매하는 것이 가장 좋나요?' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '전문적인 사전 판매 및 판매 후 선택에 도움이 됩니다.' +[2026-03-02 20:50:36,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['전문적인', '사전', '판매', '및', '판매', '후', '선택에', '도움이', '됩니다.'] +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '전문적인 사전 판매 및 판매 후 선택에 도움이 됩니다.' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '모른다' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['모른다'] +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '모른다' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '배터리 품질은 좋은가요?' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['배터리', '품질은', '좋은가요?'] +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '배터리 품질은 좋은가요?' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '대형 브랜드는 높은 품질을 보장하고 신뢰할 수 있습니다.' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['대형', '브랜드는', '높은', '품질을', '보장하고', '신뢰할', '수', '있습니다.'] +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '대형 브랜드는 높은 품질을 보장하고 신뢰할 수 있습니다.' +[2026-03-02 20:50:36,849] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '여러개 봤어' +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['여러개', '봤어'] +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '여러개 봤어' +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 원본 텍스트: '아직도 주문을 하지 않으셨나요?' +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 분리된 단어: ['아직도', '주문을', '하지', '않으셨나요?'] +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 변경 없음: '아직도 주문을 하지 않으셨나요?' +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 원본 텍스트: '당사의 제품은 구매 시 비용 효율적이며 걱정이 없습니다.' +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 분리된 단어: ['당사의', '제품은', '구매', '시', '비용', '효율적이며', '걱정이', '없습니다.'] +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 변경 없음: '당사의 제품은 구매 시 비용 효율적이며 걱정이 없습니다.' +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 16개 텍스트 처리 완료 +[2026-03-02 20:50:36,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 1 치환됨 +[2026-03-02 20:50:36,852] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.161, comps=12, min_center_dist=0.036 → external_request +[2026-03-02 20:50:36,852] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 16 +[2026-03-02 20:50:36,853] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:36,853] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:36,853] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:36,893] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:36,988] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:38,218] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:50:38,222] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11028.9MB -> 11012.6MB (-16.4MB, -0.1%) - 방법: external_request +[2026-03-02 20:50:38,222] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:50:38,431] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:50:38,433] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:50:38,433] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:50:39,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_1.webp +[2026-03-02 20:50:39,052] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 1 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_1.webp +[2026-03-02 20:50:39,052] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 5979.7ms | download=0.0ms | ocr=1547.7ms | translate=1789.0ms | mask=1789.0ms | inpaint=1371.7ms(external_request/SERVER) | render=209.0ms | save=567.0ms +[2026-03-02 20:50:39,052] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:50:39,052] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=55bbca51-1d6c-4509-9c4e-99d63c335844 +[2026-03-02 20:50:39,052] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=55bbca51-1d6c-4509-9c4e-99d63c335844 +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['안심하고 구매하고 안심하고 사용하세요', '우리의 판매 후 보증을 신뢰하십시오!', '일', '반품, 교환 사유가 되지 않는 상품', '품질 문제가 있으면 교체하십시오. 사고 싶은거 있으면 그냥 좋은거 사세요.', '보상하다', '후퇴', '품질 약속', '서비스 약속', '판매 후 약속', '20년 이상의 품질 핵심 맞춤화 경험', '30일 이내 반품, 교환 사유가 되지 않는 경우', '품질 문제 직접 교환', '더 좋고 내구성이 뛰어난 노트북 배터리 만들기', '만족할 때까지 고객 서비스에 문의하여 처리하십시오.', '판매 후 고객 서비스는 귀하가 이를 처리하는 데 도움을 드릴 준비가 되어 있습니다.'] +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '안심하고 구매하고 안심하고 사용하세요' +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['안심하고', '구매하고', '안심하고', '사용하세요'] +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '안심하고 구매하고 안심하고 사용하세요' +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '우리의 판매 후 보증을 신뢰하십시오!' +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['우리의', '판매', '후', '보증을', '신뢰하십시오!'] +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '우리의 판매 후 보증을 신뢰하십시오!' +[2026-03-02 20:50:39,592] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '일' +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['일'] +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '일' +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '반품, 교환 사유가 되지 않는 상품' +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['반품,', '교환', '사유가', '되지', '않는', '상품'] +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '반품, 교환 사유가 되지 않는 상품' +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '품질 문제가 있으면 교체하십시오. 사고 싶은거 있으면 그냥 좋은거 사세요.' +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['품질', '문제가', '있으면', '교체하십시오.', '사고', '싶은거', '있으면', '그냥', '좋은거', '사세요.'] +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '품질 문제가 있으면 교체하십시오. 사고 싶은거 있으면 그냥 좋은거 사세요.' +[2026-03-02 20:50:39,593] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '보상하다' +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['보상하다'] +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '보상하다' +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '후퇴' +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['후퇴'] +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '후퇴' +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '품질 약속' +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['품질', '약속'] +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '품질 약속' +[2026-03-02 20:50:39,594] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '서비스 약속' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['서비스', '약속'] +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '서비스 약속' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '판매 후 약속' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['판매', '후', '약속'] +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '판매 후 약속' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '20년 이상의 품질 핵심 맞춤화 경험' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['20년', '이상의', '품질', '핵심', '맞춤화', '경험'] +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '20년 이상의 품질 핵심 맞춤화 경험' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '30일 이내 반품, 교환 사유가 되지 않는 경우' +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['30일', '이내', '반품,', '교환', '사유가', '되지', '않는', '경우'] +[2026-03-02 20:50:39,595] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '30일 이내 반품, 교환 사유가 되지 않는 경우' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '품질 문제 직접 교환' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['품질', '문제', '직접', '교환'] +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '품질 문제 직접 교환' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '더 좋고 내구성이 뛰어난 노트북 배터리 만들기' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['더', '좋고', '내구성이', '뛰어난', '노트북', '배터리', '만들기'] +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '더 좋고 내구성이 뛰어난 노트북 배터리 만들기' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 원본 텍스트: '만족할 때까지 고객 서비스에 문의하여 처리하십시오.' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 분리된 단어: ['만족할', '때까지', '고객', '서비스에', '문의하여', '처리하십시오.'] +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 변경 없음: '만족할 때까지 고객 서비스에 문의하여 처리하십시오.' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 원본 텍스트: '판매 후 고객 서비스는 귀하가 이를 처리하는 데 도움을 드릴 준비가 되어 있습니다.' +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 분리된 단어: ['판매', '후', '고객', '서비스는', '귀하가', '이를', '처리하는', '데', '도움을', '드릴', '준비가', '되어', '있습니다.'] +[2026-03-02 20:50:39,596] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 변경 없음: '판매 후 고객 서비스는 귀하가 이를 처리하는 데 도움을 드릴 준비가 되어 있습니다.' +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 16개 텍스트 처리 완료 +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 2 치환됨 +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.215, comps=10, min_center_dist=0.057 → external_request +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 16 +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:39,597] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:39,642] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:39,764] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:40,428] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=2fce6cd2-fb2d-445e-a4ab-134537cc0dcd +[2026-03-02 20:50:40,433] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:40,433] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:40,433] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:40,433] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:40,434] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:40,624] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:50:40,627] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11017.1MB -> 10947.1MB (-70.1MB, -0.6%) - 방법: external_request +[2026-03-02 20:50:40,627] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:50:40,779] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:50:40,780] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:50:40,780] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:50:41,341] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_2.webp +[2026-03-02 20:50:41,344] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 2 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_2.webp +[2026-03-02 20:50:41,345] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 8011.8ms | download=15.0ms | ocr=1644.9ms | translate=2755.8ms | mask=36.0ms | inpaint=1030.9ms(external_request/SERVER) | render=152.0ms | save=512.3ms +[2026-03-02 20:50:41,345] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:50:41,345] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=d25a3ed9-7edd-4496-bc07-3b991d9917ab +[2026-03-02 20:50:41,345] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=d25a3ed9-7edd-4496-bc07-3b991d9917ab +[2026-03-02 20:50:41,345] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 3 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_002_O1CN01eU0NkG1FsjxZanw4d_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:41,345] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_002_O1CN01eU0NkG1FsjxZanw4d_!!692310543.jpg +[2026-03-02 20:50:41,351] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 3 원본 크기: 750x910 +[2026-03-02 20:50:41,357] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 3 가로 크기 조정: 750x910 → 860x1043 +[2026-03-02 20:50:41,365] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 3 크기 조정 완료: 860x1043 +[2026-03-02 20:50:41,366] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 3 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_002_O1CN01eU0NkG1FsjxZanw4d_!!692310543_resized.jpg +[2026-03-02 20:50:41,371] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:43,854] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 2476.9ms +[2026-03-02 20:50:43,890] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 364.0ms, 인식: 2030.0ms, 분류: 66.0ms +[2026-03-02 20:50:43,908] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 10934.9MB -> 10973.9MB (+39.0MB, +0.4%) - 이미지 3 +[2026-03-02 20:50:43,910] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '质量从品质开始', 'confidence': 0.9717680215835571, 'polygon': [[124.0, 83.0], [730.0, 83.0], [730.0, 160.0], [124.0, 160.0]], 'bbox': (124, 83, 607, 78), 'method': 'polygon'}, {'text': '采用全新知名品牌进口超A级高容量电芯', 'confidence': 0.9963377714157104, 'polygon': [[146.0, 179.0], [709.0, 179.0], [709.0, 209.0], [146.0, 209.0]], 'bbox': (146, 179, 564, 31), 'method': 'polygon'}, {'text': 'AA-PBVN4NP', 'confidence': 0.9959461092948914, 'polygon': [[347.0, 233.0], [516.0, 233.0], [516.0, 255.0], [347.0, 255.0]], 'bbox': (347, 233, 170, 23), 'method': 'polygon'}, {'text': '（15.2V57WH）', 'confidence': 0.9228973984718323, 'polygon': [[355.0, 272.0], [504.0, 272.0], [504.0, 294.0], [355.0, 294.0]], 'bbox': (355, 272, 150, 23), 'method': 'polygon'}, {'text': 'SHUO.Z.B', 'confidence': 0.9749159812927246, 'polygon': [[77.0, 473.0], [142.0, 473.0], [142.0, 485.0], [77.0, 485.0]], 'bbox': (77, 473, 66, 13), 'method': 'polygon'}, {'text': 'Rating:+15.2V---57W', 'confidence': 0.9323304891586304, 'polygon': [[74.0, 483.0], [218.0, 482.0], [218.0, 499.0], [74.0, 500.0]], 'bbox': (74, 482, 145, 19), 'method': 'polygon'}, {'text': 'RoHS', 'confidence': 0.9476627111434937, 'polygon': [[425.0, 485.0], [479.0, 485.0], [479.0, 504.0], [425.0, 504.0]], 'bbox': (425, 485, 55, 20), 'method': 'polygon'}, {'text': 'Capacity:3750mAh(TYP)/3550mAh(MIN)', 'confidence': 0.9464518427848816, 'polygon': [[75.0, 502.0], [260.0, 502.0], [260.0, 516.0], [75.0, 516.0]], 'bbox': (75, 502, 186, 15), 'method': 'polygon'}, {'text': 'yPac', 'confidence': 0.9052963256835938, 'polygon': [[207.0, 498.0], [233.0, 495.0], [234.0, 503.0], [208.0, 505.0]], 'bbox': (207, 495, 28, 11), 'method': 'polygon'}, {'text': 'VORSICHT!', 'confidence': 0.9417805075645447, 'polygon': [[75.0, 516.0], [127.0, 516.0], [127.0, 527.0], [75.0, 527.0]], 'bbox': (75, 516, 53, 12), 'method': 'polygon'}, {'text': 'CE', 'confidence': 0.9818071126937866, 'polygon': [[432.0, 513.0], [478.0, 513.0], [478.0, 543.0], [432.0, 543.0]], 'bbox': (432, 513, 47, 31), 'method': 'polygon'}, {'text': 'xpio:', 'confidence': 0.7303586006164551, 'polygon': [[76.0, 529.0], [102.0, 529.0], [102.0, 537.0], [76.0, 537.0]], 'bbox': (76, 529, 27, 9), 'method': 'polygon'}, {'text': 'rauchterBatter', 'confidence': 0.9713979959487915, 'polygon': [[145.0, 538.0], [216.0, 535.0], [216.0, 550.0], [145.0, 552.0]], 'bbox': (145, 535, 72, 18), 'method': 'polygon'}, {'text': 'man', 'confidence': 0.9892904162406921, 'polygon': [[389.0, 541.0], [410.0, 541.0], [410.0, 549.0], [389.0, 549.0]], 'bbox': (389, 541, 22, 9), 'method': 'polygon'}, {'text': '注意/注意', 'confidence': 0.98536217212677, 'polygon': [[74.0, 555.0], [120.0, 555.0], [120.0, 566.0], [74.0, 566.0]], 'bbox': (74, 555, 47, 12), 'method': 'polygon'}, {'text': '火中名出反产堂最品：', 'confidence': 0.5178875923156738, 'polygon': [[191.0, 585.0], [281.0, 585.0], [281.0, 592.0], [191.0, 592.0]], 'bbox': (191, 585, 91, 8), 'method': 'polygon'}, {'text': '财造商：水党', 'confidence': 0.535821259021759, 'polygon': [[72.0, 602.0], [117.0, 602.0], [117.0, 610.0], [72.0, 610.0]], 'bbox': (72, 602, 46, 9), 'method': 'polygon'}, {'text': '01', 'confidence': 0.9984710216522217, 'polygon': [[59.0, 789.0], [129.0, 789.0], [129.0, 843.0], [59.0, 843.0]], 'bbox': (59, 789, 71, 55), 'method': 'polygon'}, {'text': '02', 'confidence': 0.999152660369873, 'polygon': [[284.0, 788.0], [354.0, 788.0], [354.0, 844.0], [284.0, 844.0]], 'bbox': (284, 788, 71, 57), 'method': 'polygon'}, {'text': '03', 'confidence': 0.9990475177764893, 'polygon': [[504.0, 788.0], [575.0, 788.0], [575.0, 843.0], [504.0, 843.0]], 'bbox': (504, 788, 72, 56), 'method': 'polygon'}, {'text': '04', 'confidence': 0.9998025298118591, 'polygon': [[721.0, 789.0], [793.0, 789.0], [793.0, 842.0], [721.0, 842.0]], 'bbox': (721, 789, 73, 54), 'method': 'polygon'}, {'text': '主控芯片', 'confidence': 0.9982128143310547, 'polygon': [[42.0, 852.0], [143.0, 852.0], [143.0, 879.0], [42.0, 879.0]], 'bbox': (42, 852, 102, 28), 'method': 'polygon'}, {'text': '副芯片', 'confidence': 0.9999440312385559, 'polygon': [[272.0, 850.0], [353.0, 850.0], [353.0, 881.0], [272.0, 881.0]], 'bbox': (272, 850, 82, 32), 'method': 'polygon'}, {'text': '电阻', 'confidence': 0.9991977214813232, 'polygon': [[508.0, 851.0], [563.0, 851.0], [563.0, 880.0], [508.0, 880.0]], 'bbox': (508, 851, 56, 30), 'method': 'polygon'}, {'text': '二次保护芯片', 'confidence': 0.9985308051109314, 'polygon': [[680.0, 852.0], [833.0, 852.0], [833.0, 881.0], [680.0, 881.0]], 'bbox': (680, 852, 154, 30), 'method': 'polygon'}, {'text': '控制各元件运行状态', 'confidence': 0.9934531450271606, 'polygon': [[23.0, 897.0], [163.0, 897.0], [163.0, 916.0], [23.0, 916.0]], 'bbox': (23, 897, 141, 20), 'method': 'polygon'}, {'text': '检测各元器件电压电流', 'confidence': 0.9863897562026978, 'polygon': [[237.0, 895.0], [396.0, 895.0], [396.0, 917.0], [237.0, 917.0]], 'bbox': (237, 895, 160, 23), 'method': 'polygon'}, {'text': '多个电阻检测每块系统', 'confidence': 0.9937173128128052, 'polygon': [[457.0, 895.0], [614.0, 896.0], [614.0, 916.0], [457.0, 915.0]], 'bbox': (457, 895, 158, 22), 'method': 'polygon'}, {'text': '散热硅脂下有二次保护', 'confidence': 0.9930480718612671, 'polygon': [[677.0, 897.0], [833.0, 897.0], [833.0, 916.0], [677.0, 916.0]], 'bbox': (677, 897, 157, 20), 'method': 'polygon'}, {'text': '温度状况', 'confidence': 0.9974344372749329, 'polygon': [[282.0, 916.0], [347.0, 916.0], [347.0, 935.0], [282.0, 935.0]], 'bbox': (282, 916, 66, 20), 'method': 'polygon'}, {'text': '之间的电压电流状况', 'confidence': 0.9962363839149475, 'polygon': [[465.0, 917.0], [607.0, 917.0], [607.0, 935.0], [465.0, 935.0]], 'bbox': (465, 917, 143, 19), 'method': 'polygon'}, {'text': '西片放过压', 'confidence': 0.9995805621147156, 'polygon': [[714.0, 917.0], [798.0, 917.0], [798.0, 935.0], [714.0, 935.0]], 'bbox': (714, 917, 85, 19), 'method': 'polygon'}, {'text': '适用机型型号', 'confidence': 0.9939303398132324, 'polygon': [[282.0, 975.0], [620.0, 975.0], [620.0, 1022.0], [282.0, 1022.0]], 'bbox': (282, 975, 339, 48), 'method': 'polygon'}] +[2026-03-02 20:50:43,910] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 3 OCR raw 데이터 메모리 저장 완료: 33개 텍스트 +[2026-03-02 20:50:43,910] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 97.2%): '质量从品质开始' +[2026-03-02 20:50:43,911] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '采用全新知名品牌进口超A级高容量电芯' +[2026-03-02 20:50:43,914] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'AA-PBVN4NP' +[2026-03-02 20:50:43,914] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '（15.2V57WH）' +[2026-03-02 20:50:43,914] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'SHUO.Z.B' +[2026-03-02 20:50:43,915] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'Rating:+15.2V---57W' +[2026-03-02 20:50:43,915] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'RoHS' +[2026-03-02 20:50:43,915] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'Capacity:3750mAh(TYP)/3550mAh(MIN)' +[2026-03-02 20:50:43,915] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'yPac' +[2026-03-02 20:50:43,916] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'VORSICHT!' +[2026-03-02 20:50:43,916] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'CE' +[2026-03-02 20:50:43,917] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'xpio:' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'rauchterBatter' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'man' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.5%): '注意/注意' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 51.8%): '火中名出反产堂最品：' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 53.6%): '财造商：水党' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '01' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '02' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '03' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '04' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '主控芯片' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '副芯片' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '电阻' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '二次保护芯片' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.3%): '控制各元件运行状态' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.6%): '检测各元器件电压电流' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '多个电阻检测每块系统' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.3%): '散热硅脂下有二次保护' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '温度状况' +[2026-03-02 20:50:43,919] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '之间的电压电流状况' +[2026-03-02 20:50:43,920] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '西片放过压' +[2026-03-02 20:50:43,920] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '适用机型型号' +[2026-03-02 20:50:43,920] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 17/33개 (신뢰도 + & 중국어) +[2026-03-02 20:50:43,920] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '质量从品质开始', 'confidence': 0.9717680215835571, 'polygon': [[124.0, 83.0], [730.0, 83.0], [730.0, 160.0], [124.0, 160.0]], 'bbox': (124, 83, 607, 78), 'method': 'polygon'}, {'text': '采用全新知名品牌进口超A级高容量电芯', 'confidence': 0.9963377714157104, 'polygon': [[146.0, 179.0], [709.0, 179.0], [709.0, 209.0], [146.0, 209.0]], 'bbox': (146, 179, 564, 31), 'method': 'polygon'}, {'text': '注意/注意', 'confidence': 0.98536217212677, 'polygon': [[74.0, 555.0], [120.0, 555.0], [120.0, 566.0], [74.0, 566.0]], 'bbox': (74, 555, 47, 12), 'method': 'polygon'}, {'text': '火中名出反产堂最品：', 'confidence': 0.5178875923156738, 'polygon': [[191.0, 585.0], [281.0, 585.0], [281.0, 592.0], [191.0, 592.0]], 'bbox': (191, 585, 91, 8), 'method': 'polygon'}, {'text': '财造商：水党', 'confidence': 0.535821259021759, 'polygon': [[72.0, 602.0], [117.0, 602.0], [117.0, 610.0], [72.0, 610.0]], 'bbox': (72, 602, 46, 9), 'method': 'polygon'}, {'text': '主控芯片', 'confidence': 0.9982128143310547, 'polygon': [[42.0, 852.0], [143.0, 852.0], [143.0, 879.0], [42.0, 879.0]], 'bbox': (42, 852, 102, 28), 'method': 'polygon'}, {'text': '副芯片', 'confidence': 0.9999440312385559, 'polygon': [[272.0, 850.0], [353.0, 850.0], [353.0, 881.0], [272.0, 881.0]], 'bbox': (272, 850, 82, 32), 'method': 'polygon'}, {'text': '电阻', 'confidence': 0.9991977214813232, 'polygon': [[508.0, 851.0], [563.0, 851.0], [563.0, 880.0], [508.0, 880.0]], 'bbox': (508, 851, 56, 30), 'method': 'polygon'}, {'text': '二次保护芯片', 'confidence': 0.9985308051109314, 'polygon': [[680.0, 852.0], [833.0, 852.0], [833.0, 881.0], [680.0, 881.0]], 'bbox': (680, 852, 154, 30), 'method': 'polygon'}, {'text': '控制各元件运行状态', 'confidence': 0.9934531450271606, 'polygon': [[23.0, 897.0], [163.0, 897.0], [163.0, 916.0], [23.0, 916.0]], 'bbox': (23, 897, 141, 20), 'method': 'polygon'}, {'text': '检测各元器件电压电流', 'confidence': 0.9863897562026978, 'polygon': [[237.0, 895.0], [396.0, 895.0], [396.0, 917.0], [237.0, 917.0]], 'bbox': (237, 895, 160, 23), 'method': 'polygon'}, {'text': '多个电阻检测每块系统', 'confidence': 0.9937173128128052, 'polygon': [[457.0, 895.0], [614.0, 896.0], [614.0, 916.0], [457.0, 915.0]], 'bbox': (457, 895, 158, 22), 'method': 'polygon'}, {'text': '散热硅脂下有二次保护', 'confidence': 0.9930480718612671, 'polygon': [[677.0, 897.0], [833.0, 897.0], [833.0, 916.0], [677.0, 916.0]], 'bbox': (677, 897, 157, 20), 'method': 'polygon'}, {'text': '温度状况', 'confidence': 0.9974344372749329, 'polygon': [[282.0, 916.0], [347.0, 916.0], [347.0, 935.0], [282.0, 935.0]], 'bbox': (282, 916, 66, 20), 'method': 'polygon'}, {'text': '之间的电压电流状况', 'confidence': 0.9962363839149475, 'polygon': [[465.0, 917.0], [607.0, 917.0], [607.0, 935.0], [465.0, 935.0]], 'bbox': (465, 917, 143, 19), 'method': 'polygon'}, {'text': '西片放过压', 'confidence': 0.9995805621147156, 'polygon': [[714.0, 917.0], [798.0, 917.0], [798.0, 935.0], [714.0, 935.0]], 'bbox': (714, 917, 85, 19), 'method': 'polygon'}, {'text': '适用机型型号', 'confidence': 0.9939303398132324, 'polygon': [[282.0, 975.0], [620.0, 975.0], [620.0, 1022.0], [282.0, 1022.0]], 'bbox': (282, 975, 339, 48), 'method': 'polygon'}] +[2026-03-02 20:50:43,920] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 17개 필터링 완료 +[2026-03-02 20:50:43,921] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:43,921] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=3a13571d-2435-4d11-b496-5f9812739032 +[2026-03-02 20:50:43,921] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:43,922] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:43,923] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:43,923] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:43,924] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:44,254] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['품질은 품질에서 시작됩니다', '새로운 유명 브랜드 수입 슈퍼 A급 고용량 배터리 채택', '참고 / 참고', '가장 유명한 산불 방지 제품은 다음과 같습니다.', 'Wealth Maker: 워터 파티', '메인 제어 칩', '바이스칩', '저항', '2차 보호 칩', '각 구성 요소의 작동 상태를 제어합니다.', '각 구성 요소의 전압 및 전류 감지', '여러 저항기가 각 시스템을 감지합니다.', '방열 실리콘 그리스 아래에 2차 보호 장치가 있습니다.', '온도 조건', '사이의 전압 및 전류 조건', '서부영화의 압박', '적용 가능한 모델'] +[2026-03-02 20:50:44,254] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '품질은 품질에서 시작됩니다' +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['품질은', '품질에서', '시작됩니다'] +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '품질은 품질에서 시작됩니다' +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '새로운 유명 브랜드 수입 슈퍼 A급 고용량 배터리 채택' +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['새로운', '유명', '브랜드', '수입', '슈퍼', 'A급', '고용량', '배터리', '채택'] +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '새로운 유명 브랜드 수입 슈퍼 A급 고용량 배터리 채택' +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '참고 / 참고' +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['참고', '/', '참고'] +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '참고 / 참고' +[2026-03-02 20:50:44,255] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '가장 유명한 산불 방지 제품은 다음과 같습니다.' +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['가장', '유명한', '산불', '방지', '제품은', '다음과', '같습니다.'] +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '가장 유명한 산불 방지 제품은 다음과 같습니다.' +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: 'Wealth Maker: 워터 파티' +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['Wealth', 'Maker:', '워터', '파티'] +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: 'Wealth Maker: 워터 파티' +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '메인 제어 칩' +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['메인', '제어', '칩'] +[2026-03-02 20:50:44,256] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '메인 제어 칩' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '바이스칩' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['바이스칩'] +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '바이스칩' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '저항' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['저항'] +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '저항' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '2차 보호 칩' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['2차', '보호', '칩'] +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '2차 보호 칩' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '각 구성 요소의 작동 상태를 제어합니다.' +[2026-03-02 20:50:44,257] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['각', '구성', '요소의', '작동', '상태를', '제어합니다.'] +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '각 구성 요소의 작동 상태를 제어합니다.' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '각 구성 요소의 전압 및 전류 감지' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['각', '구성', '요소의', '전압', '및', '전류', '감지'] +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '각 구성 요소의 전압 및 전류 감지' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '여러 저항기가 각 시스템을 감지합니다.' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['여러', '저항기가', '각', '시스템을', '감지합니다.'] +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '여러 저항기가 각 시스템을 감지합니다.' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '방열 실리콘 그리스 아래에 2차 보호 장치가 있습니다.' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['방열', '실리콘', '그리스', '아래에', '2차', '보호', '장치가', '있습니다.'] +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '방열 실리콘 그리스 아래에 2차 보호 장치가 있습니다.' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '온도 조건' +[2026-03-02 20:50:44,258] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['온도', '조건'] +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '온도 조건' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 원본 텍스트: '사이의 전압 및 전류 조건' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 분리된 단어: ['사이의', '전압', '및', '전류', '조건'] +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 변경 없음: '사이의 전압 및 전류 조건' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 원본 텍스트: '서부영화의 압박' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 분리된 단어: ['서부영화의', '압박'] +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 변경 없음: '서부영화의 압박' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 원본 텍스트: '적용 가능한 모델' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 분리된 단어: ['적용', '가능한', '모델'] +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 변경 없음: '적용 가능한 모델' +[2026-03-02 20:50:44,259] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 17개 텍스트 처리 완료 +[2026-03-02 20:50:44,260] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 3 치환됨 +[2026-03-02 20:50:44,260] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.198, comps=9, min_center_dist=0.034 → external_request +[2026-03-02 20:50:44,263] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 17 +[2026-03-02 20:50:44,263] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:44,263] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:44,263] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:44,307] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:44,325] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 4 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_003_O1CN01DoY5Vv1FsjxZ1rduf_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:44,325] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_003_O1CN01DoY5Vv1FsjxZ1rduf_!!692310543.jpg +[2026-03-02 20:50:44,332] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 4 원본 크기: 750x1393 +[2026-03-02 20:50:44,341] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 4 가로 크기 조정: 750x1393 → 860x1597 +[2026-03-02 20:50:44,351] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 4 크기 조정 완료: 860x1597 +[2026-03-02 20:50:44,351] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 4 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_003_O1CN01DoY5Vv1FsjxZ1rduf_!!692310543_resized.jpg +[2026-03-02 20:50:44,360] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:44,408] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:45,025] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:50:45,029] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 10962.9MB -> 11103.8MB (+140.9MB, +1.3%) - 방법: external_request +[2026-03-02 20:50:47,087] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 2723.9ms +[2026-03-02 20:50:47,104] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 212.0ms, 인식: 2470.9ms, 분류: 27.0ms +[2026-03-02 20:50:47,111] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 10969.4MB -> 11076.9MB (+107.5MB, +1.0%) - 이미지 4 +[2026-03-02 20:50:47,112] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': 'NP670Z5E-X01NP670Z5E-X01AE', 'confidence': 0.9928831458091736, 'polygon': [[151.0, 50.0], [707.0, 50.0], [707.0, 78.0], [151.0, 78.0]], 'bbox': (151, 50, 557, 29), 'method': 'polygon'}, {'text': 'X01AUX01BEX01BRX01CLX01VE', 'confidence': 0.9875860810279846, 'polygon': [[146.0, 98.0], [712.0, 98.0], [712.0, 126.0], [146.0, 126.0]], 'bbox': (146, 98, 567, 29), 'method': 'polygon'}, {'text': 'X01CZX01HSX01ITX01NGX01NL', 'confidence': 0.9632481336593628, 'polygon': [[143.0, 146.0], [707.0, 146.0], [707.0, 175.0], [143.0, 175.0]], 'bbox': (143, 146, 565, 30), 'method': 'polygon'}, {'text': 'X01PLX01ROX01RUX01SEX01ZA', 'confidence': 0.9856464862823486, 'polygon': [[138.0, 191.0], [711.0, 193.0], [710.0, 223.0], [138.0, 221.0]], 'bbox': (138, 191, 574, 33), 'method': 'polygon'}, {'text': 'X02MYXD2', 'confidence': 0.9679923057556152, 'polygon': [[334.0, 236.0], [524.0, 236.0], [524.0, 271.0], [334.0, 271.0]], 'bbox': (334, 236, 191, 36), 'method': 'polygon'}, {'text': '注：电池的适用型号较多，未能一一列出，有不明白的地方请联系客服。', 'confidence': 0.9898643493652344, 'polygon': [[69.0, 354.0], [820.0, 354.0], [820.0, 378.0], [69.0, 378.0]], 'bbox': (69, 354, 752, 25), 'method': 'polygon'}, {'text': '专注于电池技术', 'confidence': 0.9980081915855408, 'polygon': [[59.0, 494.0], [722.0, 494.0], [722.0, 572.0], [59.0, 572.0]], 'bbox': (59, 494, 664, 79), 'method': 'polygon'}, {'text': '从设计到选材，从生产到质检，', 'confidence': 0.9879975914955139, 'polygon': [[66.0, 607.0], [462.0, 607.0], [462.0, 640.0], [66.0, 640.0]], 'bbox': (66, 607, 397, 34), 'method': 'polygon'}, {'text': '始终以高于行业的严苛标准。', 'confidence': 0.9868646860122681, 'polygon': [[64.0, 652.0], [440.0, 652.0], [440.0, 685.0], [64.0, 685.0]], 'bbox': (64, 652, 377, 34), 'method': 'polygon'}, {'text': '品质芯片安全稳定', 'confidence': 0.9970617890357971, 'polygon': [[203.0, 883.0], [633.0, 883.0], [633.0, 933.0], [203.0, 933.0]], 'bbox': (203, 883, 431, 51), 'method': 'polygon'}, {'text': '智能安全芯片采用优良线路板，原装兼容方案。', 'confidence': 0.9854679107666016, 'polygon': [[141.0, 955.0], [717.0, 955.0], [717.0, 988.0], [141.0, 988.0]], 'bbox': (141, 955, 577, 34), 'method': 'polygon'}, {'text': 'HEINTELLIGENTSECURITYCHII', 'confidence': 0.9286781549453735, 'polygon': [[284.0, 1003.0], [435.0, 1003.0], [435.0, 1020.0], [284.0, 1020.0]], 'bbox': (284, 1003, 152, 18), 'method': 'polygon'}, {'text': 'PTSEXCELLENTCIRCUI', 'confidence': 0.9835410714149475, 'polygon': [[465.0, 1001.0], [578.0, 1001.0], [578.0, 1020.0], [465.0, 1020.0]], 'bbox': (465, 1001, 114, 20), 'method': 'polygon'}] +[2026-03-02 20:50:47,112] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 4 OCR raw 데이터 메모리 저장 완료: 13개 텍스트 +[2026-03-02 20:50:47,114] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'NP670Z5E-X01NP670Z5E-X01AE' +[2026-03-02 20:50:47,118] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'X01AUX01BEX01BRX01CLX01VE' +[2026-03-02 20:50:47,119] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'X01CZX01HSX01ITX01NGX01NL' +[2026-03-02 20:50:47,120] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'X01PLX01ROX01RUX01SEX01ZA' +[2026-03-02 20:50:47,120] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'X02MYXD2' +[2026-03-02 20:50:47,121] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.0%): '注：电池的适用型号较多，未能一一列出，有不明白的地方请联系客服。' +[2026-03-02 20:50:47,121] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '专注于电池技术' +[2026-03-02 20:50:47,121] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.8%): '从设计到选材，从生产到质检，' +[2026-03-02 20:50:47,121] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.7%): '始终以高于行业的严苛标准。' +[2026-03-02 20:50:47,121] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '品质芯片安全稳定' +[2026-03-02 20:50:47,122] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.5%): '智能安全芯片采用优良线路板，原装兼容方案。' +[2026-03-02 20:50:47,123] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'HEINTELLIGENTSECURITYCHII' +[2026-03-02 20:50:47,123] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'PTSEXCELLENTCIRCUI' +[2026-03-02 20:50:47,123] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 6/13개 (신뢰도 + & 중국어) +[2026-03-02 20:50:47,123] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '注：电池的适用型号较多，未能一一列出，有不明白的地方请联系客服。', 'confidence': 0.9898643493652344, 'polygon': [[69.0, 354.0], [820.0, 354.0], [820.0, 378.0], [69.0, 378.0]], 'bbox': (69, 354, 752, 25), 'method': 'polygon'}, {'text': '专注于电池技术', 'confidence': 0.9980081915855408, 'polygon': [[59.0, 494.0], [722.0, 494.0], [722.0, 572.0], [59.0, 572.0]], 'bbox': (59, 494, 664, 79), 'method': 'polygon'}, {'text': '从设计到选材，从生产到质检，', 'confidence': 0.9879975914955139, 'polygon': [[66.0, 607.0], [462.0, 607.0], [462.0, 640.0], [66.0, 640.0]], 'bbox': (66, 607, 397, 34), 'method': 'polygon'}, {'text': '始终以高于行业的严苛标准。', 'confidence': 0.9868646860122681, 'polygon': [[64.0, 652.0], [440.0, 652.0], [440.0, 685.0], [64.0, 685.0]], 'bbox': (64, 652, 377, 34), 'method': 'polygon'}, {'text': '品质芯片安全稳定', 'confidence': 0.9970617890357971, 'polygon': [[203.0, 883.0], [633.0, 883.0], [633.0, 933.0], [203.0, 933.0]], 'bbox': (203, 883, 431, 51), 'method': 'polygon'}, {'text': '智能安全芯片采用优良线路板，原装兼容方案。', 'confidence': 0.9854679107666016, 'polygon': [[141.0, 955.0], [717.0, 955.0], [717.0, 988.0], [141.0, 988.0]], 'bbox': (141, 955, 577, 34), 'method': 'polygon'}] +[2026-03-02 20:50:47,124] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 6개 필터링 완료 +[2026-03-02 20:50:47,124] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:47,124] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:50:47,263] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:50:47,264] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:50:47,264] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:50:47,714] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_3.webp +[2026-03-02 20:50:47,717] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 3 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_3.webp +[2026-03-02 20:50:47,717] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 7280.4ms | download=0.0ms | ocr=2492.9ms | translate=342.4ms | mask=24.0ms | inpaint=2852.3ms(external_request/SERVER) | render=151.0ms | save=403.2ms +[2026-03-02 20:50:47,717] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:50:47,717] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=2fce6cd2-fb2d-445e-a4ab-134537cc0dcd +[2026-03-02 20:50:47,717] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=2fce6cd2-fb2d-445e-a4ab-134537cc0dcd +[2026-03-02 20:50:48,961] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=02df4896-5b20-4f6e-b9d1-2541069a737f +[2026-03-02 20:50:48,963] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:48,963] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:48,964] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:48,964] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:48,964] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:49,367] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 5 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_004_O1CN0101eXYB1FsjxcXuiDF_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:49,367] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_004_O1CN0101eXYB1FsjxcXuiDF_!!692310543.jpg +[2026-03-02 20:50:49,379] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 5 원본 크기: 750x967 +[2026-03-02 20:50:49,397] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 5 가로 크기 조정: 750x967 → 860x1108 +[2026-03-02 20:50:49,405] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 5 크기 조정 완료: 860x1108 +[2026-03-02 20:50:49,405] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 5 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_004_O1CN0101eXYB1FsjxcXuiDF_!!692310543_resized.jpg +[2026-03-02 20:50:49,412] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:52,052] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 2635.3ms +[2026-03-02 20:50:52,077] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 308.0ms, 인식: 2270.3ms, 분류: 44.0ms +[2026-03-02 20:50:52,077] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11087.0MB -> 11095.1MB (+8.1MB, +0.1%) - 이미지 5 +[2026-03-02 20:50:52,097] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '轻松应对各种场景', 'confidence': 0.9915658235549927, 'polygon': [[87.0, 104.0], [770.0, 106.0], [770.0, 180.0], [86.0, 178.0]], 'bbox': (86, 104, 685, 77), 'method': 'polygon'}, {'text': '您的需求我们都知道', 'confidence': 0.9891422986984253, 'polygon': [[273.0, 219.0], [588.0, 219.0], [588.0, 250.0], [273.0, 250.0]], 'bbox': (273, 219, 316, 32), 'method': 'polygon'}, {'text': 'MEETTHEDAILYNEEDSREECTTHERTUALLABELATTERYLARGERCAPACITY', 'confidence': 0.8604782223701477, 'polygon': [[285.0, 274.0], [571.0, 274.0], [571.0, 289.0], [285.0, 289.0]], 'bbox': (285, 274, 287, 16), 'method': 'polygon'}, {'text': 'STRONGER,STRONGER', 'confidence': 0.9671908020973206, 'polygon': [[387.0, 290.0], [470.0, 290.0], [470.0, 302.0], [387.0, 302.0]], 'bbox': (387, 290, 84, 13), 'method': 'polygon'}, {'text': '休闲', 'confidence': 0.9994382262229919, 'polygon': [[141.0, 382.0], [201.0, 382.0], [201.0, 413.0], [141.0, 413.0]], 'bbox': (141, 382, 61, 32), 'method': 'polygon'}, {'text': '办公', 'confidence': 0.9973188042640686, 'polygon': [[397.0, 382.0], [459.0, 382.0], [459.0, 413.0], [397.0, 413.0]], 'bbox': (397, 382, 63, 32), 'method': 'polygon'}, {'text': '娱乐', 'confidence': 0.9990744590759277, 'polygon': [[656.0, 380.0], [720.0, 380.0], [720.0, 416.0], [656.0, 416.0]], 'bbox': (656, 380, 65, 37), 'method': 'polygon'}, {'text': 'LEISURE', 'confidence': 0.9922155737876892, 'polygon': [[145.0, 422.0], [196.0, 422.0], [196.0, 440.0], [145.0, 440.0]], 'bbox': (145, 422, 52, 19), 'method': 'polygon'}, {'text': 'OFFICE', 'confidence': 0.9922831058502197, 'polygon': [[407.0, 422.0], [452.0, 422.0], [452.0, 440.0], [407.0, 440.0]], 'bbox': (407, 422, 46, 19), 'method': 'polygon'}, {'text': 'ENTERTAINMENT', 'confidence': 0.9936981201171875, 'polygon': [[636.0, 424.0], [741.0, 424.0], [741.0, 439.0], [636.0, 439.0]], 'bbox': (636, 424, 106, 16), 'method': 'polygon'}, {'text': '3-4小时', 'confidence': 0.9945409893989563, 'polygon': [[134.0, 707.0], [218.0, 704.0], [219.0, 729.0], [135.0, 732.0]], 'bbox': (134, 704, 86, 29), 'method': 'polygon'}, {'text': '2-3小时', 'confidence': 0.9951154589653015, 'polygon': [[388.0, 706.0], [471.0, 706.0], [471.0, 731.0], [388.0, 731.0]], 'bbox': (388, 706, 84, 26), 'method': 'polygon'}, {'text': '1.5-2小时', 'confidence': 0.9970284700393677, 'polygon': [[643.0, 706.0], [742.0, 706.0], [742.0, 727.0], [643.0, 727.0]], 'bbox': (643, 706, 100, 22), 'method': 'polygon'}, {'text': '日常轻微办公', 'confidence': 0.9954341053962708, 'polygon': [[107.0, 758.0], [235.0, 758.0], [235.0, 781.0], [107.0, 781.0]], 'bbox': (107, 758, 129, 24), 'method': 'polygon'}, {'text': '从容面对繁重的工作', 'confidence': 0.995532751083374, 'polygon': [[333.0, 758.0], [526.0, 758.0], [526.0, 781.0], [333.0, 781.0]], 'bbox': (333, 758, 194, 24), 'method': 'polygon'}, {'text': '看电影听音乐玩游戏', 'confidence': 0.9980283379554749, 'polygon': [[592.0, 758.0], [786.0, 758.0], [786.0, 781.0], [592.0, 781.0]], 'bbox': (592, 758, 195, 24), 'method': 'polygon'}, {'text': '放电率：13000mW左右', 'confidence': 0.9922302961349487, 'polygon': [[56.0, 788.0], [286.0, 788.0], [286.0, 811.0], [56.0, 811.0]], 'bbox': (56, 788, 231, 24), 'method': 'polygon'}, {'text': '放电率：20000mW左右', 'confidence': 0.9919224977493286, 'polygon': [[314.0, 787.0], [545.0, 788.0], [544.0, 811.0], [314.0, 810.0]], 'bbox': (314, 787, 232, 25), 'method': 'polygon'}, {'text': '放电率：30000mW左右', 'confidence': 0.9945681691169739, 'polygon': [[574.0, 787.0], [803.0, 788.0], [803.0, 811.0], [574.0, 810.0]], 'bbox': (574, 787, 230, 25), 'method': 'polygon'}, {'text': '温馨提示', 'confidence': 0.9975357055664062, 'polygon': [[375.0, 888.0], [486.0, 888.0], [486.0, 920.0], [375.0, 920.0]], 'bbox': (375, 888, 112, 33), 'method': 'polygon'}, {'text': '新电池出厂前都会有部分养机电量，此电量主要是保证电池在存放中具有活性', 'confidence': 0.9956708550453186, 'polygon': [[78.0, 951.0], [777.0, 951.0], [777.0, 971.0], [78.0, 971.0]], 'bbox': (78, 951, 700, 21), 'method': 'polygon'}, {'text': '您收到电池后，需要完全充放电5次及以上才能达到正常使用水平。', 'confidence': 0.9904487729072571, 'polygon': [[134.0, 995.0], [721.0, 995.0], [721.0, 1015.0], [134.0, 1015.0]], 'bbox': (134, 995, 588, 21), 'method': 'polygon'}] +[2026-03-02 20:50:52,098] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 5 OCR raw 데이터 메모리 저장 완료: 22개 텍스트 +[2026-03-02 20:50:52,098] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.2%): '轻松应对各种场景' +[2026-03-02 20:50:52,101] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.9%): '您的需求我们都知道' +[2026-03-02 20:50:52,101] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'MEETTHEDAILYNEEDSREECTTHERTUALLABELATTERYLARGERCAPACITY' +[2026-03-02 20:50:52,101] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'STRONGER,STRONGER' +[2026-03-02 20:50:52,104] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '休闲' +[2026-03-02 20:50:52,104] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '办公' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '娱乐' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'LEISURE' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'OFFICE' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'ENTERTAINMENT' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '3-4小时' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '2-3小时' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '1.5-2小时' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '日常轻微办公' +[2026-03-02 20:50:52,105] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '从容面对繁重的工作' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '看电影听音乐玩游戏' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.2%): '放电率：13000mW左右' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.2%): '放电率：20000mW左右' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '放电率：30000mW左右' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '温馨提示' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '新电池出厂前都会有部分养机电量，此电量主要是保证电池在存放中具有活性' +[2026-03-02 20:50:52,106] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.0%): '您收到电池后，需要完全充放电5次及以上才能达到正常使用水平。' +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 17/22개 (신뢰도 + & 중국어) +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '轻松应对各种场景', 'confidence': 0.9915658235549927, 'polygon': [[87.0, 104.0], [770.0, 106.0], [770.0, 180.0], [86.0, 178.0]], 'bbox': (86, 104, 685, 77), 'method': 'polygon'}, {'text': '您的需求我们都知道', 'confidence': 0.9891422986984253, 'polygon': [[273.0, 219.0], [588.0, 219.0], [588.0, 250.0], [273.0, 250.0]], 'bbox': (273, 219, 316, 32), 'method': 'polygon'}, {'text': '休闲', 'confidence': 0.9994382262229919, 'polygon': [[141.0, 382.0], [201.0, 382.0], [201.0, 413.0], [141.0, 413.0]], 'bbox': (141, 382, 61, 32), 'method': 'polygon'}, {'text': '办公', 'confidence': 0.9973188042640686, 'polygon': [[397.0, 382.0], [459.0, 382.0], [459.0, 413.0], [397.0, 413.0]], 'bbox': (397, 382, 63, 32), 'method': 'polygon'}, {'text': '娱乐', 'confidence': 0.9990744590759277, 'polygon': [[656.0, 380.0], [720.0, 380.0], [720.0, 416.0], [656.0, 416.0]], 'bbox': (656, 380, 65, 37), 'method': 'polygon'}, {'text': '3-4小时', 'confidence': 0.9945409893989563, 'polygon': [[134.0, 707.0], [218.0, 704.0], [219.0, 729.0], [135.0, 732.0]], 'bbox': (134, 704, 86, 29), 'method': 'polygon'}, {'text': '2-3小时', 'confidence': 0.9951154589653015, 'polygon': [[388.0, 706.0], [471.0, 706.0], [471.0, 731.0], [388.0, 731.0]], 'bbox': (388, 706, 84, 26), 'method': 'polygon'}, {'text': '1.5-2小时', 'confidence': 0.9970284700393677, 'polygon': [[643.0, 706.0], [742.0, 706.0], [742.0, 727.0], [643.0, 727.0]], 'bbox': (643, 706, 100, 22), 'method': 'polygon'}, {'text': '日常轻微办公', 'confidence': 0.9954341053962708, 'polygon': [[107.0, 758.0], [235.0, 758.0], [235.0, 781.0], [107.0, 781.0]], 'bbox': (107, 758, 129, 24), 'method': 'polygon'}, {'text': '从容面对繁重的工作', 'confidence': 0.995532751083374, 'polygon': [[333.0, 758.0], [526.0, 758.0], [526.0, 781.0], [333.0, 781.0]], 'bbox': (333, 758, 194, 24), 'method': 'polygon'}, {'text': '看电影听音乐玩游戏', 'confidence': 0.9980283379554749, 'polygon': [[592.0, 758.0], [786.0, 758.0], [786.0, 781.0], [592.0, 781.0]], 'bbox': (592, 758, 195, 24), 'method': 'polygon'}, {'text': '放电率：13000mW左右', 'confidence': 0.9922302961349487, 'polygon': [[56.0, 788.0], [286.0, 788.0], [286.0, 811.0], [56.0, 811.0]], 'bbox': (56, 788, 231, 24), 'method': 'polygon'}, {'text': '放电率：20000mW左右', 'confidence': 0.9919224977493286, 'polygon': [[314.0, 787.0], [545.0, 788.0], [544.0, 811.0], [314.0, 810.0]], 'bbox': (314, 787, 232, 25), 'method': 'polygon'}, {'text': '放电率：30000mW左右', 'confidence': 0.9945681691169739, 'polygon': [[574.0, 787.0], [803.0, 788.0], [803.0, 811.0], [574.0, 810.0]], 'bbox': (574, 787, 230, 25), 'method': 'polygon'}, {'text': '温馨提示', 'confidence': 0.9975357055664062, 'polygon': [[375.0, 888.0], [486.0, 888.0], [486.0, 920.0], [375.0, 920.0]], 'bbox': (375, 888, 112, 33), 'method': 'polygon'}, {'text': '新电池出厂前都会有部分养机电量，此电量主要是保证电池在存放中具有活性', 'confidence': 0.9956708550453186, 'polygon': [[78.0, 951.0], [777.0, 951.0], [777.0, 971.0], [78.0, 971.0]], 'bbox': (78, 951, 700, 21), 'method': 'polygon'}, {'text': '您收到电池后，需要完全充放电5次及以上才能达到正常使用水平。', 'confidence': 0.9904487729072571, 'polygon': [[134.0, 995.0], [721.0, 995.0], [721.0, 1015.0], [134.0, 1015.0]], 'bbox': (134, 995, 588, 21), 'method': 'polygon'}] +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 17개 필터링 완료 +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['참고: 적합한 배터리 모델이 많이 있으므로 하나씩 나열할 수 없습니다. 질문이 있으시면 고객 서비스에 문의하십시오.', '배터리 기술에 집중', '디자인부터 소재선택, 생산부터 품질검사까지,', '항상 업계에서 가장 엄격한 표준을 충족하십시오.', '고품질 칩은 안전하고 안정적입니다.', '스마트 보안 칩은 고품질 회로 기판을 사용하며 원본과 호환됩니다.'] +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '참고: 적합한 배터리 모델이 많이 있으므로 하나씩 나열할 수 없습니다. 질문이 있으시면 고객 서비스에 문의하십시오.' +[2026-03-02 20:50:52,107] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['참고:', '적합한', '배터리', '모델이', '많이', '있으므로', '하나씩', '나열할', '수', '없습니다.', '질문이', '있으시면', '고객', '서비스에', '문의하십시오.'] +[2026-03-02 20:50:52,108] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '참고: 적합한 배터리 모델이 많이 있으므로 하나씩 나열할 수 없습니다. 질문이 있으시면 고객 서비스에 문의하십시오.' +[2026-03-02 20:50:52,108] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '배터리 기술에 집중' +[2026-03-02 20:50:52,108] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['배터리', '기술에', '집중'] +[2026-03-02 20:50:52,108] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '배터리 기술에 집중' +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '디자인부터 소재선택, 생산부터 품질검사까지,' +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['디자인부터', '소재선택,', '생산부터', '품질검사까지,'] +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '디자인부터 소재선택, 생산부터 품질검사까지,' +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '항상 업계에서 가장 엄격한 표준을 충족하십시오.' +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['항상', '업계에서', '가장', '엄격한', '표준을', '충족하십시오.'] +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '항상 업계에서 가장 엄격한 표준을 충족하십시오.' +[2026-03-02 20:50:52,109] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '고품질 칩은 안전하고 안정적입니다.' +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['고품질', '칩은', '안전하고', '안정적입니다.'] +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '고품질 칩은 안전하고 안정적입니다.' +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '스마트 보안 칩은 고품질 회로 기판을 사용하며 원본과 호환됩니다.' +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['스마트', '보안', '칩은', '고품질', '회로', '기판을', '사용하며', '원본과', '호환됩니다.'] +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '스마트 보안 칩은 고품질 회로 기판을 사용하며 원본과 호환됩니다.' +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 6개 텍스트 처리 완료 +[2026-03-02 20:50:52,110] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 4 치환됨 +[2026-03-02 20:50:52,116] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.172, comps=4, min_center_dist=0.095 → external_request +[2026-03-02 20:50:52,117] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 6 +[2026-03-02 20:50:52,117] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:52,117] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:52,117] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:52,161] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:52,269] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:53,365] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:50:53,369] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11093.0MB -> 11100.9MB (+7.8MB, +0.1%) - 방법: external_request +[2026-03-02 20:50:53,369] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:50:53,470] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:50:53,470] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:50:53,470] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:50:54,126] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_4.webp +[2026-03-02 20:50:54,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 4 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_4.webp +[2026-03-02 20:50:54,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 10209.0ms | download=0.0ms | ocr=2738.9ms | translate=4989.2ms | mask=606.3ms | inpaint=1256.6ms(external_request/SERVER) | render=100.1ms | save=608.4ms +[2026-03-02 20:50:54,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:50:54,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=3a13571d-2435-4d11-b496-5f9812739032 +[2026-03-02 20:50:54,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=3a13571d-2435-4d11-b496-5f9812739032 +[2026-03-02 20:50:54,132] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['다양한 시나리오에 쉽게 대처', '우리 모두는 귀하의 요구 사항을 알고 있습니다.', '레저', '사무실', '엔터테인먼트', '3~4시간', '2~3시간', '1.5~2시간', '매일 가벼운 사무', '무거운 작업도 쉽게 처리하세요', '영화를 보고, 음악을 듣고, 게임을 해보세요.', '방전율: 약 13000mW', '방전율: 약 20000mW', '방전율: 약 30000mW', '따뜻한 알림', '새 배터리는 공장에서 출고되기 전에 약간의 유지 관리 능력을 갖습니다. 이 전원은 주로 보관 중에 배터리가 활성화되도록 하기 위한 것입니다.', '배터리를 받은 후 정상적인 사용 수준에 도달하려면 5회 이상 완전히 충전하고 방전해야 합니다.'] +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '다양한 시나리오에 쉽게 대처' +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['다양한', '시나리오에', '쉽게', '대처'] +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '다양한 시나리오에 쉽게 대처' +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '우리 모두는 귀하의 요구 사항을 알고 있습니다.' +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['우리', '모두는', '귀하의', '요구', '사항을', '알고', '있습니다.'] +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '우리 모두는 귀하의 요구 사항을 알고 있습니다.' +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '레저' +[2026-03-02 20:50:54,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['레저'] +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '레저' +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '사무실' +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['사무실'] +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '사무실' +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '엔터테인먼트' +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['엔터테인먼트'] +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '엔터테인먼트' +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '3~4시간' +[2026-03-02 20:50:54,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['3~4시간'] +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '3~4시간' +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '2~3시간' +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['2~3시간'] +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '2~3시간' +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '1.5~2시간' +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['1.5~2시간'] +[2026-03-02 20:50:54,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '1.5~2시간' +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '매일 가벼운 사무' +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['매일', '가벼운', '사무'] +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '매일 가벼운 사무' +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '무거운 작업도 쉽게 처리하세요' +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['무거운', '작업도', '쉽게', '처리하세요'] +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '무거운 작업도 쉽게 처리하세요' +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '영화를 보고, 음악을 듣고, 게임을 해보세요.' +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['영화를', '보고,', '음악을', '듣고,', '게임을', '해보세요.'] +[2026-03-02 20:50:54,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '영화를 보고, 음악을 듣고, 게임을 해보세요.' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '방전율: 약 13000mW' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['방전율:', '약', '13000mW'] +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '방전율: 약 13000mW' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '방전율: 약 20000mW' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['방전율:', '약', '20000mW'] +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '방전율: 약 20000mW' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '방전율: 약 30000mW' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['방전율:', '약', '30000mW'] +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '방전율: 약 30000mW' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 원본 텍스트: '따뜻한 알림' +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 분리된 단어: ['따뜻한', '알림'] +[2026-03-02 20:50:54,137] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 변경 없음: '따뜻한 알림' +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 원본 텍스트: '새 배터리는 공장에서 출고되기 전에 약간의 유지 관리 능력을 갖습니다. 이 전원은 주로 보관 중에 배터리가 활성화되도록 하기 위한 것입니다.' +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 분리된 단어: ['새', '배터리는', '공장에서', '출고되기', '전에', '약간의', '유지', '관리', '능력을', '갖습니다.', '이', '전원은', '주로', '보관', '중에', '배터리가', '활성화되도록', '하기', '위한', '것입니다.'] +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 변경 없음: '새 배터리는 공장에서 출고되기 전에 약간의 유지 관리 능력을 갖습니다. 이 전원은 주로 보관 중에 배터리가 활성화되도록 하기 위한 것입니다.' +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 원본 텍스트: '배터리를 받은 후 정상적인 사용 수준에 도달하려면 5회 이상 완전히 충전하고 방전해야 합니다.' +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 분리된 단어: ['배터리를', '받은', '후', '정상적인', '사용', '수준에', '도달하려면', '5회', '이상', '완전히', '충전하고', '방전해야', '합니다.'] +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 변경 없음: '배터리를 받은 후 정상적인 사용 수준에 도달하려면 5회 이상 완전히 충전하고 방전해야 합니다.' +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 17개 텍스트 처리 완료 +[2026-03-02 20:50:54,138] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 5 치환됨 +[2026-03-02 20:50:54,140] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.233, comps=14, min_center_dist=0.031 → external_request +[2026-03-02 20:50:54,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 17 +[2026-03-02 20:50:54,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:54,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:54,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:54,194] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:54,299] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:55,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=0836b864-ce89-41ef-b380-dd15dc5444eb +[2026-03-02 20:50:55,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:55,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:55,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:55,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:55,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:55,334] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:50:55,337] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11086.8MB -> 11105.0MB (+18.2MB, +0.2%) - 방법: external_request +[2026-03-02 20:50:55,339] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:50:55,512] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:50:55,512] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:50:55,512] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:50:55,966] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_5.webp +[2026-03-02 20:50:55,969] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 5 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_5.webp +[2026-03-02 20:50:55,969] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 7003.5ms | download=1.0ms | ocr=2651.3ms | translate=2032.1ms | mask=33.0ms | inpaint=1197.0ms(external_request/SERVER) | render=174.0ms | save=407.0ms +[2026-03-02 20:50:55,969] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:50:55,969] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=02df4896-5b20-4f6e-b9d1-2541069a737f +[2026-03-02 20:50:55,969] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=02df4896-5b20-4f6e-b9d1-2541069a737f +[2026-03-02 20:50:55,970] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 6 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_005_O1CN018uGQQb1FsjxZamWl1_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:55,970] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_005_O1CN018uGQQb1FsjxZamWl1_!!692310543.jpg +[2026-03-02 20:50:55,973] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 6 원본 크기: 750x1171 +[2026-03-02 20:50:55,983] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 6 가로 크기 조정: 750x1171 → 860x1342 +[2026-03-02 20:50:55,990] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 6 크기 조정 완료: 860x1342 +[2026-03-02 20:50:55,991] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 6 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_005_O1CN018uGQQb1FsjxZamWl1_!!692310543_resized.jpg +[2026-03-02 20:50:55,995] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:57,033] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 1033.0ms +[2026-03-02 20:50:57,050] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 254.0ms, 인식: 739.0ms, 분류: 30.0ms +[2026-03-02 20:50:57,050] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11096.2MB -> 11101.0MB (+4.8MB, +0.0%) - 이미지 6 +[2026-03-02 20:50:57,067] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '12重安全保护', 'confidence': 0.9974347949028015, 'polygon': [[215.0, 143.0], [675.0, 143.0], [675.0, 210.0], [215.0, 210.0]], 'bbox': (215, 143, 461, 68), 'method': 'polygon'}, {'text': '盆', 'confidence': 0.5087405443191528, 'polygon': [[178.0, 365.0], [223.0, 365.0], [223.0, 410.0], [178.0, 410.0]], 'bbox': (178, 365, 46, 46), 'method': 'polygon'}, {'text': '过压保护', 'confidence': 0.9996292591094971, 'polygon': [[146.0, 445.0], [259.0, 445.0], [259.0, 478.0], [146.0, 478.0]], 'bbox': (146, 445, 114, 34), 'method': 'polygon'}, {'text': '过流保护', 'confidence': 0.9995509386062622, 'polygon': [[388.0, 446.0], [502.0, 446.0], [502.0, 481.0], [388.0, 481.0]], 'bbox': (388, 446, 115, 36), 'method': 'polygon'}, {'text': '短路保护', 'confidence': 0.998879075050354, 'polygon': [[629.0, 447.0], [743.0, 447.0], [743.0, 482.0], [629.0, 482.0]], 'bbox': (629, 447, 115, 36), 'method': 'polygon'}, {'text': '防静电保护', 'confidence': 0.9995673894882202, 'polygon': [[134.0, 685.0], [274.0, 685.0], [274.0, 714.0], [134.0, 714.0]], 'bbox': (134, 685, 141, 30), 'method': 'polygon'}, {'text': '温度异常保护', 'confidence': 0.9979144930839539, 'polygon': [[361.0, 684.0], [530.0, 684.0], [530.0, 717.0], [361.0, 717.0]], 'bbox': (361, 684, 170, 34), 'method': 'polygon'}, {'text': '功率保护', 'confidence': 0.9993990063667297, 'polygon': [[631.0, 684.0], [744.0, 684.0], [744.0, 717.0], [631.0, 717.0]], 'bbox': (631, 684, 114, 34), 'method': 'polygon'}, {'text': '过放电保护', 'confidence': 0.9982434511184692, 'polygon': [[133.0, 918.0], [276.0, 918.0], [276.0, 952.0], [133.0, 952.0]], 'bbox': (133, 918, 144, 35), 'method': 'polygon'}, {'text': '过充电保护', 'confidence': 0.9976310729980469, 'polygon': [[375.0, 921.0], [515.0, 921.0], [515.0, 951.0], [375.0, 951.0]], 'bbox': (375, 921, 141, 31), 'method': 'polygon'}, {'text': '电磁保护', 'confidence': 0.998640239238739, 'polygon': [[631.0, 918.0], [744.0, 918.0], [744.0, 953.0], [631.0, 953.0]], 'bbox': (631, 918, 114, 36), 'method': 'polygon'}, {'text': '充电时间保护', 'confidence': 0.9971632957458496, 'polygon': [[117.0, 1156.0], [288.0, 1153.0], [289.0, 1187.0], [118.0, 1190.0]], 'bbox': (117, 1153, 173, 38), 'method': 'polygon'}, {'text': '电芯智能防护', 'confidence': 0.9988138675689697, 'polygon': [[364.0, 1157.0], [528.0, 1157.0], [528.0, 1187.0], [364.0, 1187.0]], 'bbox': (364, 1157, 165, 31), 'method': 'polygon'}, {'text': '一级备用防护', 'confidence': 0.9978243708610535, 'polygon': [[601.0, 1155.0], [772.0, 1155.0], [772.0, 1188.0], [601.0, 1188.0]], 'bbox': (601, 1155, 172, 34), 'method': 'polygon'}] +[2026-03-02 20:50:57,067] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 6 OCR raw 데이터 메모리 저장 완료: 14개 텍스트 +[2026-03-02 20:50:57,070] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '12重安全保护' +[2026-03-02 20:50:57,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 50.9%): '盆' +[2026-03-02 20:50:57,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '过压保护' +[2026-03-02 20:50:57,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '过流保护' +[2026-03-02 20:50:57,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '短路保护' +[2026-03-02 20:50:57,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '防静电保护' +[2026-03-02 20:50:57,072] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '温度异常保护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '功率保护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '过放电保护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '过充电保护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '电磁保护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '充电时间保护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '电芯智能防护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '一级备用防护' +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 14/14개 (신뢰도 + & 중국어) +[2026-03-02 20:50:57,073] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '12重安全保护', 'confidence': 0.9974347949028015, 'polygon': [[215.0, 143.0], [675.0, 143.0], [675.0, 210.0], [215.0, 210.0]], 'bbox': (215, 143, 461, 68), 'method': 'polygon'}, {'text': '盆', 'confidence': 0.5087405443191528, 'polygon': [[178.0, 365.0], [223.0, 365.0], [223.0, 410.0], [178.0, 410.0]], 'bbox': (178, 365, 46, 46), 'method': 'polygon'}, {'text': '过压保护', 'confidence': 0.9996292591094971, 'polygon': [[146.0, 445.0], [259.0, 445.0], [259.0, 478.0], [146.0, 478.0]], 'bbox': (146, 445, 114, 34), 'method': 'polygon'}, {'text': '过流保护', 'confidence': 0.9995509386062622, 'polygon': [[388.0, 446.0], [502.0, 446.0], [502.0, 481.0], [388.0, 481.0]], 'bbox': (388, 446, 115, 36), 'method': 'polygon'}, {'text': '短路保护', 'confidence': 0.998879075050354, 'polygon': [[629.0, 447.0], [743.0, 447.0], [743.0, 482.0], [629.0, 482.0]], 'bbox': (629, 447, 115, 36), 'method': 'polygon'}, {'text': '防静电保护', 'confidence': 0.9995673894882202, 'polygon': [[134.0, 685.0], [274.0, 685.0], [274.0, 714.0], [134.0, 714.0]], 'bbox': (134, 685, 141, 30), 'method': 'polygon'}, {'text': '温度异常保护', 'confidence': 0.9979144930839539, 'polygon': [[361.0, 684.0], [530.0, 684.0], [530.0, 717.0], [361.0, 717.0]], 'bbox': (361, 684, 170, 34), 'method': 'polygon'}, {'text': '功率保护', 'confidence': 0.9993990063667297, 'polygon': [[631.0, 684.0], [744.0, 684.0], [744.0, 717.0], [631.0, 717.0]], 'bbox': (631, 684, 114, 34), 'method': 'polygon'}, {'text': '过放电保护', 'confidence': 0.9982434511184692, 'polygon': [[133.0, 918.0], [276.0, 918.0], [276.0, 952.0], [133.0, 952.0]], 'bbox': (133, 918, 144, 35), 'method': 'polygon'}, {'text': '过充电保护', 'confidence': 0.9976310729980469, 'polygon': [[375.0, 921.0], [515.0, 921.0], [515.0, 951.0], [375.0, 951.0]], 'bbox': (375, 921, 141, 31), 'method': 'polygon'}, {'text': '电磁保护', 'confidence': 0.998640239238739, 'polygon': [[631.0, 918.0], [744.0, 918.0], [744.0, 953.0], [631.0, 953.0]], 'bbox': (631, 918, 114, 36), 'method': 'polygon'}, {'text': '充电时间保护', 'confidence': 0.9971632957458496, 'polygon': [[117.0, 1156.0], [288.0, 1153.0], [289.0, 1187.0], [118.0, 1190.0]], 'bbox': (117, 1153, 173, 38), 'method': 'polygon'}, {'text': '电芯智能防护', 'confidence': 0.9988138675689697, 'polygon': [[364.0, 1157.0], [528.0, 1157.0], [528.0, 1187.0], [364.0, 1187.0]], 'bbox': (364, 1157, 165, 31), 'method': 'polygon'}, {'text': '一级备用防护', 'confidence': 0.9978243708610535, 'polygon': [[601.0, 1155.0], [772.0, 1155.0], [772.0, 1188.0], [601.0, 1188.0]], 'bbox': (601, 1155, 172, 34), 'method': 'polygon'}] +[2026-03-02 20:50:57,075] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 14개 필터링 완료 +[2026-03-02 20:50:57,076] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:57,076] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=9ea906ea-0ba4-47ce-b9aa-3ac5424cef78 +[2026-03-02 20:50:57,078] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:50:57,078] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:50:57,078] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:50:57,078] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:50:57,079] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:50:57,290] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 7 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_006_O1CN01SRL3wT1FsjxfYrwwP_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:50:57,290] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_006_O1CN01SRL3wT1FsjxfYrwwP_!!692310543.jpg +[2026-03-02 20:50:57,295] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 7 원본 크기: 750x1166 +[2026-03-02 20:50:57,302] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 7 가로 크기 조정: 750x1166 → 860x1337 +[2026-03-02 20:50:57,311] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 7 크기 조정 완료: 860x1337 +[2026-03-02 20:50:57,311] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 7 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_006_O1CN01SRL3wT1FsjxfYrwwP_!!692310543_resized.jpg +[2026-03-02 20:50:57,316] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:50:59,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 1823.0ms +[2026-03-02 20:50:59,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 270.0ms, 인식: 1516.0ms, 분류: 26.0ms +[2026-03-02 20:50:59,167] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11091.3MB -> 11168.0MB (+76.7MB, +0.7%) - 이미지 7 +[2026-03-02 20:50:59,167] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '产品实拍展示', 'confidence': 0.99440598487854, 'polygon': [[153.0, 121.0], [724.0, 124.0], [724.0, 210.0], [153.0, 207.0]], 'bbox': (153, 121, 572, 90), 'method': 'polygon'}, {'text': 'PRODUCTDETAILSDISPLAY', 'confidence': 0.9940453767776489, 'polygon': [[122.0, 247.0], [748.0, 247.0], [748.0, 280.0], [122.0, 280.0]], 'bbox': (122, 247, 627, 34), 'method': 'polygon'}, {'text': '精工细作', 'confidence': 0.998788595199585, 'polygon': [[233.0, 418.0], [426.0, 418.0], [426.0, 461.0], [233.0, 461.0]], 'bbox': (233, 418, 194, 44), 'method': 'polygon'}, {'text': '坚固耐用', 'confidence': 0.9994091391563416, 'polygon': [[453.0, 419.0], [639.0, 419.0], [639.0, 462.0], [453.0, 462.0]], 'bbox': (453, 419, 187, 44), 'method': 'polygon'}, {'text': '外壳采用耐高温抗磨损的ABS+PC', 'confidence': 0.9977625608444214, 'polygon': [[222.0, 528.0], [648.0, 529.0], [648.0, 559.0], [222.0, 557.0]], 'bbox': (222, 528, 427, 32), 'method': 'polygon'}, {'text': '合金环保材料打造做工精细，耐磨抗压', 'confidence': 0.9955678582191467, 'polygon': [[191.0, 581.0], [679.0, 581.0], [679.0, 609.0], [191.0, 609.0]], 'bbox': (191, 581, 489, 29), 'method': 'polygon'}, {'text': 'SHUO.2.B', 'confidence': 0.9244955778121948, 'polygon': [[78.0, 868.0], [139.0, 868.0], [139.0, 883.0], [78.0, 883.0]], 'bbox': (78, 868, 62, 16), 'method': 'polygon'}, {'text': 'Rating:+15.2V-57W', 'confidence': 0.8985471129417419, 'polygon': [[76.0, 880.0], [215.0, 880.0], [215.0, 900.0], [76.0, 900.0]], 'bbox': (76, 880, 140, 21), 'method': 'polygon'}, {'text': 'MODEL（星号/型号）:AA-PBVN4NP', 'confidence': 0.8782500624656677, 'polygon': [[264.0, 880.0], [410.0, 877.0], [410.0, 893.0], [265.0, 896.0]], 'bbox': (264, 877, 147, 20), 'method': 'polygon'}, {'text': 'RoHS', 'confidence': 0.9808260202407837, 'polygon': [[414.0, 879.0], [472.0, 879.0], [472.0, 904.0], [414.0, 904.0]], 'bbox': (414, 879, 59, 26), 'method': 'polygon'}, {'text': 'arie.Ersat', 'confidence': 0.8820827603340149, 'polygon': [[331.0, 929.0], [371.0, 929.0], [371.0, 943.0], [331.0, 943.0]], 'bbox': (331, 929, 41, 15), 'method': 'polygon'}] +[2026-03-02 20:50:59,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 7 OCR raw 데이터 메모리 저장 완료: 11개 텍스트 +[2026-03-02 20:50:59,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '产品实拍展示' +[2026-03-02 20:50:59,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'PRODUCTDETAILSDISPLAY' +[2026-03-02 20:50:59,168] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '精工细作' +[2026-03-02 20:50:59,169] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '坚固耐用' +[2026-03-02 20:50:59,169] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '外壳采用耐高温抗磨损的ABS+PC' +[2026-03-02 20:50:59,169] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '合金环保材料打造做工精细，耐磨抗压' +[2026-03-02 20:50:59,169] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'SHUO.2.B' +[2026-03-02 20:50:59,169] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'Rating:+15.2V-57W' +[2026-03-02 20:50:59,171] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 87.8%): 'MODEL（星号/型号）:AA-PBVN4NP' +[2026-03-02 20:50:59,171] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'RoHS' +[2026-03-02 20:50:59,172] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'arie.Ersat' +[2026-03-02 20:50:59,172] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 6/11개 (신뢰도 + & 중국어) +[2026-03-02 20:50:59,172] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '产品实拍展示', 'confidence': 0.99440598487854, 'polygon': [[153.0, 121.0], [724.0, 124.0], [724.0, 210.0], [153.0, 207.0]], 'bbox': (153, 121, 572, 90), 'method': 'polygon'}, {'text': '精工细作', 'confidence': 0.998788595199585, 'polygon': [[233.0, 418.0], [426.0, 418.0], [426.0, 461.0], [233.0, 461.0]], 'bbox': (233, 418, 194, 44), 'method': 'polygon'}, {'text': '坚固耐用', 'confidence': 0.9994091391563416, 'polygon': [[453.0, 419.0], [639.0, 419.0], [639.0, 462.0], [453.0, 462.0]], 'bbox': (453, 419, 187, 44), 'method': 'polygon'}, {'text': '外壳采用耐高温抗磨损的ABS+PC', 'confidence': 0.9977625608444214, 'polygon': [[222.0, 528.0], [648.0, 529.0], [648.0, 559.0], [222.0, 557.0]], 'bbox': (222, 528, 427, 32), 'method': 'polygon'}, {'text': '合金环保材料打造做工精细，耐磨抗压', 'confidence': 0.9955678582191467, 'polygon': [[191.0, 581.0], [679.0, 581.0], [679.0, 609.0], [191.0, 609.0]], 'bbox': (191, 581, 489, 29), 'method': 'polygon'}, {'text': 'MODEL（星号/型号）:AA-PBVN4NP', 'confidence': 0.8782500624656677, 'polygon': [[264.0, 880.0], [410.0, 877.0], [410.0, 893.0], [265.0, 896.0]], 'bbox': (264, 877, 147, 20), 'method': 'polygon'}] +[2026-03-02 20:50:59,172] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 6개 필터링 완료 +[2026-03-02 20:50:59,172] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:50:59,172] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['12개 계층의 보안 보호', '분지', '과전압 보호', '과전류 보호', '단락 보호', '정전기 방지 보호', '온도 이상 보호', '전원 보호', '과방 전 보호', '과충전 보호', '전자기 보호', '충전 시간 보호', '지능형 배터리 보호', '레벨 1 백업 보호'] +[2026-03-02 20:50:59,173] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:59,173] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '12개 계층의 보안 보호' +[2026-03-02 20:50:59,173] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['12개', '계층의', '보안', '보호'] +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '12개 계층의 보안 보호' +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '분지' +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['분지'] +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '분지' +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '과전압 보호' +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['과전압', '보호'] +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '과전압 보호' +[2026-03-02 20:50:59,174] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '과전류 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['과전류', '보호'] +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '과전류 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '단락 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['단락', '보호'] +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '단락 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '정전기 방지 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['정전기', '방지', '보호'] +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '정전기 방지 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '온도 이상 보호' +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['온도', '이상', '보호'] +[2026-03-02 20:50:59,175] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '온도 이상 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '전원 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['전원', '보호'] +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '전원 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '과방 전 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['과방', '전', '보호'] +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '과방 전 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '과충전 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['과충전', '보호'] +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '과충전 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '전자기 보호' +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['전자기', '보호'] +[2026-03-02 20:50:59,176] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '전자기 보호' +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '충전 시간 보호' +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['충전', '시간', '보호'] +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '충전 시간 보호' +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '지능형 배터리 보호' +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['지능형', '배터리', '보호'] +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '지능형 배터리 보호' +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '레벨 1 백업 보호' +[2026-03-02 20:50:59,177] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['레벨', '1', '백업', '보호'] +[2026-03-02 20:50:59,180] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '레벨 1 백업 보호' +[2026-03-02 20:50:59,183] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 14개 텍스트 처리 완료 +[2026-03-02 20:50:59,183] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 6 치환됨 +[2026-03-02 20:50:59,184] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.140, comps=14, min_center_dist=0.046 → external_request +[2026-03-02 20:50:59,185] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 14 +[2026-03-02 20:50:59,186] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:59,187] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:59,187] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:59,387] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['제품 실제 샷 디스플레이', '훌륭한 솜씨', '견고함과 내구성', '쉘은 고온 및 내마모성 ABS+PC로 제작되었습니다.', '환경 친화적인 합금 소재, 훌륭한 솜씨, 내마모성 및 내압성으로 제작되었습니다.', '모델(별표 / 모델):AA-PBVN4NP'] +[2026-03-02 20:50:59,387] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:50:59,387] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '제품 실제 샷 디스플레이' +[2026-03-02 20:50:59,388] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['제품', '실제', '샷', '디스플레이'] +[2026-03-02 20:50:59,389] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '제품 실제 샷 디스플레이' +[2026-03-02 20:50:59,389] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '훌륭한 솜씨' +[2026-03-02 20:50:59,389] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['훌륭한', '솜씨'] +[2026-03-02 20:50:59,389] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '훌륭한 솜씨' +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '견고함과 내구성' +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['견고함과', '내구성'] +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '견고함과 내구성' +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '쉘은 고온 및 내마모성 ABS+PC로 제작되었습니다.' +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['쉘은', '고온', '및', '내마모성', 'ABS+PC로', '제작되었습니다.'] +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '쉘은 고온 및 내마모성 ABS+PC로 제작되었습니다.' +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '환경 친화적인 합금 소재, 훌륭한 솜씨, 내마모성 및 내압성으로 제작되었습니다.' +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['환경', '친화적인', '합금', '소재,', '훌륭한', '솜씨,', '내마모성', '및', '내압성으로', '제작되었습니다.'] +[2026-03-02 20:50:59,390] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '환경 친화적인 합금 소재, 훌륭한 솜씨, 내마모성 및 내압성으로 제작되었습니다.' +[2026-03-02 20:50:59,391] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '모델(별표 / 모델):AA-PBVN4NP' +[2026-03-02 20:50:59,391] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['모델(별표', '/', '모델):AA-PBVN4NP'] +[2026-03-02 20:50:59,391] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '모델(별표 / 모델):AA-PBVN4NP' +[2026-03-02 20:50:59,391] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 6개 텍스트 처리 완료 +[2026-03-02 20:50:59,391] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 7 치환됨 +[2026-03-02 20:50:59,392] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:59,395] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.143, comps=4, min_center_dist=0.082 → external_request +[2026-03-02 20:50:59,395] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 6 +[2026-03-02 20:50:59,395] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:50:59,395] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:50:59,395] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:50:59,427] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:50:59,457] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:59,491] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:50:59,972] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:50:59,975] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11168.8MB -> 11180.3MB (+11.5MB, +0.1%) - 방법: external_request +[2026-03-02 20:50:59,976] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:51:00,123] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:51:00,124] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:51:00,124] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:51:00,413] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:51:00,416] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11166.6MB -> 11195.0MB (+28.4MB, +0.3%) - 방법: external_request +[2026-03-02 20:51:00,533] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_6.webp +[2026-03-02 20:51:00,536] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 6 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_6.webp +[2026-03-02 20:51:00,536] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 5381.0ms | download=1.0ms | ocr=1045.0ms | translate=2099.3ms | mask=24.0ms | inpaint=796.4ms(external_request/SERVER) | render=148.2ms | save=361.3ms +[2026-03-02 20:51:00,536] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:51:00,537] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=0836b864-ce89-41ef-b380-dd15dc5444eb +[2026-03-02 20:51:00,537] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=0836b864-ce89-41ef-b380-dd15dc5444eb +[2026-03-02 20:51:00,537] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:51:00,609] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:51:00,609] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:51:00,609] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:51:01,022] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_7.webp +[2026-03-02 20:51:01,025] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 7 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_7.webp +[2026-03-02 20:51:01,025] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 3944.8ms | download=16.0ms | ocr=1835.0ms | translate=221.4ms | mask=30.1ms | inpaint=1142.5ms(external_request/SERVER) | render=71.0ms | save=365.5ms +[2026-03-02 20:51:01,025] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:51:01,025] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=9ea906ea-0ba4-47ce-b9aa-3ac5424cef78 +[2026-03-02 20:51:01,026] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=9ea906ea-0ba4-47ce-b9aa-3ac5424cef78 +[2026-03-02 20:51:01,797] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=acb0a920-f86b-488e-aaa7-670832486116 +[2026-03-02 20:51:01,801] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:51:01,801] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:51:01,801] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:51:01,802] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:51:01,802] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:51:02,044] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=67666d64-47c1-4eb1-910b-7aec9848c76b +[2026-03-02 20:51:02,046] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:51:02,047] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:51:02,047] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:51:02,047] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:51:02,047] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:51:02,074] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 8 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_007_O1CN01x3xU9M1FsjxTHwtoe_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:51:02,074] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_007_O1CN01x3xU9M1FsjxTHwtoe_!!692310543.jpg +[2026-03-02 20:51:02,078] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 8 원본 크기: 750x855 +[2026-03-02 20:51:02,083] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 8 가로 크기 조정: 750x855 → 860x980 +[2026-03-02 20:51:02,090] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 8 크기 조정 완료: 860x980 +[2026-03-02 20:51:02,091] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 8 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_007_O1CN01x3xU9M1FsjxTHwtoe_!!692310543_resized.jpg +[2026-03-02 20:51:02,094] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:51:02,746] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 649.0ms +[2026-03-02 20:51:02,757] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 308.0ms, 인식: 328.0ms, 분류: 8.0ms +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11179.2MB -> 11175.6MB (-3.6MB, -0.0%) - 이미지 8 +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '精准设计方案', 'confidence': 0.998397171497345, 'polygon': [[190.0, 62.0], [471.0, 64.0], [471.0, 103.0], [190.0, 101.0]], 'bbox': (190, 62, 282, 42), 'method': 'polygon'}, {'text': '更加匹配', 'confidence': 0.9982356429100037, 'polygon': [[495.0, 63.0], [679.0, 63.0], [679.0, 102.0], [495.0, 102.0]], 'bbox': (495, 63, 185, 40), 'method': 'polygon'}, {'text': '我们家电池采用一比一设计', 'confidence': 0.9946824908256531, 'polygon': [[258.0, 207.0], [590.0, 207.0], [590.0, 232.0], [258.0, 232.0]], 'bbox': (258, 207, 333, 26), 'method': 'polygon'}, {'text': '方案与您的电脑更加匹配', 'confidence': 0.9942060708999634, 'polygon': [[273.0, 258.0], [578.0, 258.0], [578.0, 283.0], [273.0, 283.0]], 'bbox': (273, 258, 306, 26), 'method': 'polygon'}] +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 8 OCR raw 데이터 메모리 저장 완료: 4개 텍스트 +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '精准设计方案' +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '更加匹配' +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '我们家电池采用一比一设计' +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '方案与您的电脑更加匹配' +[2026-03-02 20:51:02,758] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 4/4개 (신뢰도 + & 중국어) +[2026-03-02 20:51:02,759] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '精准设计方案', 'confidence': 0.998397171497345, 'polygon': [[190.0, 62.0], [471.0, 64.0], [471.0, 103.0], [190.0, 101.0]], 'bbox': (190, 62, 282, 42), 'method': 'polygon'}, {'text': '更加匹配', 'confidence': 0.9982356429100037, 'polygon': [[495.0, 63.0], [679.0, 63.0], [679.0, 102.0], [495.0, 102.0]], 'bbox': (495, 63, 185, 40), 'method': 'polygon'}, {'text': '我们家电池采用一比一设计', 'confidence': 0.9946824908256531, 'polygon': [[258.0, 207.0], [590.0, 207.0], [590.0, 232.0], [258.0, 232.0]], 'bbox': (258, 207, 333, 26), 'method': 'polygon'}, {'text': '方案与您的电脑更加匹配', 'confidence': 0.9942060708999634, 'polygon': [[273.0, 258.0], [578.0, 258.0], [578.0, 283.0], [273.0, 283.0]], 'bbox': (273, 258, 306, 26), 'method': 'polygon'}] +[2026-03-02 20:51:02,759] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 4개 필터링 완료 +[2026-03-02 20:51:02,760] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:51:02,760] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 9 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_008_O1CN01rYnf1A1FsjxfYp004_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:51:02,761] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_008_O1CN01rYnf1A1FsjxfYp004_!!692310543.jpg +[2026-03-02 20:51:02,768] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 9 원본 크기: 750x839 +[2026-03-02 20:51:02,770] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 9 가로 크기 조정: 750x839 → 860x962 +[2026-03-02 20:51:02,777] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 9 크기 조정 완료: 860x962 +[2026-03-02 20:51:02,778] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 9 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_008_O1CN01rYnf1A1FsjxfYp004_!!692310543_resized.jpg +[2026-03-02 20:51:02,782] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:51:05,802] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 3014.7ms +[2026-03-02 20:51:05,822] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 351.0ms, 인식: 2610.7ms, 분류: 39.0ms +[2026-03-02 20:51:05,833] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11175.4MB -> 11182.4MB (+7.0MB, +0.1%) - 이미지 9 +[2026-03-02 20:51:05,834] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '安全检测安', 'confidence': 0.990048885345459, 'polygon': [[238.0, 60.0], [461.0, 60.0], [461.0, 101.0], [238.0, 101.0]], 'bbox': (238, 60, 224, 42), 'method': 'polygon'}, {'text': '安全放心', 'confidence': 0.9983964562416077, 'polygon': [[441.0, 60.0], [630.0, 60.0], [630.0, 101.0], [441.0, 101.0]], 'bbox': (441, 60, 190, 42), 'method': 'polygon'}, {'text': '电路保护设计，只为使用安心', 'confidence': 0.9979783296585083, 'polygon': [[251.0, 170.0], [623.0, 171.0], [623.0, 195.0], [251.0, 194.0]], 'bbox': (251, 170, 373, 26), 'method': 'polygon'}, {'text': '产品已通过CE、FCC、PSE、ROHS等认证', 'confidence': 0.9867547154426575, 'polygon': [[168.0, 222.0], [704.0, 222.0], [704.0, 247.0], [168.0, 247.0]], 'bbox': (168, 222, 537, 26), 'method': 'polygon'}, {'text': '4ICP3/64/120', 'confidence': 0.9462878704071045, 'polygon': [[630.0, 431.0], [749.0, 416.0], [751.0, 433.0], [633.0, 449.0]], 'bbox': (630, 416, 122, 34), 'method': 'polygon'}, {'text': 'SHUO.Z.B', 'confidence': 0.975742757320404, 'polygon': [[137.0, 453.0], [296.0, 433.0], [298.0, 454.0], [140.0, 474.0]], 'bbox': (137, 433, 162, 42), 'method': 'polygon'}, {'text': 'Rating:+15.2V---57W', 'confidence': 0.9401453733444214, 'polygon': [[147.0, 475.0], [497.0, 429.0], [500.0, 456.0], [150.0, 502.0]], 'bbox': (147, 429, 354, 74), 'method': 'polygon'}, {'text': 'RechargeableLi-PolymerBatteryPack', 'confidence': 0.9910144209861755, 'polygon': [[160.0, 498.0], [563.0, 445.0], [565.0, 466.0], [163.0, 519.0]], 'bbox': (160, 445, 406, 75), 'method': 'polygon'}, {'text': 'Capacity:3750mAh(TYP)/3550mAh(MIN)', 'confidence': 0.9379695653915405, 'polygon': [[172.0, 515.0], [623.0, 455.0], [626.0, 478.0], [175.0, 538.0]], 'bbox': (172, 455, 455, 84), 'method': 'polygon'}, {'text': 'VORSICHT!', 'confidence': 0.9590327739715576, 'polygon': [[186.0, 538.0], [325.0, 521.0], [327.0, 542.0], [189.0, 559.0]], 'bbox': (186, 521, 142, 39), 'method': 'polygon'}, {'text': 'Explosionsgetahrbei unsachgemaBenAustauschderBatterie', 'confidence': 0.9749507308006287, 'polygon': [[196.0, 557.0], [859.0, 462.0], [859.0, 488.0], [199.0, 583.0]], 'bbox': (196, 462, 664, 122), 'method': 'polygon'}, {'text': '注意/注意：', 'confidence': 0.9554426670074463, 'polygon': [[244.0, 621.0], [376.0, 602.0], [379.0, 624.0], [247.0, 642.0]], 'bbox': (244, 602, 136, 41), 'method': 'polygon'}, {'text': '池必须接照废弃物管理办法回收处理', 'confidence': 0.9363356828689575, 'polygon': [[344.0, 634.0], [678.0, 579.0], [681.0, 598.0], [347.0, 653.0]], 'bbox': (344, 579, 338, 75), 'method': 'polygon'}, {'text': '池漫水后使用，请勿自行拆解或组装电池、', 'confidence': 0.9297481179237366, 'polygon': [[362.0, 650.0], [729.0, 588.0], [732.0, 608.0], [366.0, 671.0]], 'bbox': (362, 588, 371, 84), 'method': 'polygon'}, {'text': '耀毒。挤压或投入火中若出现严重鼓胀，请勿继纟', 'confidence': 0.9054036736488342, 'polygon': [[409.0, 662.0], [857.0, 584.0], [859.0, 605.0], [413.0, 683.0]], 'bbox': (409, 584, 451, 100), 'method': 'polygon'}, {'text': '池置手60爆氏度以上的环境中，', 'confidence': 0.8659030199050903, 'polygon': [[394.0, 685.0], [684.0, 634.0], [687.0, 654.0], [398.0, 706.0]], 'bbox': (394, 634, 294, 73), 'method': 'polygon'}, {'text': '东美市领之宝电子', 'confidence': 0.8385457992553711, 'polygon': [[377.0, 710.0], [548.0, 680.0], [552.0, 700.0], [380.0, 730.0]], 'bbox': (377, 680, 176, 51), 'method': 'polygon'}] +[2026-03-02 20:51:05,836] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 9 OCR raw 데이터 메모리 저장 완료: 17개 텍스트 +[2026-03-02 20:51:05,836] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.0%): '安全检测安' +[2026-03-02 20:51:05,836] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '安全放心' +[2026-03-02 20:51:05,838] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '电路保护设计，只为使用安心' +[2026-03-02 20:51:05,839] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.7%): '产品已通过CE、FCC、PSE、ROHS等认证' +[2026-03-02 20:51:05,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '4ICP3/64/120' +[2026-03-02 20:51:05,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'SHUO.Z.B' +[2026-03-02 20:51:05,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'Rating:+15.2V---57W' +[2026-03-02 20:51:05,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'RechargeableLi-PolymerBatteryPack' +[2026-03-02 20:51:05,840] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'Capacity:3750mAh(TYP)/3550mAh(MIN)' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'VORSICHT!' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'Explosionsgetahrbei unsachgemaBenAustauschderBatterie' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 95.5%): '注意/注意：' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 93.6%): '池必须接照废弃物管理办法回收处理' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 93.0%): '池漫水后使用，请勿自行拆解或组装电池、' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 90.5%): '耀毒。挤压或投入火中若出现严重鼓胀，请勿继纟' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 86.6%): '池置手60爆氏度以上的环境中，' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 83.9%): '东美市领之宝电子' +[2026-03-02 20:51:05,841] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 10/17개 (신뢰도 + & 중국어) +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '安全检测安', 'confidence': 0.990048885345459, 'polygon': [[238.0, 60.0], [461.0, 60.0], [461.0, 101.0], [238.0, 101.0]], 'bbox': (238, 60, 224, 42), 'method': 'polygon'}, {'text': '安全放心', 'confidence': 0.9983964562416077, 'polygon': [[441.0, 60.0], [630.0, 60.0], [630.0, 101.0], [441.0, 101.0]], 'bbox': (441, 60, 190, 42), 'method': 'polygon'}, {'text': '电路保护设计，只为使用安心', 'confidence': 0.9979783296585083, 'polygon': [[251.0, 170.0], [623.0, 171.0], [623.0, 195.0], [251.0, 194.0]], 'bbox': (251, 170, 373, 26), 'method': 'polygon'}, {'text': '产品已通过CE、FCC、PSE、ROHS等认证', 'confidence': 0.9867547154426575, 'polygon': [[168.0, 222.0], [704.0, 222.0], [704.0, 247.0], [168.0, 247.0]], 'bbox': (168, 222, 537, 26), 'method': 'polygon'}, {'text': '注意/注意：', 'confidence': 0.9554426670074463, 'polygon': [[244.0, 621.0], [376.0, 602.0], [379.0, 624.0], [247.0, 642.0]], 'bbox': (244, 602, 136, 41), 'method': 'polygon'}, {'text': '池必须接照废弃物管理办法回收处理', 'confidence': 0.9363356828689575, 'polygon': [[344.0, 634.0], [678.0, 579.0], [681.0, 598.0], [347.0, 653.0]], 'bbox': (344, 579, 338, 75), 'method': 'polygon'}, {'text': '池漫水后使用，请勿自行拆解或组装电池、', 'confidence': 0.9297481179237366, 'polygon': [[362.0, 650.0], [729.0, 588.0], [732.0, 608.0], [366.0, 671.0]], 'bbox': (362, 588, 371, 84), 'method': 'polygon'}, {'text': '耀毒。挤压或投入火中若出现严重鼓胀，请勿继纟', 'confidence': 0.9054036736488342, 'polygon': [[409.0, 662.0], [857.0, 584.0], [859.0, 605.0], [413.0, 683.0]], 'bbox': (409, 584, 451, 100), 'method': 'polygon'}, {'text': '池置手60爆氏度以上的环境中，', 'confidence': 0.8659030199050903, 'polygon': [[394.0, 685.0], [684.0, 634.0], [687.0, 654.0], [398.0, 706.0]], 'bbox': (394, 634, 294, 73), 'method': 'polygon'}, {'text': '东美市领之宝电子', 'confidence': 0.8385457992553711, 'polygon': [[377.0, 710.0], [548.0, 680.0], [552.0, 700.0], [380.0, 730.0]], 'bbox': (377, 680, 176, 51), 'method': 'polygon'}] +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 10개 필터링 완료 +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['정확한 디자인 계획', '더 나은 일치', '우리 배터리는 일대일 디자인을 채택합니다.', '이 솔루션은 귀하의 컴퓨터에 더 적합합니다.'] +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '정확한 디자인 계획' +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['정확한', '디자인', '계획'] +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '정확한 디자인 계획' +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '더 나은 일치' +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['더', '나은', '일치'] +[2026-03-02 20:51:05,842] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '더 나은 일치' +[2026-03-02 20:51:05,843] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '우리 배터리는 일대일 디자인을 채택합니다.' +[2026-03-02 20:51:05,846] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['우리', '배터리는', '일대일', '디자인을', '채택합니다.'] +[2026-03-02 20:51:05,847] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '우리 배터리는 일대일 디자인을 채택합니다.' +[2026-03-02 20:51:05,848] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '이 솔루션은 귀하의 컴퓨터에 더 적합합니다.' +[2026-03-02 20:51:05,850] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['이', '솔루션은', '귀하의', '컴퓨터에', '더', '적합합니다.'] +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '이 솔루션은 귀하의 컴퓨터에 더 적합합니다.' +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 4개 텍스트 처리 완료 +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 8 치환됨 +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.093, comps=2, min_center_dist=0.124 → external_request +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 4 +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:51:05,851] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:51:05,888] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:51:05,954] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ 실행 중인 작업(2): acb0a920-f86b-488e-aaa7-670832486116(4.1s), 67666d64-47c1-4eb1-910b-7aec9848c76b(3.9s) +[2026-03-02 20:51:05,960] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:51:06,149] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['안전점검', '안전하고 보안됨', '마음의 평화를 위한 회로 보호 설계', '제품이 CE를 통과했습니다. / FCC / PSE / ROHS 및 기타 인증', '참고 / 참고:', '수영장은 폐기물 관리 규정에 따라 재활용 및 폐기되어야 합니다.', '수영장에 물이 잠긴 후 사용하기 전에 배터리를 직접 분해하거나 조립하지 마십시오.', '야오 독.압착하거나 불 속에 던진 후 심하게 부풀어 오르는 경우에는 계속하지 마십시오.', '수영장은 섭씨 60도 이상의 환경에 설치해야 합니다.', '동메이 링즈바오 전자'] +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '안전점검' +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['안전점검'] +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '안전점검' +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '안전하고 보안됨' +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['안전하고', '보안됨'] +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '안전하고 보안됨' +[2026-03-02 20:51:06,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '마음의 평화를 위한 회로 보호 설계' +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['마음의', '평화를', '위한', '회로', '보호', '설계'] +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '마음의 평화를 위한 회로 보호 설계' +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '제품이 CE를 통과했습니다. / FCC / PSE / ROHS 및 기타 인증' +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['제품이', 'CE를', '통과했습니다.', '/', 'FCC', '/', 'PSE', '/', 'ROHS', '및', '기타', '인증'] +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '제품이 CE를 통과했습니다. / FCC / PSE / ROHS 및 기타 인증' +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '참고 / 참고:' +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['참고', '/', '참고:'] +[2026-03-02 20:51:06,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '참고 / 참고:' +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '수영장은 폐기물 관리 규정에 따라 재활용 및 폐기되어야 합니다.' +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['수영장은', '폐기물', '관리', '규정에', '따라', '재활용', '및', '폐기되어야', '합니다.'] +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '수영장은 폐기물 관리 규정에 따라 재활용 및 폐기되어야 합니다.' +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '수영장에 물이 잠긴 후 사용하기 전에 배터리를 직접 분해하거나 조립하지 마십시오.' +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['수영장에', '물이', '잠긴', '후', '사용하기', '전에', '배터리를', '직접', '분해하거나', '조립하지', '마십시오.'] +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '수영장에 물이 잠긴 후 사용하기 전에 배터리를 직접 분해하거나 조립하지 마십시오.' +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '야오 독.압착하거나 불 속에 던진 후 심하게 부풀어 오르는 경우에는 계속하지 마십시오.' +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['야오', '독.압착하거나', '불', '속에', '던진', '후', '심하게', '부풀어', '오르는', '경우에는', '계속하지', '마십시오.'] +[2026-03-02 20:51:06,152] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '야오 독.압착하거나 불 속에 던진 후 심하게 부풀어 오르는 경우에는 계속하지 마십시오.' +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '수영장은 섭씨 60도 이상의 환경에 설치해야 합니다.' +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['수영장은', '섭씨', '60도', '이상의', '환경에', '설치해야', '합니다.'] +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '수영장은 섭씨 60도 이상의 환경에 설치해야 합니다.' +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '동메이 링즈바오 전자' +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['동메이', '링즈바오', '전자'] +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '동메이 링즈바오 전자' +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 10개 텍스트 처리 완료 +[2026-03-02 20:51:06,153] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 9 치환됨 +[2026-03-02 20:51:06,154] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.156, comps=4, min_center_dist=0.041 → external_request +[2026-03-02 20:51:06,154] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 10 +[2026-03-02 20:51:06,154] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:51:06,154] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:51:06,154] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:51:06,185] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:51:06,246] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:51:06,454] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:51:06,458] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11194.9MB -> 11192.2MB (-2.7MB, -0.0%) - 방법: external_request +[2026-03-02 20:51:06,458] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:51:06,512] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:51:06,512] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:51:06,512] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:51:06,878] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_8.webp +[2026-03-02 20:51:06,881] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 8 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_8.webp +[2026-03-02 20:51:06,881] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 5077.3ms | download=0.0ms | ocr=659.0ms | translate=3075.9ms | mask=3075.9ms | inpaint=616.0ms(external_request/SERVER) | render=53.0ms | save=320.0ms +[2026-03-02 20:51:06,881] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:51:06,881] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=acb0a920-f86b-488e-aaa7-670832486116 +[2026-03-02 20:51:06,881] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=acb0a920-f86b-488e-aaa7-670832486116 +[2026-03-02 20:51:06,956] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:51:06,959] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11189.2MB -> 11234.9MB (+45.7MB, +0.4%) - 방법: external_request +[2026-03-02 20:51:06,960] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:51:07,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:51:07,049] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:51:07,050] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:51:07,449] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_9.webp +[2026-03-02 20:51:07,452] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 9 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_9.webp +[2026-03-02 20:51:07,453] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 5403.5ms | download=0.0ms | ocr=3027.7ms | translate=314.2ms | mask=25.0ms | inpaint=806.0ms(external_request/SERVER) | render=89.0ms | save=352.2ms +[2026-03-02 20:51:07,453] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:51:07,453] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=67666d64-47c1-4eb1-910b-7aec9848c76b +[2026-03-02 20:51:07,453] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=67666d64-47c1-4eb1-910b-7aec9848c76b +[2026-03-02 20:51:08,212] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=b6925576-713f-49c8-9910-65c57ce35f1a +[2026-03-02 20:51:08,215] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:51:08,215] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:51:08,215] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:51:08,215] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:51:08,216] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:51:08,335] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🚀 작업 처리 시작: cmd=process_single_image, uid=da0904b4-4f0a-4824-9fa4-399b9850aa23 +[2026-03-02 20:51:08,337] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 프로세서 toggle_states 업데이트 : {'TEMP_IMAGE_DIR': 'C:\\ProgramData\\ImgWorker\\work', 'output_image_format': 'webp', 'use_local_rembg': False, 'local_rembg_model_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\rembg_models\\birefnet-general-lite.onnx', 'local_model_name': 'birefnet-general-lite', 'optionIMGTrans_type': 'CPU', 'detail_IMGTrans_type': 'CPU', 'thumb_trans_type': 'CPU', 'migan_use_accel': True, 'migan_onnx_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\migan_onnx\\migan_pipeline_v2_simplified.onnx', 'ocr_provider_override': 'auto', 'migan_provider_override': 'auto', 'rembg_provider_override': 'auto', 'force_cpu_ocr': True, 'title': False, 'title_shuffle': False, 'title_trans_type': False, 'collect_method_combo': 'api', 'ocr': True, 'unwanted_words': {'할인': '이미지삭제', '무료': '이미지삭제', '증정': '이미지삭제', '이벤트': '이미지삭제', '세일': '이미지삭제', '사은품': '이미지삭제', '보증': '이미지삭제', '품절': '이미지삭제', '행사': '이미지삭제', '할인가': '이미지삭제', '무료배송': '이미지삭제', '보장': '이미지삭제', '즉시': '이미지삭제', '고객센터': '이미지삭제', '반품': '이미지삭제', '약속': '이미지삭제', '교환': '이미지삭제', '품질': '이미지삭제'}, 'interval': 3.0, 'watingTime': 20, 'memo': True, 'memo_toggle_exposer': True, 'memo_toggle_order': False, 'optionTrnas': True, 'optionTrnas_method': True, 'optionNumbering_method_type': 'numeric', 'optionIMGTrans': True, 'optionAutoSelect': True, 'optionName_max_length': 25, 'option_numbering_shuffle': False, 'optionNumbering_only': False, 'first_option_img_to_thumb': True, 'price': False, 'price_range_percent': 0, 'tag': True, 'tag_method': 'ai', 'tag_ai': True, 'tag_by_product_name': False, 'tag_lens': False, 'delete_all_tags': False, 'tag_filter_enabled': True, 'tag_filter_ss_reg': 'ALL', 'tag_filter_search_3m_min': 3000, 'tag_filter_search_3m_max': 0, 'tag_filter_product_min': 5000, 'tag_filter_product_max': 500000, 'tag_filter_competition': 'ALL', 'tag_filter_ad': 'ALL', 'tag_filter_ai_relevance': True, 'thumb': False, 'thumb_represent': False, 'thumb_nukki': True, 'remove_background_white': True, 'detail_Option': True, 'detail_IMGTrans': True, 'detail_concurrency_limit': 2, 'detail_promo_enabled': False, 'detail_promo_position': 'top', 'debug_mode': False, 'ed_mode': False, 'discord': False, 'is_localServer': False, 'watermark_toggle': False, 'vip_detail_edit': False, 'clientID': '', 'clientSecret': '', 'gpt_model': 'gpt-5-nano', 'requests_server_type': 'main', 'discord_webhook': '', 'watermark_text': '', 'thumb_rmb_count': 1, 'max_option_count': 8, 'opacity_percent': 20, 'group_index': 24, 'remove_overprice': True, 'cat_rec': True, 'fixed_keywords': False, 'fixed_keywords_count': 2, 'sub_word_remove': False, 'del_warning_word': False, 'title_length_limit': 35, 'forbidden_partial_title': False, 'forbidden_partial_option': False, 'forbidden_partial_tag': False, 'base_dir': 'C:\\Program Files\\Edit PartTimer3\\lib\\src', 'ERROR_SCREENSHOT_DIR': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\error_screenshots', 'font_type': '폰트2', 'image_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'watermark_font_path': 'C:\\Program Files\\Edit PartTimer3\\lib\\src\\modules\\fonts\\HakgyoansimDunggeunmisoTTFB.ttf', 'request_inpainting_server_url': 'http://e5.m1tcloud.cc:8008', 'request_inpainting_server_url_local': 'http://1.208.108.242:58539', 'request_rembg_server_url': 'http://1.208.108.242:58539', 'request_rembg_server_url_local': 'http://1.208.108.242:58533', 'gemma_api_base_url': 'https://gemma.m1tcloud.cc', 'gemma_api_base_url_local': 'https://gemma.m1tcloud.cc', 'gemma_api_timeout': 120, 'gemma_api_timeout_local': 120, 'membership_level': 'vip', 'image_worker_restart_every': 3, 'image_worker_restart_count': 0, 'products_per_context_restart': 19, 'image_worker_mem_restart_threshold': 85, 'image_worker_mem_error_escalate_after': 2, 'enable_aggressive_memory_cleanup': True, 'force_cuda_cache_clear': True, 'inpaint_method': 'CPU', 'min_masks_for_lama': 2, 'use_roi_optimized_mask': True, 'enable_mask_refinement': False, 'context_expansion_ratio': 0.4, 'blend_mode': 'simple', 'performance_mode': True, 'max_image_size': 1280, 'roi_area_high': 0.0, 'local_inpaint_method': 'migan', 'migan_use_cuda': True, 'migan_intra_threads': 0, 'migan_inter_threads': 0, 'migan_use_tensorrt': True, 'migan_trt_fp16_enable': True, 'migan_max_image_size': 2048, 'use_cuda': True, 'onnx_model_type': '자동 선택', 'gpu_info': {'has_directx12': True, 'gpu_type': 'unknown', 'vendor': 'unknown', 'recommended_model': 'simp'}, 'admin_id': 'deardearmydear@daum.net\n', 'admin_pw': 'skywalker-5', 'is_admin': True, 'user_id': '', 'user_pw': '', 'price_range_enabled': False, 'unwanted_words_button': False, 'cmb_button': False, 'detail_text_button': False, 'gpt_model_label': '[실험실]AI 모델 - 최신 모델 적용 중', 'unwanted_texts': ['할인', '무료', '증정', '이벤트', '세일', '사은품', '보증', '품절', '행사', '할인가', '무료배송', '보장', '즉시', '고객센터', '반품', '약속', '교환', '품질'], 'is_member_valid': False, 'authenticated_by_admin': False} +[2026-03-02 20:51:08,338] [LogListener] [DEBUG] [loggerModule.py:debug:449] [UpdateToggle] 완료: member=True, inpaint=CPU, font=NanumBarunGothic.ttf +[2026-03-02 20:51:08,338] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 실행 직전: cmd=process_single_image +[2026-03-02 20:51:08,338] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 직전 +[2026-03-02 20:51:08,338] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 번역시작 +[2026-03-02 20:51:08,568] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 11 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_010_O1CN01XU1Y2d1Sk7fIMOkeU_!!6000000002284-2-tps-1125-1446.png - OCR+인페인팅 모드 +[2026-03-02 20:51:08,569] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_010_O1CN01XU1Y2d1Sk7fIMOkeU_!!6000000002284-2-tps-1125-1446.png +[2026-03-02 20:51:08,606] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 11 원본 크기: 1125x1446 +[2026-03-02 20:51:08,615] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 11 가로 크기 조정: 1125x1446 → 860x1105 +[2026-03-02 20:51:08,638] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 11 크기 조정 완료: 860x1105 +[2026-03-02 20:51:08,638] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 11 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_010_O1CN01XU1Y2d1Sk7fIMOkeU_!!6000000002284-2-tps-1125-1446_resized.png +[2026-03-02 20:51:08,653] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:51:12,417] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 3760.6ms +[2026-03-02 20:51:12,439] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 308.5ms, 인식: 3403.1ms, 분류: 34.0ms +[2026-03-02 20:51:12,458] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11241.8MB -> 11370.1MB (+128.3MB, +1.1%) - 이미지 11 +[2026-03-02 20:51:12,460] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '价格说明：', 'confidence': 0.999051570892334, 'polygon': [[36.0, 25.0], [168.0, 28.0], [168.0, 60.0], [35.0, 57.0]], 'bbox': (35, 25, 134, 36), 'method': 'polygon'}, {'text': '被比较价格', 'confidence': 0.9981765747070312, 'polygon': [[37.0, 124.0], [182.0, 124.0], [182.0, 153.0], [37.0, 153.0]], 'bbox': (37, 124, 146, 30), 'method': 'polygon'}, {'text': '商品的专柜价、吊牌价、厂家建议零售价、厂商指导价、品', 'confidence': 0.9965836405754089, 'polygon': [[39.0, 174.0], [809.0, 174.0], [809.0, 200.0], [39.0, 200.0]], 'bbox': (39, 174, 771, 27), 'method': 'polygon'}, {'text': '牌供应商提供的指导价、商家在后台设置的一口价、减价（', 'confidence': 0.9975272417068481, 'polygon': [[40.0, 222.0], [811.0, 222.0], [811.0, 249.0], [40.0, 249.0]], 'bbox': (40, 222, 772, 28), 'method': 'polygon'}, {'text': '折价）前的基准价或该商品曾经展示过的销售价等。该价格', 'confidence': 0.9956801533699036, 'polygon': [[39.0, 269.0], [807.0, 269.0], [807.0, 297.0], [39.0, 297.0]], 'bbox': (39, 269, 769, 29), 'method': 'polygon'}, {'text': '仅供您在购买时参考。', 'confidence': 0.9984695315361023, 'polygon': [[40.0, 318.0], [319.0, 318.0], [319.0, 345.0], [40.0, 345.0]], 'bbox': (40, 318, 280, 28), 'method': 'polygon'}, {'text': '标价/销售价', 'confidence': 0.9938657283782959, 'polygon': [[37.0, 412.0], [200.0, 412.0], [200.0, 443.0], [37.0, 443.0]], 'bbox': (37, 412, 164, 32), 'method': 'polygon'}, {'text': '商品的实时标价。具体成交价格根据商品参加活动，或会员', 'confidence': 0.9975964426994324, 'polygon': [[39.0, 463.0], [807.0, 463.0], [807.0, 489.0], [39.0, 489.0]], 'bbox': (39, 463, 769, 27), 'method': 'polygon'}, {'text': '使用优惠券、积分等发生变化，最终以订单结算页价格为', 'confidence': 0.9875636100769043, 'polygon': [[39.0, 510.0], [777.0, 511.0], [777.0, 538.0], [39.0, 536.0]], 'bbox': (39, 510, 739, 29), 'method': 'polygon'}, {'text': '准。', 'confidence': 0.9998109936714172, 'polygon': [[35.0, 555.0], [84.0, 555.0], [84.0, 588.0], [35.0, 588.0]], 'bbox': (35, 555, 50, 34), 'method': 'polygon'}, {'text': '商家详情页所展示的可优惠金额是根据用户当前可使用的优', 'confidence': 0.995481550693512, 'polygon': [[40.0, 655.0], [807.0, 655.0], [807.0, 681.0], [40.0, 681.0]], 'bbox': (40, 655, 768, 27), 'method': 'polygon'}, {'text': '惠券、满减、立减，可参与的特定活动（如多件多折、限时', 'confidence': 0.992651641368866, 'polygon': [[40.0, 703.0], [810.0, 703.0], [810.0, 730.0], [40.0, 730.0]], 'bbox': (40, 703, 771, 28), 'method': 'polygon'}, {'text': '秒杀）、红包（含消费券）、淘金币抵扣等四舍五入计算得', 'confidence': 0.9940646290779114, 'polygon': [[39.0, 752.0], [809.0, 752.0], [809.0, 778.0], [39.0, 778.0]], 'bbox': (39, 752, 771, 27), 'method': 'polygon'}, {'text': '出，优惠获取及使用条件等详见活动页面及相关规则（如', 'confidence': 0.9929466247558594, 'polygon': [[41.0, 800.0], [779.0, 800.0], [779.0, 826.0], [41.0, 826.0]], 'bbox': (41, 800, 739, 27), 'method': 'polygon'}, {'text': '有），实际价格以结算页面展示为准。', 'confidence': 0.997909426689148, 'polygon': [[39.0, 846.0], [525.0, 848.0], [525.0, 876.0], [39.0, 874.0]], 'bbox': (39, 846, 487, 31), 'method': 'polygon'}, {'text': '此说明仅当出现价格比较时有效，具体请参见《淘宝平台价', 'confidence': 0.9972702264785767, 'polygon': [[39.0, 943.0], [807.0, 944.0], [807.0, 970.0], [39.0, 969.0]], 'bbox': (39, 943, 769, 28), 'method': 'polygon'}, {'text': '格管理规则》，若商家单独对被比较价格进行说明的，以商', 'confidence': 0.9984889626502991, 'polygon': [[40.0, 992.0], [810.0, 992.0], [810.0, 1019.0], [40.0, 1019.0]], 'bbox': (40, 992, 771, 28), 'method': 'polygon'}, {'text': '家的表述为准。', 'confidence': 0.9994814991950989, 'polygon': [[38.0, 1036.0], [230.0, 1038.0], [230.0, 1069.0], [37.0, 1067.0]], 'bbox': (37, 1036, 194, 34), 'method': 'polygon'}] +[2026-03-02 20:51:12,460] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 11 OCR raw 데이터 메모리 저장 완료: 18개 텍스트 +[2026-03-02 20:51:12,460] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '价格说明：' +[2026-03-02 20:51:12,460] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '被比较价格' +[2026-03-02 20:51:12,464] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '商品的专柜价、吊牌价、厂家建议零售价、厂商指导价、品' +[2026-03-02 20:51:12,464] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '牌供应商提供的指导价、商家在后台设置的一口价、减价（' +[2026-03-02 20:51:12,464] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.6%): '折价）前的基准价或该商品曾经展示过的销售价等。该价格' +[2026-03-02 20:51:12,464] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '仅供您在购买时参考。' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '标价/销售价' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '商品的实时标价。具体成交价格根据商品参加活动，或会员' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.8%): '使用优惠券、积分等发生变化，最终以订单结算页价格为' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 100.0%): '准。' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '商家详情页所展示的可优惠金额是根据用户当前可使用的优' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.3%): '惠券、满减、立减，可参与的特定活动（如多件多折、限时' +[2026-03-02 20:51:12,465] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '秒杀）、红包（含消费券）、淘金币抵扣等四舍五入计算得' +[2026-03-02 20:51:12,466] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.3%): '出，优惠获取及使用条件等详见活动页面及相关规则（如' +[2026-03-02 20:51:12,466] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '有），实际价格以结算页面展示为准。' +[2026-03-02 20:51:12,466] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '此说明仅当出现价格比较时有效，具体请参见《淘宝平台价' +[2026-03-02 20:51:12,466] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '格管理规则》，若商家单独对被比较价格进行说明的，以商' +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.9%): '家的表述为准。' +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 18/18개 (신뢰도 + & 중국어) +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '价格说明：', 'confidence': 0.999051570892334, 'polygon': [[36.0, 25.0], [168.0, 28.0], [168.0, 60.0], [35.0, 57.0]], 'bbox': (35, 25, 134, 36), 'method': 'polygon'}, {'text': '被比较价格', 'confidence': 0.9981765747070312, 'polygon': [[37.0, 124.0], [182.0, 124.0], [182.0, 153.0], [37.0, 153.0]], 'bbox': (37, 124, 146, 30), 'method': 'polygon'}, {'text': '商品的专柜价、吊牌价、厂家建议零售价、厂商指导价、品', 'confidence': 0.9965836405754089, 'polygon': [[39.0, 174.0], [809.0, 174.0], [809.0, 200.0], [39.0, 200.0]], 'bbox': (39, 174, 771, 27), 'method': 'polygon'}, {'text': '牌供应商提供的指导价、商家在后台设置的一口价、减价（', 'confidence': 0.9975272417068481, 'polygon': [[40.0, 222.0], [811.0, 222.0], [811.0, 249.0], [40.0, 249.0]], 'bbox': (40, 222, 772, 28), 'method': 'polygon'}, {'text': '折价）前的基准价或该商品曾经展示过的销售价等。该价格', 'confidence': 0.9956801533699036, 'polygon': [[39.0, 269.0], [807.0, 269.0], [807.0, 297.0], [39.0, 297.0]], 'bbox': (39, 269, 769, 29), 'method': 'polygon'}, {'text': '仅供您在购买时参考。', 'confidence': 0.9984695315361023, 'polygon': [[40.0, 318.0], [319.0, 318.0], [319.0, 345.0], [40.0, 345.0]], 'bbox': (40, 318, 280, 28), 'method': 'polygon'}, {'text': '标价/销售价', 'confidence': 0.9938657283782959, 'polygon': [[37.0, 412.0], [200.0, 412.0], [200.0, 443.0], [37.0, 443.0]], 'bbox': (37, 412, 164, 32), 'method': 'polygon'}, {'text': '商品的实时标价。具体成交价格根据商品参加活动，或会员', 'confidence': 0.9975964426994324, 'polygon': [[39.0, 463.0], [807.0, 463.0], [807.0, 489.0], [39.0, 489.0]], 'bbox': (39, 463, 769, 27), 'method': 'polygon'}, {'text': '使用优惠券、积分等发生变化，最终以订单结算页价格为', 'confidence': 0.9875636100769043, 'polygon': [[39.0, 510.0], [777.0, 511.0], [777.0, 538.0], [39.0, 536.0]], 'bbox': (39, 510, 739, 29), 'method': 'polygon'}, {'text': '准。', 'confidence': 0.9998109936714172, 'polygon': [[35.0, 555.0], [84.0, 555.0], [84.0, 588.0], [35.0, 588.0]], 'bbox': (35, 555, 50, 34), 'method': 'polygon'}, {'text': '商家详情页所展示的可优惠金额是根据用户当前可使用的优', 'confidence': 0.995481550693512, 'polygon': [[40.0, 655.0], [807.0, 655.0], [807.0, 681.0], [40.0, 681.0]], 'bbox': (40, 655, 768, 27), 'method': 'polygon'}, {'text': '惠券、满减、立减，可参与的特定活动（如多件多折、限时', 'confidence': 0.992651641368866, 'polygon': [[40.0, 703.0], [810.0, 703.0], [810.0, 730.0], [40.0, 730.0]], 'bbox': (40, 703, 771, 28), 'method': 'polygon'}, {'text': '秒杀）、红包（含消费券）、淘金币抵扣等四舍五入计算得', 'confidence': 0.9940646290779114, 'polygon': [[39.0, 752.0], [809.0, 752.0], [809.0, 778.0], [39.0, 778.0]], 'bbox': (39, 752, 771, 27), 'method': 'polygon'}, {'text': '出，优惠获取及使用条件等详见活动页面及相关规则（如', 'confidence': 0.9929466247558594, 'polygon': [[41.0, 800.0], [779.0, 800.0], [779.0, 826.0], [41.0, 826.0]], 'bbox': (41, 800, 739, 27), 'method': 'polygon'}, {'text': '有），实际价格以结算页面展示为准。', 'confidence': 0.997909426689148, 'polygon': [[39.0, 846.0], [525.0, 848.0], [525.0, 876.0], [39.0, 874.0]], 'bbox': (39, 846, 487, 31), 'method': 'polygon'}, {'text': '此说明仅当出现价格比较时有效，具体请参见《淘宝平台价', 'confidence': 0.9972702264785767, 'polygon': [[39.0, 943.0], [807.0, 944.0], [807.0, 970.0], [39.0, 969.0]], 'bbox': (39, 943, 769, 28), 'method': 'polygon'}, {'text': '格管理规则》，若商家单独对被比较价格进行说明的，以商', 'confidence': 0.9984889626502991, 'polygon': [[40.0, 992.0], [810.0, 992.0], [810.0, 1019.0], [40.0, 1019.0]], 'bbox': (40, 992, 771, 28), 'method': 'polygon'}, {'text': '家的表述为准。', 'confidence': 0.9994814991950989, 'polygon': [[38.0, 1036.0], [230.0, 1038.0], [230.0, 1069.0], [37.0, 1067.0]], 'bbox': (37, 1036, 194, 34), 'method': 'polygon'}] +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 18개 필터링 완료 +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 10 처리 시작: C:\ProgramData\ImgWorker\incoming\detail_image_009_O1CN012YZZbz1FsjxXvfB9O_!!692310543.jpg - OCR+인페인팅 모드 +[2026-03-02 20:51:12,467] [LogListener] [DEBUG] [loggerModule.py:debug:449] 로컬 파일 경로 감지, 다운로드 생략: C:\ProgramData\ImgWorker\incoming\detail_image_009_O1CN012YZZbz1FsjxXvfB9O_!!692310543.jpg +[2026-03-02 20:51:12,468] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 10 원본 크기: 750x1075 +[2026-03-02 20:51:12,476] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 10 가로 크기 조정: 750x1075 → 860x1232 +[2026-03-02 20:51:12,485] [LogListener] [DEBUG] [loggerModule.py:debug:449] 상세페이지 이미지 10 크기 조정 완료: 860x1232 +[2026-03-02 20:51:12,485] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 10 로컬 저장위치(상세페이지 전처리 완료): C:\ProgramData\ImgWorker\incoming\detail_image_009_O1CN012YZZbz1FsjxXvfB9O_!!692310543_resized.jpg +[2026-03-02 20:51:12,491] [LogListener] [DEBUG] [loggerModule.py:debug:449] 🔍 ONNX OCR 감지 방식: polygon +[2026-03-02 20:51:16,088] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⚡ ONNX OCR 추론 완료: 3591.6ms +[2026-03-02 20:51:16,133] [LogListener] [DEBUG] [loggerModule.py:debug:449] 📊 세부 시간 - 감지: 397.0ms, 인식: 3140.7ms, 분류: 42.0ms +[2026-03-02 20:51:16,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [OCR 처리]: 11376.0MB -> 11378.2MB (+2.2MB, +0.0%) - 이미지 10 +[2026-03-02 20:51:16,134] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_results: [{'text': '品质保障用心服务售后无忧', 'confidence': 0.994602620601654, 'polygon': [[246.0, 96.0], [614.0, 96.0], [614.0, 127.0], [246.0, 127.0]], 'bbox': (246, 96, 369, 32), 'method': 'polygon'}, {'text': '售后保障买家须知', 'confidence': 0.9922782182693481, 'polygon': [[146.0, 150.0], [717.0, 150.0], [717.0, 210.0], [146.0, 210.0]], 'bbox': (146, 150, 572, 61), 'method': 'polygon'}, {'text': 'AFTERSALEASSURED', 'confidence': 0.9876356720924377, 'polygon': [[367.0, 261.0], [494.0, 261.0], [494.0, 278.0], [367.0, 278.0]], 'bbox': (367, 261, 128, 18), 'method': 'polygon'}, {'text': 'PURCHASE', 'confidence': 0.9929922819137573, 'polygon': [[399.0, 276.0], [463.0, 276.0], [463.0, 289.0], [399.0, 289.0]], 'bbox': (399, 276, 65, 14), 'method': 'polygon'}, {'text': '关于签收>', 'confidence': 0.953946590423584, 'polygon': [[184.0, 388.0], [334.0, 388.0], [334.0, 420.0], [184.0, 420.0]], 'bbox': (184, 388, 151, 33), 'method': 'polygon'}, {'text': '密', 'confidence': 0.5337368845939636, 'polygon': [[97.0, 409.0], [143.0, 409.0], [143.0, 450.0], [97.0, 450.0]], 'bbox': (97, 409, 47, 42), 'method': 'polygon'}, {'text': '商品外包装小箱子（非快递袋子）完好无损方可签收，如果签收时发现异常情况', 'confidence': 0.9940605163574219, 'polygon': [[184.0, 426.0], [760.0, 426.0], [760.0, 448.0], [184.0, 448.0]], 'bbox': (184, 426, 577, 23), 'method': 'polygon'}, {'text': '，请拒绝签收并及时和本店在线客服联系。', 'confidence': 0.9893859028816223, 'polygon': [[184.0, 450.0], [506.0, 450.0], [506.0, 472.0], [184.0, 472.0]], 'bbox': (184, 450, 323, 23), 'method': 'polygon'}, {'text': '关于产品>', 'confidence': 0.9395023584365845, 'polygon': [[186.0, 567.0], [335.0, 567.0], [335.0, 599.0], [186.0, 599.0]], 'bbox': (186, 567, 150, 33), 'method': 'polygon'}, {'text': '全部产品均是高质量生产，本页面所有数据均为实测所得。测试数据因环境及', 'confidence': 0.9954391717910767, 'polygon': [[184.0, 603.0], [767.0, 603.0], [767.0, 625.0], [184.0, 625.0]], 'bbox': (184, 603, 584, 23), 'method': 'polygon'}, {'text': '工具影响可能略有差异，请以实际为准。', 'confidence': 0.9948413372039795, 'polygon': [[183.0, 628.0], [488.0, 628.0], [488.0, 649.0], [183.0, 649.0]], 'bbox': (183, 628, 306, 22), 'method': 'polygon'}, {'text': '关于客服>', 'confidence': 0.9593256711959839, 'polygon': [[182.0, 742.0], [332.0, 745.0], [331.0, 777.0], [182.0, 774.0]], 'bbox': (182, 742, 151, 36), 'method': 'polygon'}, {'text': '®', 'confidence': 0.6373090147972107, 'polygon': [[109.0, 774.0], [129.0, 774.0], [129.0, 789.0], [109.0, 789.0]], 'bbox': (109, 774, 21, 16), 'method': 'polygon'}, {'text': '我们的客服经过专业知识培训，保证让每一位顾客体验到满意的服务，不会', 'confidence': 0.996809184551239, 'polygon': [[183.0, 780.0], [759.0, 780.0], [759.0, 802.0], [183.0, 802.0]], 'bbox': (183, 780, 577, 23), 'method': 'polygon'}, {'text': '因快递包装售后等问题影响到您愉快地购物。', 'confidence': 0.9952741861343384, 'polygon': [[182.0, 805.0], [521.0, 806.0], [521.0, 828.0], [182.0, 826.0]], 'bbox': (182, 805, 340, 24), 'method': 'polygon'}, {'text': '关于发货物流>', 'confidence': 0.957436203956604, 'polygon': [[183.0, 923.0], [390.0, 923.0], [390.0, 950.0], [183.0, 950.0]], 'bbox': (183, 923, 208, 28), 'method': 'polygon'}, {'text': '本店合作快递中通快递，电池类产品不能走空运，只能走陆运。', 'confidence': 0.9934704899787903, 'polygon': [[180.0, 959.0], [668.0, 959.0], [668.0, 980.0], [180.0, 980.0]], 'bbox': (180, 959, 489, 22), 'method': 'polygon'}, {'text': '澳门、台湾省、海外（国外）暂不支持发货，如拍下请及时申请退款。', 'confidence': 0.9891617298126221, 'polygon': [[179.0, 983.0], [710.0, 984.0], [710.0, 1006.0], [179.0, 1005.0]], 'bbox': (179, 983, 532, 24), 'method': 'polygon'}, {'text': '关于退货>', 'confidence': 0.9784687757492065, 'polygon': [[180.0, 1097.0], [329.0, 1097.0], [329.0, 1128.0], [180.0, 1128.0]], 'bbox': (180, 1097, 150, 32), 'method': 'polygon'}, {'text': '本店承诺7天退换货服务，再签收后规定时间内，宝贝不影响二次销售的前提下', 'confidence': 0.9905626773834229, 'polygon': [[178.0, 1133.0], [756.0, 1133.0], [756.0, 1155.0], [178.0, 1155.0]], 'bbox': (178, 1133, 579, 23), 'method': 'polygon'}, {'text': '均可联系客服退换货。', 'confidence': 0.9977195858955383, 'polygon': [[180.0, 1160.0], [344.0, 1160.0], [344.0, 1178.0], [180.0, 1178.0]], 'bbox': (180, 1160, 165, 19), 'method': 'polygon'}] +[2026-03-02 20:51:16,135] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 10 OCR raw 데이터 메모리 저장 완료: 21개 텍스트 +[2026-03-02 20:51:16,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '品质保障用心服务售后无忧' +[2026-03-02 20:51:16,136] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.2%): '售后保障买家须知' +[2026-03-02 20:51:16,140] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'AFTERSALEASSURED' +[2026-03-02 20:51:16,140] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): 'PURCHASE' +[2026-03-02 20:51:16,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 95.4%): '关于签收>' +[2026-03-02 20:51:16,143] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 53.4%): '密' +[2026-03-02 20:51:16,144] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.4%): '商品外包装小箱子（非快递袋子）完好无损方可签收，如果签收时发现异常情况' +[2026-03-02 20:51:16,145] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.9%): '，请拒绝签收并及时和本店在线客服联系。' +[2026-03-02 20:51:16,145] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 94.0%): '关于产品>' +[2026-03-02 20:51:16,146] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '全部产品均是高质量生产，本页面所有数据均为实测所得。测试数据因环境及' +[2026-03-02 20:51:16,146] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '工具影响可能略有差异，请以实际为准。' +[2026-03-02 20:51:16,146] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 95.9%): '关于客服>' +[2026-03-02 20:51:16,149] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 제외 (중국어 없음): '®' +[2026-03-02 20:51:16,149] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.7%): '我们的客服经过专业知识培训，保证让每一位顾客体验到满意的服务，不会' +[2026-03-02 20:51:16,149] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.5%): '因快递包装售后等问题影响到您愉快地购物。' +[2026-03-02 20:51:16,149] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 95.7%): '关于发货物流>' +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.3%): '本店合作快递中通快递，电池类产品不能走空运，只能走陆运。' +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 98.9%): '澳门、台湾省、海外（国外）暂不支持发货，如拍下请及时申请退款。' +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 97.8%): '关于退货>' +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.1%): '本店承诺7天退换货服务，再签收后规定时间内，宝贝不影响二次销售的前提下' +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] [필터링] 포함 (신뢰도 99.8%): '均可联系客服退换货。' +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] 필터링 결과: 18/21개 (신뢰도 + & 중국어) +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] filter_ocr_results: [{'text': '品质保障用心服务售后无忧', 'confidence': 0.994602620601654, 'polygon': [[246.0, 96.0], [614.0, 96.0], [614.0, 127.0], [246.0, 127.0]], 'bbox': (246, 96, 369, 32), 'method': 'polygon'}, {'text': '售后保障买家须知', 'confidence': 0.9922782182693481, 'polygon': [[146.0, 150.0], [717.0, 150.0], [717.0, 210.0], [146.0, 210.0]], 'bbox': (146, 150, 572, 61), 'method': 'polygon'}, {'text': '关于签收>', 'confidence': 0.953946590423584, 'polygon': [[184.0, 388.0], [334.0, 388.0], [334.0, 420.0], [184.0, 420.0]], 'bbox': (184, 388, 151, 33), 'method': 'polygon'}, {'text': '密', 'confidence': 0.5337368845939636, 'polygon': [[97.0, 409.0], [143.0, 409.0], [143.0, 450.0], [97.0, 450.0]], 'bbox': (97, 409, 47, 42), 'method': 'polygon'}, {'text': '商品外包装小箱子（非快递袋子）完好无损方可签收，如果签收时发现异常情况', 'confidence': 0.9940605163574219, 'polygon': [[184.0, 426.0], [760.0, 426.0], [760.0, 448.0], [184.0, 448.0]], 'bbox': (184, 426, 577, 23), 'method': 'polygon'}, {'text': '，请拒绝签收并及时和本店在线客服联系。', 'confidence': 0.9893859028816223, 'polygon': [[184.0, 450.0], [506.0, 450.0], [506.0, 472.0], [184.0, 472.0]], 'bbox': (184, 450, 323, 23), 'method': 'polygon'}, {'text': '关于产品>', 'confidence': 0.9395023584365845, 'polygon': [[186.0, 567.0], [335.0, 567.0], [335.0, 599.0], [186.0, 599.0]], 'bbox': (186, 567, 150, 33), 'method': 'polygon'}, {'text': '全部产品均是高质量生产，本页面所有数据均为实测所得。测试数据因环境及', 'confidence': 0.9954391717910767, 'polygon': [[184.0, 603.0], [767.0, 603.0], [767.0, 625.0], [184.0, 625.0]], 'bbox': (184, 603, 584, 23), 'method': 'polygon'}, {'text': '工具影响可能略有差异，请以实际为准。', 'confidence': 0.9948413372039795, 'polygon': [[183.0, 628.0], [488.0, 628.0], [488.0, 649.0], [183.0, 649.0]], 'bbox': (183, 628, 306, 22), 'method': 'polygon'}, {'text': '关于客服>', 'confidence': 0.9593256711959839, 'polygon': [[182.0, 742.0], [332.0, 745.0], [331.0, 777.0], [182.0, 774.0]], 'bbox': (182, 742, 151, 36), 'method': 'polygon'}, {'text': '我们的客服经过专业知识培训，保证让每一位顾客体验到满意的服务，不会', 'confidence': 0.996809184551239, 'polygon': [[183.0, 780.0], [759.0, 780.0], [759.0, 802.0], [183.0, 802.0]], 'bbox': (183, 780, 577, 23), 'method': 'polygon'}, {'text': '因快递包装售后等问题影响到您愉快地购物。', 'confidence': 0.9952741861343384, 'polygon': [[182.0, 805.0], [521.0, 806.0], [521.0, 828.0], [182.0, 826.0]], 'bbox': (182, 805, 340, 24), 'method': 'polygon'}, {'text': '关于发货物流>', 'confidence': 0.957436203956604, 'polygon': [[183.0, 923.0], [390.0, 923.0], [390.0, 950.0], [183.0, 950.0]], 'bbox': (183, 923, 208, 28), 'method': 'polygon'}, {'text': '本店合作快递中通快递，电池类产品不能走空运，只能走陆运。', 'confidence': 0.9934704899787903, 'polygon': [[180.0, 959.0], [668.0, 959.0], [668.0, 980.0], [180.0, 980.0]], 'bbox': (180, 959, 489, 22), 'method': 'polygon'}, {'text': '澳门、台湾省、海外（国外）暂不支持发货，如拍下请及时申请退款。', 'confidence': 0.9891617298126221, 'polygon': [[179.0, 983.0], [710.0, 984.0], [710.0, 1006.0], [179.0, 1005.0]], 'bbox': (179, 983, 532, 24), 'method': 'polygon'}, {'text': '关于退货>', 'confidence': 0.9784687757492065, 'polygon': [[180.0, 1097.0], [329.0, 1097.0], [329.0, 1128.0], [180.0, 1128.0]], 'bbox': (180, 1097, 150, 32), 'method': 'polygon'}, {'text': '本店承诺7天退换货服务，再签收后规定时间内，宝贝不影响二次销售的前提下', 'confidence': 0.9905626773834229, 'polygon': [[178.0, 1133.0], [756.0, 1133.0], [756.0, 1155.0], [178.0, 1155.0]], 'bbox': (178, 1133, 579, 23), 'method': 'polygon'}, {'text': '均可联系客服退换货。', 'confidence': 0.9977195858955383, 'polygon': [[180.0, 1160.0], [344.0, 1160.0], [344.0, 1178.0], [180.0, 1178.0]], 'bbox': (180, 1160, 165, 19), 'method': 'polygon'}] +[2026-03-02 20:51:16,150] [LogListener] [DEBUG] [loggerModule.py:debug:449] 중국어 텍스트 18개 필터링 완료 +[2026-03-02 20:51:16,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] 한글 텍스트 0개 필터링 완료 +[2026-03-02 20:51:16,151] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['가격 설명:', '비교 가격', '제품 카운터 가격 / 태그 가격 / 제조사 권장 소매가 / 제조사 가이드 가격 / 제품', '브랜드 공급업체가 제공하는 가이드 가격 / 백그라운드에서 판매자가 설정한 고정 가격 / 감소 (', '할인 전 기본 가격) 또는 해당 상품이 이전에 표시했던 판매 가격 등입니다.', '구매시 참고용으로만 사용하세요.', '가격 / 판매 가격', '품목의 실시간 가격.구체적인 거래 가격은 이벤트에 참여하는 상품이나 멤버십에 따라 다릅니다.', '쿠폰 사용 / 포인트 등이 변경된 경우 주문 정산 페이지에 게시되는 최종 가격이 적용됩니다.', '정확합니다.', '판매자 세부정보 페이지에 표시되는 할인 금액은 현재 사용자에게 제공되는 할인을 기준으로 합니다.', '쿠폰 / 전액할인 / 즉시 할인, 참여할 수 있는 특정 활동(예: 더 많은 품목에 대한 추가 할인) / 제한된 시간', '플래시 세일) / 빨간 봉투 (소비 쿠폰 포함) / 금광 채굴 코인 공제 등은 반올림하여 계산합니다.', '활동 페이지 및 관련 규칙(예:', '예) 실제 가격은 결제 페이지에 표시되는 금액입니다.', '이 설명은 가격 비교가 발생한 경우에만 유효합니다. 자세한 내용은 "타오바오 플랫폼 가격"을 참조하세요.', '"가격 관리 규정"에 따라, 비교 대상 가격에 대해 가맹점이 별도로 설명하는 경우, 가맹점은', '집의 진술이 우선합니다.'] +[2026-03-02 20:51:16,154] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:51:16,155] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '가격 설명:' +[2026-03-02 20:51:16,155] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['가격', '설명:'] +[2026-03-02 20:51:16,157] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '가격 설명:' +[2026-03-02 20:51:16,157] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '비교 가격' +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['비교', '가격'] +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '비교 가격' +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '제품 카운터 가격 / 태그 가격 / 제조사 권장 소매가 / 제조사 가이드 가격 / 제품' +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['제품', '카운터', '가격', '/', '태그', '가격', '/', '제조사', '권장', '소매가', '/', '제조사', '가이드', '가격', '/', '제품'] +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '제품 카운터 가격 / 태그 가격 / 제조사 권장 소매가 / 제조사 가이드 가격 / 제품' +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '브랜드 공급업체가 제공하는 가이드 가격 / 백그라운드에서 판매자가 설정한 고정 가격 / 감소 (' +[2026-03-02 20:51:16,158] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['브랜드', '공급업체가', '제공하는', '가이드', '가격', '/', '백그라운드에서', '판매자가', '설정한', '고정', '가격', '/', '감소', '('] +[2026-03-02 20:51:16,159] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '브랜드 공급업체가 제공하는 가이드 가격 / 백그라운드에서 판매자가 설정한 고정 가격 / 감소 (' +[2026-03-02 20:51:16,159] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '할인 전 기본 가격) 또는 해당 상품이 이전에 표시했던 판매 가격 등입니다.' +[2026-03-02 20:51:16,159] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['할인', '전', '기본', '가격)', '또는', '해당', '상품이', '이전에', '표시했던', '판매', '가격', '등입니다.'] +[2026-03-02 20:51:16,159] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '할인 전 기본 가격) 또는 해당 상품이 이전에 표시했던 판매 가격 등입니다.' +[2026-03-02 20:51:16,160] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: '구매시 참고용으로만 사용하세요.' +[2026-03-02 20:51:16,161] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: ['구매시', '참고용으로만', '사용하세요.'] +[2026-03-02 20:51:16,161] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: '구매시 참고용으로만 사용하세요.' +[2026-03-02 20:51:16,161] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '가격 / 판매 가격' +[2026-03-02 20:51:16,161] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['가격', '/', '판매', '가격'] +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '가격 / 판매 가격' +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '품목의 실시간 가격.구체적인 거래 가격은 이벤트에 참여하는 상품이나 멤버십에 따라 다릅니다.' +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['품목의', '실시간', '가격.구체적인', '거래', '가격은', '이벤트에', '참여하는', '상품이나', '멤버십에', '따라', '다릅니다.'] +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '품목의 실시간 가격.구체적인 거래 가격은 이벤트에 참여하는 상품이나 멤버십에 따라 다릅니다.' +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '쿠폰 사용 / 포인트 등이 변경된 경우 주문 정산 페이지에 게시되는 최종 가격이 적용됩니다.' +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['쿠폰', '사용', '/', '포인트', '등이', '변경된', '경우', '주문', '정산', '페이지에', '게시되는', '최종', '가격이', '적용됩니다.'] +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '쿠폰 사용 / 포인트 등이 변경된 경우 주문 정산 페이지에 게시되는 최종 가격이 적용됩니다.' +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '정확합니다.' +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['정확합니다.'] +[2026-03-02 20:51:16,162] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '정확합니다.' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '판매자 세부정보 페이지에 표시되는 할인 금액은 현재 사용자에게 제공되는 할인을 기준으로 합니다.' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['판매자', '세부정보', '페이지에', '표시되는', '할인', '금액은', '현재', '사용자에게', '제공되는', '할인을', '기준으로', '합니다.'] +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '판매자 세부정보 페이지에 표시되는 할인 금액은 현재 사용자에게 제공되는 할인을 기준으로 합니다.' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '쿠폰 / 전액할인 / 즉시 할인, 참여할 수 있는 특정 활동(예: 더 많은 품목에 대한 추가 할인) / 제한된 시간' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['쿠폰', '/', '전액할인', '/', '즉시', '할인,', '참여할', '수', '있는', '특정', '활동(예:', '더', '많은', '품목에', '대한', '추가', '할인)', '/', '제한된', '시간'] +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '쿠폰 / 전액할인 / 즉시 할인, 참여할 수 있는 특정 활동(예: 더 많은 품목에 대한 추가 할인) / 제한된 시간' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '플래시 세일) / 빨간 봉투 (소비 쿠폰 포함) / 금광 채굴 코인 공제 등은 반올림하여 계산합니다.' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['플래시', '세일)', '/', '빨간', '봉투', '(소비', '쿠폰', '포함)', '/', '금광', '채굴', '코인', '공제', '등은', '반올림하여', '계산합니다.'] +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '플래시 세일) / 빨간 봉투 (소비 쿠폰 포함) / 금광 채굴 코인 공제 등은 반올림하여 계산합니다.' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '활동 페이지 및 관련 규칙(예:' +[2026-03-02 20:51:16,163] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['활동', '페이지', '및', '관련', '규칙(예:'] +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '활동 페이지 및 관련 규칙(예:' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 원본 텍스트: '예) 실제 가격은 결제 페이지에 표시되는 금액입니다.' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 분리된 단어: ['예)', '실제', '가격은', '결제', '페이지에', '표시되는', '금액입니다.'] +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 변경 없음: '예) 실제 가격은 결제 페이지에 표시되는 금액입니다.' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 원본 텍스트: '이 설명은 가격 비교가 발생한 경우에만 유효합니다. 자세한 내용은 "타오바오 플랫폼 가격"을 참조하세요.' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 분리된 단어: ['이', '설명은', '가격', '비교가', '발생한', '경우에만', '유효합니다.', '자세한', '내용은', '"타오바오', '플랫폼', '가격"을', '참조하세요.'] +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 변경 없음: '이 설명은 가격 비교가 발생한 경우에만 유효합니다. 자세한 내용은 "타오바오 플랫폼 가격"을 참조하세요.' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 원본 텍스트: '"가격 관리 규정"에 따라, 비교 대상 가격에 대해 가맹점이 별도로 설명하는 경우, 가맹점은' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 분리된 단어: ['"가격', '관리', '규정"에', '따라,', '비교', '대상', '가격에', '대해', '가맹점이', '별도로', '설명하는', '경우,', '가맹점은'] +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 변경 없음: '"가격 관리 규정"에 따라, 비교 대상 가격에 대해 가맹점이 별도로 설명하는 경우, 가맹점은' +[2026-03-02 20:51:16,164] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 18] 원본 텍스트: '집의 진술이 우선합니다.' +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 18] 분리된 단어: ['집의', '진술이', '우선합니다.'] +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 18] 변경 없음: '집의 진술이 우선합니다.' +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 18개 텍스트 처리 완료 +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 11 치환됨 +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.511, comps=10, min_center_dist=0.035 → external_request +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 18 +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:51:16,165] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:51:16,184] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:51:16,242] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:51:16,439] [LogListener] [DEBUG] [loggerModule.py:debug:449] translated_texts: ['품질 보증, 세심한 서비스 및 걱정 없는 애프터 서비스', '판매 후 보호 구매자 지침', '서명에 대해>', '비밀', '영수증에 서명하기 전에 제품의 작은 외부 포장 상자(특급 봉투 아님)가 손상되지 않은 상태여야 합니다. 영수증 서명 시 이상이 발견된 경우,', ', 서명을 거부하고 제 시간에 온라인 고객 서비스에 문의하십시오.', '상품에 대하여>', '모든 제품은 고품질로 생산되며, 이 페이지의 모든 데이터는 실제 측정에서 얻은 것입니다.테스트 데이터는 환경에 따라 다르며,', '도구의 영향은 약간 다를 수 있으므로 실제 상황을 참조하십시오.', '고객 서비스에 대해>', '우리의 고객 서비스 직원은 모든 고객이 만족스러운 서비스를 경험할 수 있도록 전문 지식을 교육 받았습니다.', '특송 포장이나 애프터 서비스 등의 문제로 인해 쇼핑의 즐거움이 영향을 받을 수 있습니다.', '배송물류 소개>', '저희 매장은 특급 배송 회사인 Zhongtong Express와 협력하고 있습니다. 배터리 제품은 항공 운송이 불가능하고, 육상 운송만 가능합니다.', '마카오 / 대만 지방 / 해외(해외) 배송은 당분간 지원되지 않습니다. 사진을 찍으셨다면 기한 내에 환불 신청을 해주시기 바랍니다.', '반품에 대해>', '저희 매장은 7일 이내 반품 및 교환 서비스를 약속하며, 상품 서명 후 지정된 시간 내에 해당 상품은 2차 판매에 영향을 미치지 않습니다.', '반품이나 교환은 고객센터로 연락주시면 됩니다.'] +[2026-03-02 20:51:16,439] [LogListener] [DEBUG] [loggerModule.py:debug:449] 마스크 생성 완료 +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 원본 텍스트: '품질 보증, 세심한 서비스 및 걱정 없는 애프터 서비스' +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 분리된 단어: ['품질', '보증,', '세심한', '서비스', '및', '걱정', '없는', '애프터', '서비스'] +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 1] 변경 없음: '품질 보증, 세심한 서비스 및 걱정 없는 애프터 서비스' +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 원본 텍스트: '판매 후 보호 구매자 지침' +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 분리된 단어: ['판매', '후', '보호', '구매자', '지침'] +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 2] 변경 없음: '판매 후 보호 구매자 지침' +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 원본 텍스트: '서명에 대해>' +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 분리된 단어: ['서명에', '대해>'] +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 3] 변경 없음: '서명에 대해>' +[2026-03-02 20:51:16,440] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 원본 텍스트: '비밀' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 분리된 단어: ['비밀'] +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 4] 변경 없음: '비밀' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 원본 텍스트: '영수증에 서명하기 전에 제품의 작은 외부 포장 상자(특급 봉투 아님)가 손상되지 않은 상태여야 합니다. 영수증 서명 시 이상이 발견된 경우,' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 분리된 단어: ['영수증에', '서명하기', '전에', '제품의', '작은', '외부', '포장', '상자(특급', '봉투', '아님)가', '손상되지', '않은', '상태여야', '합니다.', '영수증', '서명', '시', '이상이', '발견된', '경우,'] +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 5] 변경 없음: '영수증에 서명하기 전에 제품의 작은 외부 포장 상자(특급 봉투 아님)가 손상되지 않은 상태여야 합니다. 영수증 서명 시 이상이 발견된 경우,' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 원본 텍스트: ', 서명을 거부하고 제 시간에 온라인 고객 서비스에 문의하십시오.' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 분리된 단어: [',', '서명을', '거부하고', '제', '시간에', '온라인', '고객', '서비스에', '문의하십시오.'] +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 6] 변경 없음: ', 서명을 거부하고 제 시간에 온라인 고객 서비스에 문의하십시오.' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 원본 텍스트: '상품에 대하여>' +[2026-03-02 20:51:16,441] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 분리된 단어: ['상품에', '대하여>'] +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 7] 변경 없음: '상품에 대하여>' +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 원본 텍스트: '모든 제품은 고품질로 생산되며, 이 페이지의 모든 데이터는 실제 측정에서 얻은 것입니다.테스트 데이터는 환경에 따라 다르며,' +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 분리된 단어: ['모든', '제품은', '고품질로', '생산되며,', '이', '페이지의', '모든', '데이터는', '실제', '측정에서', '얻은', '것입니다.테스트', '데이터는', '환경에', '따라', '다르며,'] +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 8] 변경 없음: '모든 제품은 고품질로 생산되며, 이 페이지의 모든 데이터는 실제 측정에서 얻은 것입니다.테스트 데이터는 환경에 따라 다르며,' +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 원본 텍스트: '도구의 영향은 약간 다를 수 있으므로 실제 상황을 참조하십시오.' +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 분리된 단어: ['도구의', '영향은', '약간', '다를', '수', '있으므로', '실제', '상황을', '참조하십시오.'] +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 9] 변경 없음: '도구의 영향은 약간 다를 수 있으므로 실제 상황을 참조하십시오.' +[2026-03-02 20:51:16,442] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 원본 텍스트: '고객 서비스에 대해>' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 분리된 단어: ['고객', '서비스에', '대해>'] +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 10] 변경 없음: '고객 서비스에 대해>' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 원본 텍스트: '우리의 고객 서비스 직원은 모든 고객이 만족스러운 서비스를 경험할 수 있도록 전문 지식을 교육 받았습니다.' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 분리된 단어: ['우리의', '고객', '서비스', '직원은', '모든', '고객이', '만족스러운', '서비스를', '경험할', '수', '있도록', '전문', '지식을', '교육', '받았습니다.'] +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 11] 변경 없음: '우리의 고객 서비스 직원은 모든 고객이 만족스러운 서비스를 경험할 수 있도록 전문 지식을 교육 받았습니다.' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 원본 텍스트: '특송 포장이나 애프터 서비스 등의 문제로 인해 쇼핑의 즐거움이 영향을 받을 수 있습니다.' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 분리된 단어: ['특송', '포장이나', '애프터', '서비스', '등의', '문제로', '인해', '쇼핑의', '즐거움이', '영향을', '받을', '수', '있습니다.'] +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 12] 변경 없음: '특송 포장이나 애프터 서비스 등의 문제로 인해 쇼핑의 즐거움이 영향을 받을 수 있습니다.' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 원본 텍스트: '배송물류 소개>' +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 분리된 단어: ['배송물류', '소개>'] +[2026-03-02 20:51:16,443] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 13] 변경 없음: '배송물류 소개>' +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 원본 텍스트: '저희 매장은 특급 배송 회사인 Zhongtong Express와 협력하고 있습니다. 배터리 제품은 항공 운송이 불가능하고, 육상 운송만 가능합니다.' +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 분리된 단어: ['저희', '매장은', '특급', '배송', '회사인', 'Zhongtong', 'Express와', '협력하고', '있습니다.', '배터리', '제품은', '항공', '운송이', '불가능하고,', '육상', '운송만', '가능합니다.'] +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 14] 변경 없음: '저희 매장은 특급 배송 회사인 Zhongtong Express와 협력하고 있습니다. 배터리 제품은 항공 운송이 불가능하고, 육상 운송만 가능합니다.' +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 원본 텍스트: '마카오 / 대만 지방 / 해외(해외) 배송은 당분간 지원되지 않습니다. 사진을 찍으셨다면 기한 내에 환불 신청을 해주시기 바랍니다.' +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 분리된 단어: ['마카오', '/', '대만', '지방', '/', '해외(해외)', '배송은', '당분간', '지원되지', '않습니다.', '사진을', '찍으셨다면', '기한', '내에', '환불', '신청을', '해주시기', '바랍니다.'] +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 15] 변경 없음: '마카오 / 대만 지방 / 해외(해외) 배송은 당분간 지원되지 않습니다. 사진을 찍으셨다면 기한 내에 환불 신청을 해주시기 바랍니다.' +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 원본 텍스트: '반품에 대해>' +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 분리된 단어: ['반품에', '대해>'] +[2026-03-02 20:51:16,444] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 16] 변경 없음: '반품에 대해>' +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 원본 텍스트: '저희 매장은 7일 이내 반품 및 교환 서비스를 약속하며, 상품 서명 후 지정된 시간 내에 해당 상품은 2차 판매에 영향을 미치지 않습니다.' +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 분리된 단어: ['저희', '매장은', '7일', '이내', '반품', '및', '교환', '서비스를', '약속하며,', '상품', '서명', '후', '지정된', '시간', '내에', '해당', '상품은', '2차', '판매에', '영향을', '미치지', '않습니다.'] +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 17] 변경 없음: '저희 매장은 7일 이내 반품 및 교환 서비스를 약속하며, 상품 서명 후 지정된 시간 내에 해당 상품은 2차 판매에 영향을 미치지 않습니다.' +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 18] 원본 텍스트: '반품이나 교환은 고객센터로 연락주시면 됩니다.' +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 18] 분리된 단어: ['반품이나', '교환은', '고객센터로', '연락주시면', '됩니다.'] +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [치환 처리 18] 변경 없음: '반품이나 교환은 고객센터로 연락주시면 됩니다.' +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] 전체 치환 결과: 18개 텍스트 처리 완료 +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 10 치환됨 +[2026-03-02 20:51:16,445] [LogListener] [DEBUG] [loggerModule.py:debug:449] [AUTO Inpaint] coverage=0.257, comps=8, min_center_dist=0.046 → external_request +[2026-03-02 20:51:16,448] [LogListener] [DEBUG] [loggerModule.py:debug:449] ocr_count: 18 +[2026-03-02 20:51:16,448] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_member_valid: True +[2026-03-02 20:51:16,449] [LogListener] [DEBUG] [loggerModule.py:debug:449] [set_inpaint_method] AUTO 모드에서 external_request 선택됨 → 유지 +[2026-03-02 20:51:16,449] [LogListener] [DEBUG] [loggerModule.py:debug:449] 최종 inpaint_method: external_request +[2026-03-02 20:51:16,475] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 시도: http://e5.m1tcloud.cc:8008 +[2026-03-02 20:51:16,561] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 서버 요청: http://e5.m1tcloud.cc:8008/api/v1/inpaint, model=migan +[2026-03-02 20:51:16,952] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:51:16,956] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11381.9MB -> 11392.6MB (+10.8MB, +0.1%) - 방법: external_request +[2026-03-02 20:51:16,956] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:51:17,180] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:51:17,180] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:51:17,180] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:51:17,250] [LogListener] [DEBUG] [loggerModule.py:debug:449] 외부 인페인팅 성공 +[2026-03-02 20:51:17,253] [LogListener] [DEBUG] [loggerModule.py:debug:449] 메모리 변화 [인페인팅]: 11393.4MB -> 11399.2MB (+5.7MB, +0.1%) - 방법: external_request +[2026-03-02 20:51:17,306] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_11.webp +[2026-03-02 20:51:17,306] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 11 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_11.webp +[2026-03-02 20:51:17,310] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 9091.6ms | download=0.0ms | ocr=3783.5ms | translate=3677.6ms | mask=3677.6ms | inpaint=807.8ms(external_request/SERVER) | render=223.0ms | save=74.0ms +[2026-03-02 20:51:17,311] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:51:17,311] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=b6925576-713f-49c8-9910-65c57ce35f1a +[2026-03-02 20:51:17,311] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=b6925576-713f-49c8-9910-65c57ce35f1a +[2026-03-02 20:51:17,311] [LogListener] [DEBUG] [loggerModule.py:debug:449] 인페인팅 완료 +[2026-03-02 20:51:17,504] [LogListener] [DEBUG] [loggerModule.py:debug:449] 텍스트 렌더링 완료 +[2026-03-02 20:51:17,504] [LogListener] [DEBUG] [loggerModule.py:debug:449] watermark_text: +[2026-03-02 20:51:17,504] [LogListener] [DEBUG] [loggerModule.py:debug:449] is_watermark_enabled: False +[2026-03-02 20:51:17,999] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 저장 완료 : C:\ProgramData\ImgWorker\work\translated_detail_img_10.webp +[2026-03-02 20:51:18,002] [LogListener] [DEBUG] [loggerModule.py:debug:449] 이미지 10 번역 완료: C:\ProgramData\ImgWorker\work\translated_detail_img_10.webp +[2026-03-02 20:51:18,002] [LogListener] [DEBUG] [loggerModule.py:debug:449] ⏱ 이미지 파이프라인 총 9662.0ms | download=0.0ms | ocr=3606.7ms | translate=301.1ms | mask=42.0ms | inpaint=864.7ms(external_request/SERVER) | render=194.2ms | save=447.0ms +[2026-03-02 20:51:18,002] [LogListener] [DEBUG] [loggerModule.py:debug:449] process_single_image 호출 완료 +[2026-03-02 20:51:18,002] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 중: uid=da0904b4-4f0a-4824-9fa4-399b9850aa23 +[2026-03-02 20:51:18,002] [LogListener] [DEBUG] [loggerModule.py:debug:449] 작업 결과 반환 완료: uid=da0904b4-4f0a-4824-9fa4-399b9850aa23