From f23e5441b530ff15a3c75704ee239be167323798 Mon Sep 17 00:00:00 2001 From: Your Name Date: Sat, 27 Apr 2024 03:14:01 -0500 Subject: [PATCH] wip --- common/SConscript | 39 + common/clutil.cc | 200 + common/clutil.h | 29 + common/conversions.py | 2 + common/file_helpers.py | 3 +- common/gpio.cc | 84 + common/gpio.h | 33 + common/gpio.py | 7 +- common/i2c.cc | 92 + common/i2c.h | 19 + common/mat.h | 85 + common/mock/__init__.py | 50 + common/mock/generators.py | 20 + common/params.cc | 607 + common/params.h | 92 + common/params_pyx.cpp | 19684 ---------------- common/params_pyx.so | Bin 4013384 -> 0 bytes common/prefix.h | 34 + common/prefix.py | 3 +- common/queue.h | 52 + common/ratekeeper.cc | 40 + common/ratekeeper.h | 23 + common/realtime.py | 7 +- common/swaglog.cc | 152 + common/swaglog.h | 76 + common/tests/.gitignore | 1 + common/tests/__init__.py | 0 common/tests/test_file_helpers.py | 24 + common/tests/test_numpy_fast.py | 26 + common/tests/test_params.cc | 27 + common/tests/test_params.py | 113 + common/tests/test_runner.cc | 2 + common/tests/test_simple_kalman.py | 35 + common/tests/test_swaglog.cc | 88 + common/tests/test_util.cc | 147 + common/time.py | 2 +- common/timing.h | 51 + common/transformations/.gitignore | 2 + common/transformations/README.md | 70 + common/transformations/SConscript | 5 + common/transformations/camera.py | 97 +- common/transformations/coordinates.cc | 100 + common/transformations/model.py | 21 +- common/transformations/orientation.cc | 144 + common/transformations/orientation.py | 2 +- common/transformations/tests/__init__.py | 0 .../transformations/tests/test_coordinates.py | 109 + .../transformations/tests/test_orientation.py | 68 + common/transformations/transformations.cpp | 16660 ------------- common/transformations/transformations.so | Bin 2314456 -> 0 bytes common/util.cc | 295 + common/util.h | 184 + common/utils.py | 11 + common/version.h | 2 +- common/watchdog.cc | 11 + common/watchdog.h | 5 + 56 files changed, 3319 insertions(+), 36416 deletions(-) create mode 100644 common/SConscript create mode 100644 common/clutil.cc create mode 100644 common/clutil.h create mode 100644 common/gpio.cc create mode 100644 common/gpio.h create mode 100644 common/i2c.cc create mode 100644 common/i2c.h create mode 100644 common/mat.h create mode 100644 common/mock/__init__.py create mode 100644 common/mock/generators.py create mode 100644 common/params.cc create mode 100644 common/params.h delete mode 100644 common/params_pyx.cpp delete mode 100755 common/params_pyx.so create mode 100644 common/prefix.h create mode 100644 common/queue.h create mode 100644 common/ratekeeper.cc create mode 100644 common/ratekeeper.h create mode 100644 common/swaglog.cc create mode 100644 common/swaglog.h create mode 100644 common/tests/.gitignore create mode 100644 common/tests/__init__.py create mode 100644 common/tests/test_file_helpers.py create mode 100644 common/tests/test_numpy_fast.py create mode 100644 common/tests/test_params.cc create mode 100644 common/tests/test_params.py create mode 100644 common/tests/test_runner.cc create mode 100644 common/tests/test_simple_kalman.py create mode 100644 common/tests/test_swaglog.cc create mode 100644 common/tests/test_util.cc create mode 100644 common/timing.h create mode 100644 common/transformations/.gitignore create mode 100644 common/transformations/README.md create mode 100644 common/transformations/SConscript create mode 100644 common/transformations/coordinates.cc create mode 100644 common/transformations/orientation.cc create mode 100644 common/transformations/tests/__init__.py create mode 100644 common/transformations/tests/test_coordinates.py create mode 100644 common/transformations/tests/test_orientation.py delete mode 100644 common/transformations/transformations.cpp delete mode 100755 common/transformations/transformations.so create mode 100644 common/util.cc create mode 100644 common/util.h create mode 100644 common/utils.py create mode 100644 common/watchdog.cc create mode 100644 common/watchdog.h diff --git a/common/SConscript b/common/SConscript new file mode 100644 index 0000000..829db6e --- /dev/null +++ b/common/SConscript @@ -0,0 +1,39 @@ +Import('env', 'envCython', 'arch') + +common_libs = [ + 'params.cc', + 'swaglog.cc', + 'util.cc', + 'i2c.cc', + 'watchdog.cc', + 'ratekeeper.cc' +] + +if arch != "Darwin": + common_libs.append('gpio.cc') + +_common = env.Library('common', common_libs, LIBS="json11") + +files = [ + 'clutil.cc', +] + +_gpucommon = env.Library('gpucommon', files) +Export('_common', '_gpucommon') + +if GetOption('extras'): + env.Program('tests/test_common', + ['tests/test_runner.cc', 'tests/test_params.cc', 'tests/test_util.cc', 'tests/test_swaglog.cc'], + LIBS=[_common, 'json11', 'zmq', 'pthread']) + +# Cython bindings +params_python = envCython.Program('params_pyx.so', 'params_pyx.pyx', LIBS=envCython['LIBS'] + [_common, 'zmq', 'json11']) + +SConscript([ + 'transformations/SConscript', +]) + +Import('transformations_python') +common_python = [params_python, transformations_python] + +Export('common_python') diff --git a/common/clutil.cc b/common/clutil.cc new file mode 100644 index 0000000..4f2a783 --- /dev/null +++ b/common/clutil.cc @@ -0,0 +1,200 @@ +#include "common/clutil.h" + +#include +#include +#include + +#include "common/util.h" +#include "common/swaglog.h" + +namespace { // helper functions + +template +std::string get_info(Func get_info_func, Id id, Name param_name) { + size_t size = 0; + CL_CHECK(get_info_func(id, param_name, 0, NULL, &size)); + std::string info(size, '\0'); + CL_CHECK(get_info_func(id, param_name, size, info.data(), NULL)); + return info; +} +inline std::string get_platform_info(cl_platform_id id, cl_platform_info name) { return get_info(&clGetPlatformInfo, id, name); } +inline std::string get_device_info(cl_device_id id, cl_device_info name) { return get_info(&clGetDeviceInfo, id, name); } + +void cl_print_info(cl_platform_id platform, cl_device_id device) { + size_t work_group_size = 0; + cl_device_type device_type = 0; + clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(work_group_size), &work_group_size, NULL); + clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(device_type), &device_type, NULL); + const char *type_str = "Other..."; + switch (device_type) { + case CL_DEVICE_TYPE_CPU: type_str ="CL_DEVICE_TYPE_CPU"; break; + case CL_DEVICE_TYPE_GPU: type_str = "CL_DEVICE_TYPE_GPU"; break; + case CL_DEVICE_TYPE_ACCELERATOR: type_str = "CL_DEVICE_TYPE_ACCELERATOR"; break; + } + + LOGD("vendor: %s", get_platform_info(platform, CL_PLATFORM_VENDOR).c_str()); + LOGD("platform version: %s", get_platform_info(platform, CL_PLATFORM_VERSION).c_str()); + LOGD("profile: %s", get_platform_info(platform, CL_PLATFORM_PROFILE).c_str()); + LOGD("extensions: %s", get_platform_info(platform, CL_PLATFORM_EXTENSIONS).c_str()); + LOGD("name: %s", get_device_info(device, CL_DEVICE_NAME).c_str()); + LOGD("device version: %s", get_device_info(device, CL_DEVICE_VERSION).c_str()); + LOGD("max work group size: %zu", work_group_size); + LOGD("type = %d, %s", (int)device_type, type_str); +} + +void cl_print_build_errors(cl_program program, cl_device_id device) { + cl_build_status status; + clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL); + size_t log_size; + clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size); + std::string log(log_size, '\0'); + clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, log_size, &log[0], NULL); + + LOGE("build failed; status=%d, log: %s", status, log.c_str()); +} + +} // namespace + +cl_device_id cl_get_device_id(cl_device_type device_type) { + cl_uint num_platforms = 0; + CL_CHECK(clGetPlatformIDs(0, NULL, &num_platforms)); + std::unique_ptr platform_ids = std::make_unique(num_platforms); + CL_CHECK(clGetPlatformIDs(num_platforms, &platform_ids[0], NULL)); + + for (size_t i = 0; i < num_platforms; ++i) { + LOGD("platform[%zu] CL_PLATFORM_NAME: %s", i, get_platform_info(platform_ids[i], CL_PLATFORM_NAME).c_str()); + + // Get first device + if (cl_device_id device_id = NULL; clGetDeviceIDs(platform_ids[i], device_type, 1, &device_id, NULL) == 0 && device_id) { + cl_print_info(platform_ids[i], device_id); + return device_id; + } + } + LOGE("No valid openCL platform found"); + assert(0); + return nullptr; +} + +cl_context cl_create_context(cl_device_id device_id) { + return CL_CHECK_ERR(clCreateContext(NULL, 1, &device_id, NULL, NULL, &err)); +} + +cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char* path, const char* args) { + return cl_program_from_source(ctx, device_id, util::read_file(path), args); +} + +cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string& src, const char* args) { + const char *csrc = src.c_str(); + cl_program prg = CL_CHECK_ERR(clCreateProgramWithSource(ctx, 1, &csrc, NULL, &err)); + if (int err = clBuildProgram(prg, 1, &device_id, args, NULL, NULL); err != 0) { + cl_print_build_errors(prg, device_id); + assert(0); + } + return prg; +} + +cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t* binary, size_t length, const char* args) { + cl_program prg = CL_CHECK_ERR(clCreateProgramWithBinary(ctx, 1, &device_id, &length, &binary, NULL, &err)); + if (int err = clBuildProgram(prg, 1, &device_id, args, NULL, NULL); err != 0) { + cl_print_build_errors(prg, device_id); + assert(0); + } + return prg; +} + +// Given a cl code and return a string representation +#define CL_ERR_TO_STR(err) case err: return #err +const char* cl_get_error_string(int err) { + switch (err) { + CL_ERR_TO_STR(CL_SUCCESS); + CL_ERR_TO_STR(CL_DEVICE_NOT_FOUND); + CL_ERR_TO_STR(CL_DEVICE_NOT_AVAILABLE); + CL_ERR_TO_STR(CL_COMPILER_NOT_AVAILABLE); + CL_ERR_TO_STR(CL_MEM_OBJECT_ALLOCATION_FAILURE); + CL_ERR_TO_STR(CL_OUT_OF_RESOURCES); + CL_ERR_TO_STR(CL_OUT_OF_HOST_MEMORY); + CL_ERR_TO_STR(CL_PROFILING_INFO_NOT_AVAILABLE); + CL_ERR_TO_STR(CL_MEM_COPY_OVERLAP); + CL_ERR_TO_STR(CL_IMAGE_FORMAT_MISMATCH); + CL_ERR_TO_STR(CL_IMAGE_FORMAT_NOT_SUPPORTED); + CL_ERR_TO_STR(CL_MAP_FAILURE); + CL_ERR_TO_STR(CL_MISALIGNED_SUB_BUFFER_OFFSET); + CL_ERR_TO_STR(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST); + CL_ERR_TO_STR(CL_COMPILE_PROGRAM_FAILURE); + CL_ERR_TO_STR(CL_LINKER_NOT_AVAILABLE); + CL_ERR_TO_STR(CL_LINK_PROGRAM_FAILURE); + CL_ERR_TO_STR(CL_DEVICE_PARTITION_FAILED); + CL_ERR_TO_STR(CL_KERNEL_ARG_INFO_NOT_AVAILABLE); + CL_ERR_TO_STR(CL_INVALID_VALUE); + CL_ERR_TO_STR(CL_INVALID_DEVICE_TYPE); + CL_ERR_TO_STR(CL_INVALID_PLATFORM); + CL_ERR_TO_STR(CL_INVALID_DEVICE); + CL_ERR_TO_STR(CL_INVALID_CONTEXT); + CL_ERR_TO_STR(CL_INVALID_QUEUE_PROPERTIES); + CL_ERR_TO_STR(CL_INVALID_COMMAND_QUEUE); + CL_ERR_TO_STR(CL_INVALID_HOST_PTR); + CL_ERR_TO_STR(CL_INVALID_MEM_OBJECT); + CL_ERR_TO_STR(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR); + CL_ERR_TO_STR(CL_INVALID_IMAGE_SIZE); + CL_ERR_TO_STR(CL_INVALID_SAMPLER); + CL_ERR_TO_STR(CL_INVALID_BINARY); + CL_ERR_TO_STR(CL_INVALID_BUILD_OPTIONS); + CL_ERR_TO_STR(CL_INVALID_PROGRAM); + CL_ERR_TO_STR(CL_INVALID_PROGRAM_EXECUTABLE); + CL_ERR_TO_STR(CL_INVALID_KERNEL_NAME); + CL_ERR_TO_STR(CL_INVALID_KERNEL_DEFINITION); + CL_ERR_TO_STR(CL_INVALID_KERNEL); + CL_ERR_TO_STR(CL_INVALID_ARG_INDEX); + CL_ERR_TO_STR(CL_INVALID_ARG_VALUE); + CL_ERR_TO_STR(CL_INVALID_ARG_SIZE); + CL_ERR_TO_STR(CL_INVALID_KERNEL_ARGS); + CL_ERR_TO_STR(CL_INVALID_WORK_DIMENSION); + CL_ERR_TO_STR(CL_INVALID_WORK_GROUP_SIZE); + CL_ERR_TO_STR(CL_INVALID_WORK_ITEM_SIZE); + CL_ERR_TO_STR(CL_INVALID_GLOBAL_OFFSET); + CL_ERR_TO_STR(CL_INVALID_EVENT_WAIT_LIST); + CL_ERR_TO_STR(CL_INVALID_EVENT); + CL_ERR_TO_STR(CL_INVALID_OPERATION); + CL_ERR_TO_STR(CL_INVALID_GL_OBJECT); + CL_ERR_TO_STR(CL_INVALID_BUFFER_SIZE); + CL_ERR_TO_STR(CL_INVALID_MIP_LEVEL); + CL_ERR_TO_STR(CL_INVALID_GLOBAL_WORK_SIZE); + CL_ERR_TO_STR(CL_INVALID_PROPERTY); + CL_ERR_TO_STR(CL_INVALID_IMAGE_DESCRIPTOR); + CL_ERR_TO_STR(CL_INVALID_COMPILER_OPTIONS); + CL_ERR_TO_STR(CL_INVALID_LINKER_OPTIONS); + CL_ERR_TO_STR(CL_INVALID_DEVICE_PARTITION_COUNT); + case -69: return "CL_INVALID_PIPE_SIZE"; + case -70: return "CL_INVALID_DEVICE_QUEUE"; + case -71: return "CL_INVALID_SPEC_ID"; + case -72: return "CL_MAX_SIZE_RESTRICTION_EXCEEDED"; + case -1002: return "CL_INVALID_D3D10_DEVICE_KHR"; + case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR"; + case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR"; + case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR"; + case -1006: return "CL_INVALID_D3D11_DEVICE_KHR"; + case -1007: return "CL_INVALID_D3D11_RESOURCE_KHR"; + case -1008: return "CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR"; + case -1009: return "CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR"; + case -1010: return "CL_INVALID_DX9_MEDIA_ADAPTER_KHR"; + case -1011: return "CL_INVALID_DX9_MEDIA_SURFACE_KHR"; + case -1012: return "CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR"; + case -1013: return "CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR"; + case -1093: return "CL_INVALID_EGL_OBJECT_KHR"; + case -1092: return "CL_EGL_RESOURCE_NOT_ACQUIRED_KHR"; + case -1001: return "CL_PLATFORM_NOT_FOUND_KHR"; + case -1057: return "CL_DEVICE_PARTITION_FAILED_EXT"; + case -1058: return "CL_INVALID_PARTITION_COUNT_EXT"; + case -1059: return "CL_INVALID_PARTITION_NAME_EXT"; + case -1094: return "CL_INVALID_ACCELERATOR_INTEL"; + case -1095: return "CL_INVALID_ACCELERATOR_TYPE_INTEL"; + case -1096: return "CL_INVALID_ACCELERATOR_DESCRIPTOR_INTEL"; + case -1097: return "CL_ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL"; + case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR"; + case -1098: return "CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL"; + case -1099: return "CL_INVALID_VA_API_MEDIA_SURFACE_INTEL"; + case -1100: return "CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL"; + case -1101: return "CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL"; + default: return "CL_UNKNOWN_ERROR"; + } +} diff --git a/common/clutil.h b/common/clutil.h new file mode 100644 index 0000000..af986d6 --- /dev/null +++ b/common/clutil.h @@ -0,0 +1,29 @@ +#pragma once + +#ifdef __APPLE__ +#include +#else +#include +#endif + +#include + +#define CL_CHECK(_expr) \ + do { \ + assert(CL_SUCCESS == (_expr)); \ + } while (0) + +#define CL_CHECK_ERR(_expr) \ + ({ \ + cl_int err = CL_INVALID_VALUE; \ + __typeof__(_expr) _ret = _expr; \ + assert(_ret&& err == CL_SUCCESS); \ + _ret; \ + }) + +cl_device_id cl_get_device_id(cl_device_type device_type); +cl_context cl_create_context(cl_device_id device_id); +cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string& src, const char* args = nullptr); +cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t* binary, size_t length, const char* args = nullptr); +cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char* path, const char* args); +const char* cl_get_error_string(int err); diff --git a/common/conversions.py b/common/conversions.py index ea23a5f..82be9ec 100644 --- a/common/conversions.py +++ b/common/conversions.py @@ -10,6 +10,8 @@ class Conversions: MPH_TO_MS = MPH_TO_KPH * KPH_TO_MS METER_TO_FOOT = 3.28084 FOOT_TO_METER = 1 / METER_TO_FOOT + CM_TO_INCH = METER_TO_FOOT / 100.0 * 12.0; + INCH_TO_CM = 1.0 / CM_TO_INCH; MS_TO_KNOTS = 1.9438 KNOTS_TO_MS = 1. / MS_TO_KNOTS diff --git a/common/file_helpers.py b/common/file_helpers.py index dea298a..29ad219 100644 --- a/common/file_helpers.py +++ b/common/file_helpers.py @@ -1,7 +1,6 @@ import os import tempfile import contextlib -from typing import Optional class CallbackReader: @@ -24,7 +23,7 @@ class CallbackReader: @contextlib.contextmanager -def atomic_write_in_dir(path: str, mode: str = 'w', buffering: int = -1, encoding: Optional[str] = None, newline: Optional[str] = None, +def atomic_write_in_dir(path: str, mode: str = 'w', buffering: int = -1, encoding: str = None, newline: str = None, overwrite: bool = False): """Write to a file atomically using a temporary file in the same directory as the destination file.""" dir_name = os.path.dirname(path) diff --git a/common/gpio.cc b/common/gpio.cc new file mode 100644 index 0000000..dd7ba34 --- /dev/null +++ b/common/gpio.cc @@ -0,0 +1,84 @@ +#include "common/gpio.h" + +#include + +#ifdef __APPLE__ +int gpio_init(int pin_nr, bool output) { + return 0; +} + +int gpio_set(int pin_nr, bool high) { + return 0; +} + +int gpiochip_get_ro_value_fd(const char* consumer_label, int gpiochiop_id, int pin_nr) { + return 0; +} + +#else + +#include +#include + +#include +#include +#include + +#include "common/util.h" +#include "common/swaglog.h" + +int gpio_init(int pin_nr, bool output) { + char pin_dir_path[50]; + int pin_dir_path_len = snprintf(pin_dir_path, sizeof(pin_dir_path), + "/sys/class/gpio/gpio%d/direction", pin_nr); + if (pin_dir_path_len <= 0) { + return -1; + } + const char *value = output ? "out" : "in"; + return util::write_file(pin_dir_path, (void*)value, strlen(value)); +} + +int gpio_set(int pin_nr, bool high) { + char pin_val_path[50]; + int pin_val_path_len = snprintf(pin_val_path, sizeof(pin_val_path), + "/sys/class/gpio/gpio%d/value", pin_nr); + if (pin_val_path_len <= 0) { + return -1; + } + return util::write_file(pin_val_path, (void*)(high ? "1" : "0"), 1); +} + +int gpiochip_get_ro_value_fd(const char* consumer_label, int gpiochiop_id, int pin_nr) { + + // Assumed that all interrupt pins are unexported and rights are given to + // read from gpiochip0. + std::string gpiochip_path = "/dev/gpiochip" + std::to_string(gpiochiop_id); + int fd = open(gpiochip_path.c_str(), O_RDONLY); + if (fd < 0) { + LOGE("Error opening gpiochip0 fd"); + return -1; + } + + // Setup event + struct gpioevent_request rq; + rq.lineoffset = pin_nr; + rq.handleflags = GPIOHANDLE_REQUEST_INPUT; + + /* Requesting both edges as the data ready pulse from the lsm6ds sensor is + very short(75us) and is mostly detected as falling edge instead of rising. + So if it is detected as rising the following falling edge is skipped. */ + rq.eventflags = GPIOEVENT_REQUEST_BOTH_EDGES; + + strncpy(rq.consumer_label, consumer_label, std::size(rq.consumer_label) - 1); + int ret = util::safe_ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &rq); + if (ret == -1) { + LOGE("Unable to get line event from ioctl : %s", strerror(errno)); + close(fd); + return -1; + } + + close(fd); + return rq.fd; +} + +#endif diff --git a/common/gpio.h b/common/gpio.h new file mode 100644 index 0000000..89cdedd --- /dev/null +++ b/common/gpio.h @@ -0,0 +1,33 @@ +#pragma once + +// Pin definitions +#ifdef QCOM2 + #define GPIO_HUB_RST_N 30 + #define GPIO_UBLOX_RST_N 32 + #define GPIO_UBLOX_SAFEBOOT_N 33 + #define GPIO_GNSS_PWR_EN 34 /* SCHEMATIC LABEL: GPIO_UBLOX_PWR_EN */ + #define GPIO_STM_RST_N 124 + #define GPIO_STM_BOOT0 134 + #define GPIO_BMX_ACCEL_INT 21 + #define GPIO_BMX_GYRO_INT 23 + #define GPIO_BMX_MAGN_INT 87 + #define GPIO_LSM_INT 84 + #define GPIOCHIP_INT 0 +#else + #define GPIO_HUB_RST_N 0 + #define GPIO_UBLOX_RST_N 0 + #define GPIO_UBLOX_SAFEBOOT_N 0 + #define GPIO_GNSS_PWR_EN 0 /* SCHEMATIC LABEL: GPIO_UBLOX_PWR_EN */ + #define GPIO_STM_RST_N 0 + #define GPIO_STM_BOOT0 0 + #define GPIO_BMX_ACCEL_INT 0 + #define GPIO_BMX_GYRO_INT 0 + #define GPIO_BMX_MAGN_INT 0 + #define GPIO_LSM_INT 0 + #define GPIOCHIP_INT 0 +#endif + +int gpio_init(int pin_nr, bool output); +int gpio_set(int pin_nr, bool high); + +int gpiochip_get_ro_value_fd(const char* consumer_label, int gpiochiop_id, int pin_nr); diff --git a/common/gpio.py b/common/gpio.py index 88a9479..68932cb 100644 --- a/common/gpio.py +++ b/common/gpio.py @@ -1,6 +1,5 @@ import os from functools import lru_cache -from typing import Optional, List def gpio_init(pin: int, output: bool) -> None: try: @@ -16,7 +15,7 @@ def gpio_set(pin: int, high: bool) -> None: except Exception as e: print(f"Failed to set gpio {pin} value: {e}") -def gpio_read(pin: int) -> Optional[bool]: +def gpio_read(pin: int) -> bool | None: val = None try: with open(f"/sys/class/gpio/gpio{pin}/value", 'rb') as f: @@ -37,7 +36,7 @@ def gpio_export(pin: int) -> None: print(f"Failed to export gpio {pin}") @lru_cache(maxsize=None) -def get_irq_action(irq: int) -> List[str]: +def get_irq_action(irq: int) -> list[str]: try: with open(f"/sys/kernel/irq/{irq}/actions") as f: actions = f.read().strip().split(',') @@ -45,7 +44,7 @@ def get_irq_action(irq: int) -> List[str]: except FileNotFoundError: return [] -def get_irqs_for_action(action: str) -> List[str]: +def get_irqs_for_action(action: str) -> list[str]: ret = [] with open("/proc/interrupts") as f: for l in f.readlines(): diff --git a/common/i2c.cc b/common/i2c.cc new file mode 100644 index 0000000..3d6c79e --- /dev/null +++ b/common/i2c.cc @@ -0,0 +1,92 @@ +#include "common/i2c.h" + +#include +#include +#include + +#include +#include +#include + +#include "common/swaglog.h" +#include "common/util.h" + +#define UNUSED(x) (void)(x) + +#ifdef QCOM2 +// TODO: decide if we want to install libi2c-dev everywhere +extern "C" { + #include + #include +} + +I2CBus::I2CBus(uint8_t bus_id) { + char bus_name[20]; + snprintf(bus_name, 20, "/dev/i2c-%d", bus_id); + + i2c_fd = HANDLE_EINTR(open(bus_name, O_RDWR)); + if (i2c_fd < 0) { + throw std::runtime_error("Failed to open I2C bus"); + } +} + +I2CBus::~I2CBus() { + if (i2c_fd >= 0) { + close(i2c_fd); + } +} + +int I2CBus::read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len) { + std::lock_guard lk(m); + + int ret = 0; + + ret = HANDLE_EINTR(ioctl(i2c_fd, I2C_SLAVE, device_address)); + if (ret < 0) { goto fail; } + + ret = i2c_smbus_read_i2c_block_data(i2c_fd, register_address, len, buffer); + if ((ret < 0) || (ret != len)) { goto fail; } + +fail: + return ret; +} + +int I2CBus::set_register(uint8_t device_address, uint register_address, uint8_t data) { + std::lock_guard lk(m); + + int ret = 0; + + ret = HANDLE_EINTR(ioctl(i2c_fd, I2C_SLAVE, device_address)); + if (ret < 0) { goto fail; } + + ret = i2c_smbus_write_byte_data(i2c_fd, register_address, data); + if (ret < 0) { goto fail; } + +fail: + return ret; +} + +#else + +I2CBus::I2CBus(uint8_t bus_id) { + UNUSED(bus_id); + i2c_fd = -1; +} + +I2CBus::~I2CBus() {} + +int I2CBus::read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len) { + UNUSED(device_address); + UNUSED(register_address); + UNUSED(buffer); + UNUSED(len); + return -1; +} + +int I2CBus::set_register(uint8_t device_address, uint register_address, uint8_t data) { + UNUSED(device_address); + UNUSED(register_address); + UNUSED(data); + return -1; +} +#endif diff --git a/common/i2c.h b/common/i2c.h new file mode 100644 index 0000000..ca0d463 --- /dev/null +++ b/common/i2c.h @@ -0,0 +1,19 @@ +#pragma once + +#include +#include + +#include + +class I2CBus { + private: + int i2c_fd; + std::mutex m; + + public: + I2CBus(uint8_t bus_id); + ~I2CBus(); + + int read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len); + int set_register(uint8_t device_address, uint register_address, uint8_t data); +}; diff --git a/common/mat.h b/common/mat.h new file mode 100644 index 0000000..8e10d61 --- /dev/null +++ b/common/mat.h @@ -0,0 +1,85 @@ +#pragma once + +typedef struct vec3 { + float v[3]; +} vec3; + +typedef struct vec4 { + float v[4]; +} vec4; + +typedef struct mat3 { + float v[3*3]; +} mat3; + +typedef struct mat4 { + float v[4*4]; +} mat4; + +static inline mat3 matmul3(const mat3 &a, const mat3 &b) { + mat3 ret = {{0.0}}; + for (int r=0; r<3; r++) { + for (int c=0; c<3; c++) { + float v = 0.0; + for (int k=0; k<3; k++) { + v += a.v[r*3+k] * b.v[k*3+c]; + } + ret.v[r*3+c] = v; + } + } + return ret; +} + +static inline vec3 matvecmul3(const mat3 &a, const vec3 &b) { + vec3 ret = {{0.0}}; + for (int r=0; r<3; r++) { + for (int c=0; c<3; c++) { + ret.v[r] += a.v[r*3+c] * b.v[c]; + } + } + return ret; +} + +static inline mat4 matmul(const mat4 &a, const mat4 &b) { + mat4 ret = {{0.0}}; + for (int r=0; r<4; r++) { + for (int c=0; c<4; c++) { + float v = 0.0; + for (int k=0; k<4; k++) { + v += a.v[r*4+k] * b.v[k*4+c]; + } + ret.v[r*4+c] = v; + } + } + return ret; +} + +static inline vec4 matvecmul(const mat4 &a, const vec4 &b) { + vec4 ret = {{0.0}}; + for (int r=0; r<4; r++) { + for (int c=0; c<4; c++) { + ret.v[r] += a.v[r*4+c] * b.v[c]; + } + } + return ret; +} + +// scales the input and output space of a transformation matrix +// that assumes pixel-center origin. +static inline mat3 transform_scale_buffer(const mat3 &in, float s) { + // in_pt = ( transform(out_pt/s + 0.5) - 0.5) * s + + mat3 transform_out = {{ + 1.0f/s, 0.0f, 0.5f, + 0.0f, 1.0f/s, 0.5f, + 0.0f, 0.0f, 1.0f, + }}; + + mat3 transform_in = {{ + s, 0.0f, -0.5f*s, + 0.0f, s, -0.5f*s, + 0.0f, 0.0f, 1.0f, + }}; + + return matmul3(transform_in, matmul3(in, transform_out)); +} diff --git a/common/mock/__init__.py b/common/mock/__init__.py new file mode 100644 index 0000000..8c86bbd --- /dev/null +++ b/common/mock/__init__.py @@ -0,0 +1,50 @@ +""" +Utilities for generating mock messages for testing. +example in common/tests/test_mock.py +""" + + +import functools +import threading +from cereal.messaging import PubMaster +from cereal.services import SERVICE_LIST +from openpilot.common.mock.generators import generate_liveLocationKalman +from openpilot.common.realtime import Ratekeeper + + +MOCK_GENERATOR = { + "liveLocationKalman": generate_liveLocationKalman +} + + +def generate_messages_loop(services: list[str], done: threading.Event): + pm = PubMaster(services) + rk = Ratekeeper(100) + i = 0 + while not done.is_set(): + for s in services: + should_send = i % (100/SERVICE_LIST[s].frequency) == 0 + if should_send: + message = MOCK_GENERATOR[s]() + pm.send(s, message) + i += 1 + rk.keep_time() + + +def mock_messages(services: list[str] | str): + if isinstance(services, str): + services = [services] + + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + done = threading.Event() + t = threading.Thread(target=generate_messages_loop, args=(services, done)) + t.start() + try: + return func(*args, **kwargs) + finally: + done.set() + t.join() + return wrapper + return decorator diff --git a/common/mock/generators.py b/common/mock/generators.py new file mode 100644 index 0000000..40951fa --- /dev/null +++ b/common/mock/generators.py @@ -0,0 +1,20 @@ +from cereal import messaging + + +LOCATION1 = (32.7174, -117.16277) +LOCATION2 = (32.7558, -117.2037) + +LLK_DECIMATION = 10 +RENDER_FRAMES = 15 +DEFAULT_ITERATIONS = RENDER_FRAMES * LLK_DECIMATION + + +def generate_liveLocationKalman(location=LOCATION1): + msg = messaging.new_message('liveLocationKalman') + msg.liveLocationKalman.positionGeodetic = {'value': [*location, 0], 'std': [0., 0., 0.], 'valid': True} + msg.liveLocationKalman.positionECEF = {'value': [0., 0., 0.], 'std': [0., 0., 0.], 'valid': True} + msg.liveLocationKalman.calibratedOrientationNED = {'value': [0., 0., 0.], 'std': [0., 0., 0.], 'valid': True} + msg.liveLocationKalman.velocityCalibrated = {'value': [0., 0., 0.], 'std': [0., 0., 0.], 'valid': True} + msg.liveLocationKalman.status = 'valid' + msg.liveLocationKalman.gpsOK = True + return msg diff --git a/common/params.cc b/common/params.cc new file mode 100644 index 0000000..2956079 --- /dev/null +++ b/common/params.cc @@ -0,0 +1,607 @@ +#include "common/params.h" + +#include +#include + +#include +#include +#include +#include + +#include "common/queue.h" +#include "common/swaglog.h" +#include "common/util.h" +#include "system/hardware/hw.h" + +namespace { + +volatile sig_atomic_t params_do_exit = 0; +void params_sig_handler(int signal) { + params_do_exit = 1; +} + +int fsync_dir(const std::string &path) { + int result = -1; + int fd = HANDLE_EINTR(open(path.c_str(), O_RDONLY, 0755)); + if (fd >= 0) { + result = fsync(fd); + close(fd); + } + return result; +} + +bool create_params_path(const std::string ¶m_path, const std::string &key_path) { + // Make sure params path exists + if (!util::file_exists(param_path) && !util::create_directories(param_path, 0775)) { + return false; + } + + // See if the symlink exists, otherwise create it + if (!util::file_exists(key_path)) { + // 1) Create temp folder + // 2) Symlink it to temp link + // 3) Move symlink to /d + + std::string tmp_path = param_path + "/.tmp_XXXXXX"; + // this should be OK since mkdtemp just replaces characters in place + char *tmp_dir = mkdtemp((char *)tmp_path.c_str()); + if (tmp_dir == NULL) { + return false; + } + + std::string link_path = std::string(tmp_dir) + ".link"; + if (symlink(tmp_dir, link_path.c_str()) != 0) { + return false; + } + + // don't return false if it has been created by other + if (rename(link_path.c_str(), key_path.c_str()) != 0 && errno != EEXIST) { + return false; + } + } + + return true; +} + +std::string ensure_params_path(const std::string &prefix, const std::string &path = {}) { + std::string params_path = path.empty() ? Path::params() : path; + if (!create_params_path(params_path, params_path + prefix)) { + throw std::runtime_error(util::string_format( + "Failed to ensure params path, errno=%d, path=%s, param_prefix=%s", + errno, params_path.c_str(), prefix.c_str())); + } + return params_path; +} + +class FileLock { +public: + FileLock(const std::string &fn) { + fd_ = HANDLE_EINTR(open(fn.c_str(), O_CREAT, 0775)); + if (fd_ < 0 || HANDLE_EINTR(flock(fd_, LOCK_EX)) < 0) { + LOGE("Failed to lock file %s, errno=%d", fn.c_str(), errno); + } + } + ~FileLock() { close(fd_); } + +private: + int fd_ = -1; +}; + +std::unordered_map keys = { + {"AccessToken", CLEAR_ON_MANAGER_START | DONT_LOG}, + {"ApiCache_Device", PERSISTENT}, + {"ApiCache_NavDestinations", PERSISTENT}, + {"AssistNowToken", PERSISTENT}, + {"AthenadPid", PERSISTENT}, + {"AthenadUploadQueue", PERSISTENT}, + {"AthenadRecentlyViewedRoutes", PERSISTENT}, + {"BootCount", PERSISTENT}, + {"CalibrationParams", PERSISTENT}, + {"CameraDebugExpGain", CLEAR_ON_MANAGER_START}, + {"CameraDebugExpTime", CLEAR_ON_MANAGER_START}, + {"CarBatteryCapacity", PERSISTENT}, + {"CarParams", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"CarParamsCache", CLEAR_ON_MANAGER_START}, + {"CarParamsPersistent", PERSISTENT}, + {"CarParamsPrevRoute", PERSISTENT}, + {"CarVin", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"CompletedTrainingVersion", PERSISTENT}, + {"ControlsReady", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"CurrentBootlog", PERSISTENT}, + {"CurrentRoute", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"DisableLogging", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"DisablePowerDown", PERSISTENT}, + {"DisableUpdates", PERSISTENT}, + {"DisengageOnAccelerator", PERSISTENT}, + {"DmModelInitialized", CLEAR_ON_ONROAD_TRANSITION}, + {"DongleId", PERSISTENT}, + {"DoReboot", CLEAR_ON_MANAGER_START}, + {"DoShutdown", CLEAR_ON_MANAGER_START}, + {"DoUninstall", CLEAR_ON_MANAGER_START}, + {"ExperimentalLongitudinalEnabled", PERSISTENT | DEVELOPMENT_ONLY}, + {"ExperimentalMode", PERSISTENT}, + {"ExperimentalModeConfirmed", PERSISTENT}, + {"FirmwareQueryDone", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"ForcePowerDown", PERSISTENT}, + {"GitBranch", PERSISTENT}, + {"GitCommit", PERSISTENT}, + {"GitCommitDate", PERSISTENT}, + {"GitDiff", PERSISTENT}, + {"GithubSshKeys", PERSISTENT}, + {"GithubUsername", PERSISTENT}, + {"GitRemote", PERSISTENT}, + {"GsmApn", PERSISTENT}, + {"GsmMetered", PERSISTENT}, + {"GsmRoaming", PERSISTENT}, + {"HardwareSerial", PERSISTENT}, + {"HasAcceptedTerms", PERSISTENT}, + {"IMEI", PERSISTENT}, + {"InstallDate", PERSISTENT}, + {"IsDriverViewEnabled", CLEAR_ON_MANAGER_START}, + {"IsEngaged", PERSISTENT}, + {"IsLdwEnabled", PERSISTENT}, + {"IsMetric", PERSISTENT}, + {"IsOffroad", CLEAR_ON_MANAGER_START}, + {"IsOnroad", PERSISTENT}, + {"IsRhdDetected", PERSISTENT}, + {"IsReleaseBranch", CLEAR_ON_MANAGER_START}, + {"IsTakingSnapshot", CLEAR_ON_MANAGER_START}, + {"IsTestedBranch", CLEAR_ON_MANAGER_START}, + {"JoystickDebugMode", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"LanguageSetting", PERSISTENT}, + {"LastAthenaPingTime", CLEAR_ON_MANAGER_START}, + {"LastGPSPosition", PERSISTENT}, + {"LastManagerExitReason", CLEAR_ON_MANAGER_START}, + {"LastOffroadStatusPacket", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"LastPowerDropDetected", CLEAR_ON_MANAGER_START}, + {"LastUpdateException", CLEAR_ON_MANAGER_START}, + {"LastUpdateTime", PERSISTENT}, + {"LiveParameters", PERSISTENT}, + {"LiveTorqueParameters", PERSISTENT | DONT_LOG}, + {"LongitudinalPersonality", PERSISTENT}, + {"NavDestination", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"NavDestinationWaypoints", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"NavPastDestinations", PERSISTENT}, + {"NavSettingLeftSide", PERSISTENT}, + {"NavSettingTime24h", PERSISTENT}, + {"NetworkMetered", PERSISTENT}, + {"ObdMultiplexingChanged", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"ObdMultiplexingEnabled", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"Offroad_BadNvme", CLEAR_ON_MANAGER_START}, + {"Offroad_CarUnrecognized", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"Offroad_ConnectivityNeeded", CLEAR_ON_MANAGER_START}, + {"Offroad_ConnectivityNeededPrompt", CLEAR_ON_MANAGER_START}, + {"Offroad_InvalidTime", CLEAR_ON_MANAGER_START}, + {"Offroad_IsTakingSnapshot", CLEAR_ON_MANAGER_START}, + {"Offroad_NeosUpdate", CLEAR_ON_MANAGER_START}, + {"Offroad_NoFirmware", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"Offroad_Recalibration", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"Offroad_StorageMissing", CLEAR_ON_MANAGER_START}, + {"Offroad_TemperatureTooHigh", CLEAR_ON_MANAGER_START}, + {"Offroad_UnofficialHardware", CLEAR_ON_MANAGER_START}, + {"Offroad_UpdateFailed", CLEAR_ON_MANAGER_START}, + {"OpenpilotEnabledToggle", PERSISTENT}, + {"PandaHeartbeatLost", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"PandaSomResetTriggered", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"PandaSignatures", CLEAR_ON_MANAGER_START}, + {"PrimeType", PERSISTENT}, + {"RecordFront", PERSISTENT}, + {"RecordFrontLock", PERSISTENT}, // for the internal fleet + {"ReplayControlsState", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"RouteCount", PERSISTENT}, + {"SnoozeUpdate", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION}, + {"SshEnabled", PERSISTENT}, + {"TermsVersion", PERSISTENT}, + {"Timezone", PERSISTENT}, + {"TrainingVersion", PERSISTENT}, + {"UbloxAvailable", PERSISTENT}, + {"UpdateAvailable", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, + {"UpdateFailedCount", CLEAR_ON_MANAGER_START}, + {"UpdaterAvailableBranches", PERSISTENT}, + {"UpdaterCurrentDescription", CLEAR_ON_MANAGER_START}, + {"UpdaterCurrentReleaseNotes", CLEAR_ON_MANAGER_START}, + {"UpdaterFetchAvailable", CLEAR_ON_MANAGER_START}, + {"UpdaterNewDescription", CLEAR_ON_MANAGER_START}, + {"UpdaterNewReleaseNotes", CLEAR_ON_MANAGER_START}, + {"UpdaterState", CLEAR_ON_MANAGER_START}, + {"UpdaterTargetBranch", CLEAR_ON_MANAGER_START}, + {"UpdaterLastFetchTime", PERSISTENT}, + {"Version", PERSISTENT}, + + // FrogPilot parameters + {"AccelerationPath", PERSISTENT}, + {"AccelerationProfile", PERSISTENT}, + {"AdjacentPath", PERSISTENT}, + {"AdjacentPathMetrics", PERSISTENT}, + {"AggressiveAcceleration", PERSISTENT}, + {"AggressiveFollow", PERSISTENT}, + {"AggressiveJerk", PERSISTENT}, + {"AlertVolumeControl", PERSISTENT}, + {"AlwaysOnLateral", PERSISTENT}, + {"AlwaysOnLateralMain", PERSISTENT}, + {"AMapKey1", PERSISTENT}, + {"AMapKey2", PERSISTENT}, + {"ApiCache_DriveStats", PERSISTENT}, + {"AutomaticUpdates", PERSISTENT}, + {"AvailableModels", PERSISTENT}, + {"AvailableModelsNames", PERSISTENT}, + {"BigMap", PERSISTENT}, + {"BlindSpotPath", PERSISTENT}, + {"CameraFPS", PERSISTENT}, + {"CameraView", PERSISTENT}, + {"CarMake", PERSISTENT}, + {"CarModel", PERSISTENT}, + {"CarSpeedLimit", PERSISTENT}, + {"CECurves", PERSISTENT}, + {"CECurvesLead", PERSISTENT}, + {"CENavigation", PERSISTENT}, + {"CENavigationIntersections", PERSISTENT}, + {"CENavigationLead", PERSISTENT}, + {"CENavigationTurns", PERSISTENT}, + {"CESignal", PERSISTENT}, + {"CESlowerLead", PERSISTENT}, + {"CESpeed", PERSISTENT}, + {"CESpeedLead", PERSISTENT}, + {"CEStatus", PERSISTENT}, + {"CEStopLights", PERSISTENT}, + {"CEStopLightsLead", PERSISTENT}, + {"Compass", PERSISTENT}, + {"ConditionalExperimental", PERSISTENT}, + {"CrosstrekTorque", PERSISTENT}, + {"CurrentHolidayTheme", PERSISTENT}, + {"CurrentRandomEvent", PERSISTENT}, + {"CurveSensitivity", PERSISTENT}, + {"CustomAlerts", PERSISTENT}, + {"CustomColors", PERSISTENT}, + {"CustomCruise", PERSISTENT}, + {"CustomCruiseLong", PERSISTENT}, + {"CustomIcons", PERSISTENT}, + {"CustomPaths", PERSISTENT}, + {"CustomPersonalities", PERSISTENT}, + {"CustomUI", PERSISTENT}, + {"CustomSignals", PERSISTENT}, + {"CustomSounds", PERSISTENT}, + {"CustomTheme", PERSISTENT}, + {"CydiaTune", PERSISTENT}, + {"DecelerationProfile", PERSISTENT}, + {"DeveloperUI", PERSISTENT}, + {"DeviceManagement", PERSISTENT}, + {"DeviceShutdown", PERSISTENT}, + {"DisableMTSCSmoothing", PERSISTENT}, + {"DisableOnroadUploads", PERSISTENT}, + {"DisableOpenpilotLongitudinal", PERSISTENT}, + {"DisableVTSCSmoothing", PERSISTENT}, + {"DisengageVolume", PERSISTENT}, + {"DistanceLongPressed", PERSISTENT}, + {"DoSoftReboot", CLEAR_ON_MANAGER_START}, + {"DragonPilotTune", PERSISTENT}, + {"DriverCamera", PERSISTENT}, + {"DynamicPathWidth", PERSISTENT}, + {"EngageVolume", PERSISTENT}, + {"EVTable", PERSISTENT}, + {"ExperimentalModeActivation", PERSISTENT}, + {"ExperimentalModeViaDistance", PERSISTENT}, + {"ExperimentalModeViaLKAS", PERSISTENT}, + {"ExperimentalModeViaTap", PERSISTENT}, + {"Fahrenheit", PERSISTENT}, + {"FingerprintLogged", CLEAR_ON_MANAGER_START}, + {"ForceAutoTune", PERSISTENT}, + {"ForceFingerprint", PERSISTENT}, + {"ForceMPHDashboard", PERSISTENT}, + {"FPSCounter", PERSISTENT}, + {"FrogPilotDrives", PERSISTENT}, + {"FrogPilotKilometers", PERSISTENT}, + {"FrogPilotMinutes", PERSISTENT}, + {"FrogPilotTogglesUpdated", PERSISTENT}, + {"FrogsGoMoo", PERSISTENT}, + {"FrogsGoMooTune", PERSISTENT}, + {"FullMap", PERSISTENT}, + {"GasRegenCmd", PERSISTENT}, + {"GMapKey", PERSISTENT}, + {"GoatScream", PERSISTENT}, + {"GreenLightAlert", PERSISTENT}, + {"HideAlerts", PERSISTENT}, + {"HideAOLStatusBar", PERSISTENT}, + {"HideCEMStatusBar", PERSISTENT}, + {"HideDisableOpenpilotLongitudinal", PERSISTENT}, + {"HideLeadMarker", PERSISTENT}, + {"HideMapIcon", PERSISTENT}, + {"HideMaxSpeed", PERSISTENT}, + {"HideSpeed", PERSISTENT}, + {"HideSpeedUI", PERSISTENT}, + {"HideUIElements", PERSISTENT}, + {"HigherBitrate", PERSISTENT}, + {"HolidayThemes", PERSISTENT}, + {"IncreaseThermalLimits", PERSISTENT}, + {"KaofuiIcons", PERSISTENT}, + {"kiV1", PERSISTENT}, + {"kiV2", PERSISTENT}, + {"kiV3", PERSISTENT}, + {"kiV4", PERSISTENT}, + {"kpV1", PERSISTENT}, + {"kpV2", PERSISTENT}, + {"kpV3", PERSISTENT}, + {"kpV4", PERSISTENT}, + {"LaneChangeTime", PERSISTENT}, + {"LaneDetectionWidth", PERSISTENT}, + {"LaneLinesWidth", PERSISTENT}, + {"LastMapsUpdate", PERSISTENT}, + {"LateralTune", PERSISTENT}, + {"LeadDepartingAlert", PERSISTENT}, + {"LeadDetectionThreshold", PERSISTENT}, + {"LeadInfo", PERSISTENT}, + {"LockDoors", PERSISTENT}, + {"LongitudinalTune", PERSISTENT}, + {"LongPitch", PERSISTENT}, + {"LoudBlindspotAlert", PERSISTENT}, + {"LowVoltageShutdown", PERSISTENT}, + {"ManualUpdateInitiated", PERSISTENT}, + {"MapboxPublicKey", PERSISTENT}, + {"MapboxSecretKey", PERSISTENT}, + {"MapsSelected", PERSISTENT}, + {"MapSpeedLimit", PERSISTENT}, + {"MapStyle", PERSISTENT}, + {"MapTargetLatA", PERSISTENT}, + {"MapTargetVelocities", PERSISTENT}, + {"Model", PERSISTENT}, + {"ModelDownloadProgress", PERSISTENT}, + {"ModelName", PERSISTENT}, + {"ModelSelector", PERSISTENT}, + {"ModelToDownload", PERSISTENT}, + {"ModelUI", PERSISTENT}, + {"MTSCAggressiveness", PERSISTENT}, + {"MTSCCurvatureCheck", PERSISTENT}, + {"MTSCEnabled", PERSISTENT}, + {"NavSpeedLimit", PERSISTENT}, + {"NNFF", PERSISTENT}, + {"NNFFLite", PERSISTENT}, + {"NNFFModelName", PERSISTENT}, + {"NoLogging", PERSISTENT}, + {"NoUploads", PERSISTENT}, + {"NudgelessLaneChange", PERSISTENT}, + {"NumericalTemp", PERSISTENT}, + {"OfflineMode", PERSISTENT}, + {"Offset1", PERSISTENT}, + {"Offset2", PERSISTENT}, + {"Offset3", PERSISTENT}, + {"Offset4", PERSISTENT}, + {"OneLaneChange", PERSISTENT}, + {"OnroadDistanceButton", PERSISTENT}, + {"OnroadDistanceButtonPressed", PERSISTENT}, + {"OSMDownloadBounds", PERSISTENT}, + {"OSMDownloadLocations", PERSISTENT}, + {"OSMDownloadProgress", CLEAR_ON_MANAGER_START}, + {"PathEdgeWidth", PERSISTENT}, + {"PathWidth", PERSISTENT}, + {"PauseAOLOnBrake", PERSISTENT}, + {"PauseLateralOnSignal", PERSISTENT}, + {"PauseLateralSpeed", PERSISTENT}, + {"PedalsOnUI", PERSISTENT}, + {"PreferredSchedule", PERSISTENT}, + {"PreviousSpeedLimit", PERSISTENT}, + {"PromptDistractedVolume", PERSISTENT}, + {"PromptVolume", PERSISTENT}, + {"QOLControls", PERSISTENT}, + {"QOLVisuals", PERSISTENT}, + {"RandomEvents", PERSISTENT}, + {"RefuseVolume", PERSISTENT}, + {"RelaxedFollow", PERSISTENT}, + {"RelaxedJerk", PERSISTENT}, + {"ResetSteerRatio", PERSISTENT}, + {"ReverseCruise", PERSISTENT}, + {"ReverseCruiseUI", PERSISTENT}, + {"RoadEdgesWidth", PERSISTENT}, + {"RoadName", PERSISTENT}, + {"RoadNameUI", PERSISTENT}, + {"RotatingWheel", PERSISTENT}, + {"SchedulePending", PERSISTENT}, + {"ScreenBrightness", PERSISTENT}, + {"ScreenBrightnessOnroad", PERSISTENT}, + {"ScreenManagement", PERSISTENT}, + {"ScreenRecorder", PERSISTENT}, + {"ScreenTimeout", PERSISTENT}, + {"ScreenTimeoutOnroad", PERSISTENT}, + {"SearchInput", PERSISTENT}, + {"SetSpeedLimit", PERSISTENT}, + {"SetSpeedOffset", PERSISTENT}, + {"ShowCPU", PERSISTENT}, + {"ShowGPU", PERSISTENT}, + {"ShowIP", PERSISTENT}, + {"ShowJerk", PERSISTENT}, + {"ShowMemoryUsage", PERSISTENT}, + {"ShowSLCOffset", PERSISTENT}, + {"ShowSLCOffsetUI", PERSISTENT}, + {"ShowStorageLeft", PERSISTENT}, + {"ShowStorageUsed", PERSISTENT}, + {"ShowTuning", PERSISTENT}, + {"Sidebar", PERSISTENT}, + {"SLCConfirmation", PERSISTENT}, + {"SLCConfirmationLower", PERSISTENT}, + {"SLCConfirmationHigher", PERSISTENT}, + {"SLCConfirmed", PERSISTENT}, + {"SLCConfirmedPressed", PERSISTENT}, + {"SLCLookaheadHigher", PERSISTENT}, + {"SLCLookaheadLower", PERSISTENT}, + {"SLCFallback", PERSISTENT}, + {"SLCOverride", PERSISTENT}, + {"SLCPriority", PERSISTENT}, + {"SLCPriority1", PERSISTENT}, + {"SLCPriority2", PERSISTENT}, + {"SLCPriority3", PERSISTENT}, + {"SmoothBraking", PERSISTENT}, + {"SmoothBrakingFarLead", PERSISTENT}, + {"SmoothBrakingJerk", PERSISTENT}, + {"SNGHack", PERSISTENT}, + {"SpeedLimitController", PERSISTENT}, + {"SpeedLimitChangedAlert", PERSISTENT}, + {"StandardFollow", PERSISTENT}, + {"StandardJerk", PERSISTENT}, + {"StandbyMode", PERSISTENT}, + {"SteerRatio", PERSISTENT}, + {"SteerRatioStock", PERSISTENT}, + {"StockTune", PERSISTENT}, + {"StoppingDistance", PERSISTENT}, + {"TacoTune", PERSISTENT}, + {"TetheringEnabled", PERSISTENT}, + {"ToyotaDoors", PERSISTENT}, + {"TrafficFollow", PERSISTENT}, + {"TrafficJerk", PERSISTENT}, + {"TrafficMode", PERSISTENT}, + {"TrafficModeActive", CLEAR_ON_OFFROAD_TRANSITION}, + {"Tuning", PERSISTENT}, + {"TurnAggressiveness", PERSISTENT}, + {"TurnDesires", PERSISTENT}, + {"UnlimitedLength", PERSISTENT}, + {"UnlockDoors", PERSISTENT}, + {"Updated", PERSISTENT}, + {"UseSI", PERSISTENT}, + {"UseVienna", PERSISTENT}, + {"VisionTurnControl", PERSISTENT}, + {"WarningImmediateVolume", PERSISTENT}, + {"WarningSoftVolume", PERSISTENT}, + {"WheelIcon", PERSISTENT}, + {"WheelSpeed", PERSISTENT}, +}; + +} // namespace + + +Params::Params(const std::string &path) { + params_prefix = "/" + util::getenv("OPENPILOT_PREFIX", "d"); + params_path = ensure_params_path(params_prefix, path); +} + +Params::~Params() { + if (future.valid()) { + future.wait(); + } + assert(queue.empty()); +} + +std::vector Params::allKeys() const { + std::vector ret; + for (auto &p : keys) { + ret.push_back(p.first); + } + return ret; +} + +bool Params::checkKey(const std::string &key) { + return keys.find(key) != keys.end(); +} + +ParamKeyType Params::getKeyType(const std::string &key) { + return static_cast(keys[key]); +} + +int Params::put(const char* key, const char* value, size_t value_size) { + // Information about safely and atomically writing a file: https://lwn.net/Articles/457667/ + // 1) Create temp file + // 2) Write data to temp file + // 3) fsync() the temp file + // 4) rename the temp file to the real name + // 5) fsync() the containing directory + std::string tmp_path = params_path + "/.tmp_value_XXXXXX"; + int tmp_fd = mkstemp((char*)tmp_path.c_str()); + if (tmp_fd < 0) return -1; + + int result = -1; + do { + // Write value to temp. + ssize_t bytes_written = HANDLE_EINTR(write(tmp_fd, value, value_size)); + if (bytes_written < 0 || (size_t)bytes_written != value_size) { + result = -20; + break; + } + + // fsync to force persist the changes. + if ((result = fsync(tmp_fd)) < 0) break; + + FileLock file_lock(params_path + "/.lock"); + + // Move temp into place. + if ((result = rename(tmp_path.c_str(), getParamPath(key).c_str())) < 0) break; + + // fsync parent directory + result = fsync_dir(getParamPath()); + } while (false); + + close(tmp_fd); + ::unlink(tmp_path.c_str()); + return result; +} + +int Params::remove(const std::string &key) { + FileLock file_lock(params_path + "/.lock"); + int result = unlink(getParamPath(key).c_str()); + if (result != 0) { + return result; + } + return fsync_dir(getParamPath()); +} + +std::string Params::get(const std::string &key, bool block) { + if (!block) { + return util::read_file(getParamPath(key)); + } else { + // blocking read until successful + params_do_exit = 0; + void (*prev_handler_sigint)(int) = std::signal(SIGINT, params_sig_handler); + void (*prev_handler_sigterm)(int) = std::signal(SIGTERM, params_sig_handler); + + std::string value; + while (!params_do_exit) { + if (value = util::read_file(getParamPath(key)); !value.empty()) { + break; + } + util::sleep_for(100); // 0.1 s + } + + std::signal(SIGINT, prev_handler_sigint); + std::signal(SIGTERM, prev_handler_sigterm); + return value; + } +} + +std::map Params::readAll() { + FileLock file_lock(params_path + "/.lock"); + return util::read_files_in_dir(getParamPath()); +} + +void Params::clearAll(ParamKeyType key_type) { + FileLock file_lock(params_path + "/.lock"); + + // 1) delete params of key_type + // 2) delete files that are not defined in the keys. + if (DIR *d = opendir(getParamPath().c_str())) { + struct dirent *de = NULL; + while ((de = readdir(d))) { + if (de->d_type != DT_DIR) { + auto it = keys.find(de->d_name); + if (it == keys.end() || (it->second & key_type)) { + unlink(getParamPath(de->d_name).c_str()); + } + } + } + closedir(d); + } + + fsync_dir(getParamPath()); +} + +void Params::putNonBlocking(const std::string &key, const std::string &val) { + queue.push(std::make_pair(key, val)); + // start thread on demand + if (!future.valid() || future.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready) { + future = std::async(std::launch::async, &Params::asyncWriteThread, this); + } +} + +void Params::asyncWriteThread() { + // TODO: write the latest one if a key has multiple values in the queue. + std::pair p; + while (queue.try_pop(p, 0)) { + // Params::put is Thread-Safe + put(p.first, p.second); + } +} diff --git a/common/params.h b/common/params.h new file mode 100644 index 0000000..9c8af82 --- /dev/null +++ b/common/params.h @@ -0,0 +1,92 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "common/queue.h" + +enum ParamKeyType { + PERSISTENT = 0x02, + CLEAR_ON_MANAGER_START = 0x04, + CLEAR_ON_ONROAD_TRANSITION = 0x08, + CLEAR_ON_OFFROAD_TRANSITION = 0x10, + DONT_LOG = 0x20, + DEVELOPMENT_ONLY = 0x40, + ALL = 0xFFFFFFFF +}; + +class Params { +public: + explicit Params(const std::string &path = {}); + ~Params(); + // Not copyable. + Params(const Params&) = delete; + Params& operator=(const Params&) = delete; + + std::vector allKeys() const; + bool checkKey(const std::string &key); + ParamKeyType getKeyType(const std::string &key); + inline std::string getParamPath(const std::string &key = {}) { + return params_path + params_prefix + (key.empty() ? "" : "/" + key); + } + + // Delete a value + int remove(const std::string &key); + void clearAll(ParamKeyType type); + + // helpers for reading values + std::string get(const std::string &key, bool block = false); + inline bool getBool(const std::string &key, bool block = false) { + return get(key, block) == "1"; + } + inline int getInt(const std::string &key, bool block = false) { + std::string value = get(key, block); + return value.empty() ? 0 : std::stoi(value); + } + inline float getFloat(const std::string &key, bool block = false) { + std::string value = get(key, block); + return value.empty() ? 0.0 : std::stof(value); + } + std::map readAll(); + + // helpers for writing values + int put(const char *key, const char *val, size_t value_size); + inline int put(const std::string &key, const std::string &val) { + return put(key.c_str(), val.data(), val.size()); + } + inline int putBool(const std::string &key, bool val) { + return put(key.c_str(), val ? "1" : "0", 1); + } + inline int putInt(const std::string &key, int val) { + return put(key.c_str(), std::to_string(val).c_str(), std::to_string(val).size()); + } + inline int putFloat(const std::string &key, float val) { + return put(key.c_str(), std::to_string(val).c_str(), std::to_string(val).size()); + } + void putNonBlocking(const std::string &key, const std::string &val); + inline void putBoolNonBlocking(const std::string &key, bool val) { + putNonBlocking(key, val ? "1" : "0"); + } + void putIntNonBlocking(const std::string &key, const std::string &val); + inline void putIntNonBlocking(const std::string &key, int val) { + putNonBlocking(key, std::to_string(val)); + } + void putFloatNonBlocking(const std::string &key, const std::string &val); + inline void putFloatNonBlocking(const std::string &key, float val) { + putNonBlocking(key, std::to_string(val)); + } + +private: + void asyncWriteThread(); + + std::string params_path; + std::string params_prefix; + + // for nonblocking write + std::future future; + SafeQueue> queue; +}; diff --git a/common/params_pyx.cpp b/common/params_pyx.cpp deleted file mode 100644 index 6e28104..0000000 --- a/common/params_pyx.cpp +++ /dev/null @@ -1,19684 +0,0 @@ -/* Generated by Cython 3.0.8 */ - -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [ - "common/params.h" - ], - "language": "c++", - "name": "common.params_pyx", - "sources": [ - "/data/openpilot/common/params_pyx.pyx" - ] - }, - "module_name": "common.params_pyx" -} -END: Cython Metadata */ - -#ifndef PY_SSIZE_T_CLEAN -#define PY_SSIZE_T_CLEAN -#endif /* PY_SSIZE_T_CLEAN */ -#if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif -#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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. -#else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x030008F0 -#define CYTHON_FUTURE_DIVISION 1 -#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_NOGIL 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 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #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_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 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 (PY_MAJOR_VERSION >= 3) - #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_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 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 0 - #endif -#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_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #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_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 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 (PY_MAJOR_VERSION >= 3) - #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_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #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 -#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_NOGIL 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_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 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 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 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 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #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 -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #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_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #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 -#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 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef 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 - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || 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 - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #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 - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #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) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(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 -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #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 -# 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 -#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)) - -#ifndef __cplusplus - #error "Cython files generated with the C++ option must be compiled with a C++ compiler." -#endif -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #else - #define CYTHON_INLINE inline - #endif -#endif -template -void __Pyx_call_destructor(T& x) { - x.~T(); -} -template -class __Pyx_FakeReference { - public: - __Pyx_FakeReference() : ptr(NULL) { } - __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } - T *operator->() { return ptr; } - T *operator&() { return ptr; } - operator T&() { return *ptr; } - template bool operator ==(const U& other) const { return *ptr == other; } - template bool operator !=(const U& other) const { return *ptr != other; } - template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } - template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } - private: - T *ptr; -}; - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #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) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE 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, "iiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOOiOO", 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; - } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE 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; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - 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, empty_bytes); - Py_DECREF(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 -#endif -#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 CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#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 -#if PY_VERSION_HEX <= 0x030700A3 || !defined(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 - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords -#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_MAJOR_VERSION >= 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) { -#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 < 0x030900B1 - #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_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_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() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -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; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && 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 PY_MAJOR_VERSION >= 3 && (!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) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#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 CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #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)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #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_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #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 -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#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) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef 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_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#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 PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#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_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_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #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) -#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_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #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) -#endif -#if PY_VERSION_HEX >= 0x030d00A1 - #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 PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_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 - -#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; } -#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 - #define __PYX_EXTERN_C extern "C++" -#endif - -#define __PYX_HAVE__common__params_pyx -#define __PYX_HAVE_API__common__params_pyx -/* Early includes */ -#include -#include -#include "ios" -#include "new" -#include "stdexcept" -#include "typeinfo" -#include -#include "common/params.h" -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#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 PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#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_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_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) -{ - const wchar_t *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#else -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#endif -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -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_IntOrLong(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_PyInt_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)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#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 PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#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__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "common/params_pyx.pyx", - "", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - -/* NoFastGil.proto */ -#define __Pyx_PyGILState_Ensure PyGILState_Ensure -#define __Pyx_PyGILState_Release PyGILState_Release -#define __Pyx_FastGIL_Remember() -#define __Pyx_FastGIL_Forget() -#define __Pyx_FastGilFuncInit() - -/* #### Code section: numeric_typedefs ### */ -/* #### Code section: complex_type_declarations ### */ -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_obj_6common_10params_pyx_Params; -struct __pyx_obj___Pyx_EnumMeta; - -/* "common/params_pyx.pyx":43 - * pass - * - * cdef class Params: # <<<<<<<<<<<<<< - * cdef c_Params* p - * - */ -struct __pyx_obj_6common_10params_pyx_Params { - PyObject_HEAD - Params *p; -}; - - -/* "EnumBase":16 - * - * @cython.internal - * cdef class __Pyx_EnumMeta(type): # <<<<<<<<<<<<<< - * def __init__(cls, name, parents, dct): - * type.__init__(cls, name, parents, dct) - */ -struct __pyx_obj___Pyx_EnumMeta { - PyHeapTypeObject __pyx_base; -}; - -/* #### 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; -#ifdef WITH_THREAD - #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);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #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); - -/* 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_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 - -/* 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 **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" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #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 **args, size_t nargs, PyObject *kwargs); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -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_Arg_VARARGS(args, i) PySequence_GetItem(args, i) -#elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) -#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_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_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 - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) -#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); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* 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) PyObject_DelAttr(o,n) -#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) -#endif - -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__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)\ - (__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)\ - (__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); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* 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 - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); - -/* RaiseUnexpectedTypeError.proto */ -static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* PySequenceContains.proto */ -static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { - int result = PySequence_Contains(seq, item); - return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); -} - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); - -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); - -/* HasAttr.proto */ -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 -#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) -#else -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); -#endif - -/* MoveIfSupported.proto */ -#if CYTHON_USE_CPP_STD_MOVE - #include - #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) -#else - #define __PYX_STD_MOVE_IF_SUPPORTED(x) x -#endif - -/* IncludeCppStringH.proto */ -#include - -/* decode_c_string_utf16.proto */ -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = 0; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = -1; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = 1; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} - -/* decode_c_bytes.proto */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( - const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); - -/* decode_cpp_string.proto */ -static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string( - std::string cppstring, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - return __Pyx_decode_c_bytes( - cppstring.data(), cppstring.size(), start, stop, encoding, errors, decode_func); -} - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* 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); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -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); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -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 - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 || 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 - void *defaults; - int defaults_pyobjects; - size_t defaults_size; - 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_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); -#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 void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); -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 -#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); - -/* Py3UpdateBases.proto */ -static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); - -/* SetNameInClass.proto */ -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && 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 - -/* SetNewInClass.proto */ -static int __Pyx_SetNewInClass(PyObject *ns, PyObject *name, PyObject *value); - -/* CalculateMetaclass.proto */ -static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); - -/* PyObjectCall2Args.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); - -/* 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 - -/* 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); - -/* Globals.proto */ -static PyObject* __Pyx_Globals(void); - -/* dict_getitem_default.proto */ -static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); - -/* UnpackUnboundCMethod.proto */ -typedef struct { - PyObject *type; - PyObject **method_name; - PyCFunction func; - PyObject *method; - int flag; -} __Pyx_CachedCFunction; - -/* CallUnboundCMethod1.proto */ -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 - -/* CallUnboundCMethod2.proto */ -static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 -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 - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* 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 - -/* CppExceptionConversion.proto */ -#ifndef __Pyx_CppExn2PyErr -#include -#include -#include -#include -static void __Pyx_CppExn2PyErr() { - try { - if (PyErr_Occurred()) - ; // let the latest Python exn pass through and ignore the current one - else - throw; - } catch (const std::bad_alloc& exn) { - PyErr_SetString(PyExc_MemoryError, exn.what()); - } catch (const std::bad_cast& exn) { - PyErr_SetString(PyExc_TypeError, exn.what()); - } catch (const std::bad_typeid& exn) { - PyErr_SetString(PyExc_TypeError, exn.what()); - } catch (const std::domain_error& exn) { - PyErr_SetString(PyExc_ValueError, exn.what()); - } catch (const std::invalid_argument& exn) { - PyErr_SetString(PyExc_ValueError, exn.what()); - } catch (const std::ios_base::failure& exn) { - PyErr_SetString(PyExc_IOError, exn.what()); - } catch (const std::out_of_range& exn) { - PyErr_SetString(PyExc_IndexError, exn.what()); - } catch (const std::overflow_error& exn) { - PyErr_SetString(PyExc_OverflowError, exn.what()); - } catch (const std::range_error& exn) { - PyErr_SetString(PyExc_ArithmeticError, exn.what()); - } catch (const std::underflow_error& exn) { - PyErr_SetString(PyExc_ArithmeticError, exn.what()); - } catch (const std::exception& exn) { - PyErr_SetString(PyExc_RuntimeError, exn.what()); - } - catch (...) - { - PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); - } -} -#endif - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE enum ParamKeyType __Pyx_PyInt_As_enum__ParamKeyType(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__ParamKeyType(enum ParamKeyType value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* 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) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (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) - -/* CheckBinaryVersion.proto */ -static unsigned long __Pyx_get_runtime_version(void); -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ - -/* Module declarations from "libcpp" */ - -/* Module declarations from "libc.string" */ - -/* Module declarations from "libcpp.string" */ - -/* Module declarations from "libcpp.vector" */ - -/* Module declarations from "common.params_pyx" */ -static PyObject *__Pyx_OrderedDict = 0; -static PyObject *__Pyx_EnumBase = 0; -static PyObject *__Pyx_FlagBase = 0; -static PyObject *__Pyx_globals = 0; -static PyObject *__Pyx_Enum_enum__space_ParamKeyType_to_py(enum ParamKeyType); /*proto*/ -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &); /*proto*/ -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_string(std::vector const &); /*proto*/ -static PyObject *__pyx_unpickle___Pyx_EnumMeta__set_state(struct __pyx_obj___Pyx_EnumMeta *, PyObject *); /*proto*/ -/* #### Code section: typeinfo ### */ -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "common.params_pyx" -extern int __pyx_module_is_main_common__params_pyx; -int __pyx_module_is_main_common__params_pyx = 0; - -/* Implementation of "common.params_pyx" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_KeyboardInterrupt; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_MemoryError; -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_ValueError; -/* #### Code section: string_decls ### */ -static const char __pyx_k_[] = ""; -static const char __pyx_k_d[] = "d"; -static const char __pyx_k_k[] = "k"; -static const char __pyx_k_r[] = "r"; -static const char __pyx_k_v[] = "v"; -static const char __pyx_k__3[] = "."; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_ALL[] = "ALL"; -static const char __pyx_k__52[] = "?"; -static const char __pyx_k_cls[] = "cls"; -static const char __pyx_k_dat[] = "dat"; -static const char __pyx_k_dct[] = "dct"; -static const char __pyx_k_doc[] = "__doc__"; -static const char __pyx_k_get[] = "get"; -static const char __pyx_k_key[] = "key"; -static const char __pyx_k_new[] = "__new__"; -static const char __pyx_k_put[] = "put"; -static const char __pyx_k_res[] = "res"; -static const char __pyx_k_s_s[] = "%s.%s"; -static const char __pyx_k_str[] = "__str__"; -static const char __pyx_k_val[] = "val"; -static const char __pyx_k_dict[] = "__dict__"; -static const char __pyx_k_enum[] = "enum"; -static const char __pyx_k_init[] = "__init__"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "name"; -static const char __pyx_k_repr[] = "__repr__"; -static const char __pyx_k_self[] = "self"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_block[] = "block"; -static const char __pyx_k_class[] = "__class__"; -static const char __pyx_k_range[] = "range"; -static const char __pyx_k_s_s_d[] = "<%s.%s: %d>"; -static const char __pyx_k_state[] = "state"; -static const char __pyx_k_super[] = "super"; -static const char __pyx_k_value[] = "value"; -static const char __pyx_k_Params[] = "Params"; -static const char __pyx_k_decode[] = "decode"; -static const char __pyx_k_dict_2[] = "_dict"; -static const char __pyx_k_enable[] = "enable"; -static const char __pyx_k_encode[] = "encode"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_module[] = "__module__"; -static const char __pyx_k_name_2[] = "__name__"; -static const char __pyx_k_pickle[] = "pickle"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_remove[] = "remove"; -static const char __pyx_k_update[] = "update"; -static const char __pyx_k_values[] = "values"; -static const char __pyx_k_IntEnum[] = "IntEnum"; -static const char __pyx_k_IntFlag[] = "IntFlag"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_get_int[] = "get_int"; -static const char __pyx_k_members[] = "__members__"; -static const char __pyx_k_parents[] = "parents"; -static const char __pyx_k_prepare[] = "__prepare__"; -static const char __pyx_k_put_int[] = "put_int"; -static const char __pyx_k_tx_type[] = "tx_type"; -static const char __pyx_k_EnumBase[] = "EnumBase"; -static const char __pyx_k_EnumType[] = "EnumType"; -static const char __pyx_k_all_keys[] = "all_keys"; -static const char __pyx_k_encoding[] = "encoding"; -static const char __pyx_k_get_bool[] = "get_bool"; -static const char __pyx_k_getstate[] = "__getstate__"; -static const char __pyx_k_module_2[] = "module"; -static const char __pyx_k_put_bool[] = "put_bool"; -static const char __pyx_k_pyx_type[] = "__pyx_type"; -static const char __pyx_k_qualname[] = "__qualname__"; -static const char __pyx_k_set_name[] = "__set_name__"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_check_key[] = "check_key"; -static const char __pyx_k_clear_all[] = "clear_all"; -static const char __pyx_k_dat_bytes[] = "dat_bytes"; -static const char __pyx_k_get_float[] = "get_float"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_key_bytes[] = "key_bytes"; -static const char __pyx_k_metaclass[] = "__metaclass__"; -static const char __pyx_k_put_float[] = "put_float"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_PERSISTENT[] = "PERSISTENT"; -static const char __pyx_k_Params_get[] = "Params.get"; -static const char __pyx_k_Params_put[] = "Params.put"; -static const char __pyx_k_ValueError[] = "ValueError"; -static const char __pyx_k_pyx_result[] = "__pyx_result"; -static const char __pyx_k_MemoryError[] = "MemoryError"; -static const char __pyx_k_OrderedDict[] = "OrderedDict"; -static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_collections[] = "collections"; -static const char __pyx_k_mro_entries[] = "__mro_entries__"; -static const char __pyx_k_ParamKeyType[] = "ParamKeyType"; -static const char __pyx_k_Pyx_EnumBase[] = "__Pyx_EnumBase"; -static const char __pyx_k_Pyx_FlagBase[] = "__Pyx_FlagBase"; -static const char __pyx_k_ensure_bytes[] = "ensure_bytes"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_member_names[] = "_member_names_"; -static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = ""; -static const char __pyx_k_use_setstate[] = "use_setstate"; -static const char __pyx_k_Params_remove[] = "Params.remove"; -static const char __pyx_k_class_getitem[] = "__class_getitem__"; -static const char __pyx_k_init_subclass[] = "__init_subclass__"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_Params_get_int[] = "Params.get_int"; -static const char __pyx_k_Params_put_int[] = "Params.put_int"; -static const char __pyx_k_UnknownKeyName[] = "UnknownKeyName"; -static const char __pyx_k_get_param_path[] = "get_param_path"; -static const char __pyx_k_Params_all_keys[] = "Params.all_keys"; -static const char __pyx_k_Params_get_bool[] = "Params.get_bool"; -static const char __pyx_k_Params_put_bool[] = "Params.put_bool"; -static const char __pyx_k_put_nonblocking[] = "put_nonblocking"; -static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; -static const char __pyx_k_DEVELOPMENT_ONLY[] = "DEVELOPMENT_ONLY"; -static const char __pyx_k_Params_check_key[] = "Params.check_key"; -static const char __pyx_k_Params_clear_all[] = "Params.clear_all"; -static const char __pyx_k_Params_get_float[] = "Params.get_float"; -static const char __pyx_k_Params_put_float[] = "Params.put_float"; -static const char __pyx_k_KeyboardInterrupt[] = "KeyboardInterrupt"; -static const char __pyx_k_common_params_pyx[] = "common.params_pyx"; -static const char __pyx_k_Pyx_EnumBase___new[] = "__Pyx_EnumBase.__new__"; -static const char __pyx_k_Pyx_EnumBase___str[] = "__Pyx_EnumBase.__str__"; -static const char __pyx_k_Pyx_FlagBase___new[] = "__Pyx_FlagBase.__new__"; -static const char __pyx_k_Pyx_FlagBase___str[] = "__Pyx_FlagBase.__str__"; -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_Pyx_EnumBase___repr[] = "__Pyx_EnumBase.__repr__"; -static const char __pyx_k_Pyx_FlagBase___repr[] = "__Pyx_FlagBase.__repr__"; -static const char __pyx_k_put_int_nonblocking[] = "put_int_nonblocking"; -static const char __pyx_k_Unknown_enum_value_s[] = "Unknown enum value: '%s'"; -static const char __pyx_k_put_bool_nonblocking[] = "put_bool_nonblocking"; -static const char __pyx_k_Params_get_param_path[] = "Params.get_param_path"; -static const char __pyx_k_common_params_pyx_pyx[] = "common/params_pyx.pyx"; -static const char __pyx_k_put_float_nonblocking[] = "put_float_nonblocking"; -static const char __pyx_k_CLEAR_ON_MANAGER_START[] = "CLEAR_ON_MANAGER_START"; -static const char __pyx_k_Params___reduce_cython[] = "Params.__reduce_cython__"; -static const char __pyx_k_Params_put_nonblocking[] = "Params.put_nonblocking"; -static const char __pyx_k_Params___setstate_cython[] = "Params.__setstate_cython__"; -static const char __pyx_k_CLEAR_ON_ONROAD_TRANSITION[] = "CLEAR_ON_ONROAD_TRANSITION"; -static const char __pyx_k_Params_put_int_nonblocking[] = "Params.put_int_nonblocking"; -static const char __pyx_k_CLEAR_ON_OFFROAD_TRANSITION[] = "CLEAR_ON_OFFROAD_TRANSITION"; -static const char __pyx_k_Params_put_bool_nonblocking[] = "Params.put_bool_nonblocking"; -static const char __pyx_k_pyx_unpickle___Pyx_EnumMeta[] = "__pyx_unpickle___Pyx_EnumMeta"; -static const char __pyx_k_Params_put_float_nonblocking[] = "Params.put_float_nonblocking"; -static const char __pyx_k_Pyx_EnumMeta___reduce_cython[] = "__Pyx_EnumMeta.__reduce_cython__"; -static const char __pyx_k_Pyx_EnumMeta___setstate_cython[] = "__Pyx_EnumMeta.__setstate_cython__"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())"; -static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -/* #### Code section: decls ### */ -static int __pyx_pf_8EnumBase_14__Pyx_EnumMeta___init__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_cls, PyObject *__pyx_v_name, PyObject *__pyx_v_parents, PyObject *__pyx_v_dct); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_2__iter__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_cls); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_4__getitem__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_cls, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_6__reduce_cython__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_8__setstate_cython__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumBase___new__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_cls, PyObject *__pyx_v_value, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumBase_2__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumBase_4__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_FlagBase___new__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_cls, PyObject *__pyx_v_value, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_FlagBase_2__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_8EnumBase_14__Pyx_FlagBase_4__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_8EnumBase___pyx_unpickle___Pyx_EnumMeta(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_ensure_bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_v); /* proto */ -static int __pyx_pf_6common_10params_pyx_6Params___cinit__(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_d); /* proto */ -static void __pyx_pf_6common_10params_pyx_6Params_2__dealloc__(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_4clear_all(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_tx_type); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_6check_key(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_8get(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block, PyObject *__pyx_v_encoding); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_10get_bool(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_12get_int(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_14get_float(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_16put(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_dat); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_18put_bool(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_val); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_20put_int(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_v_val); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_22put_float(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, float __pyx_v_val); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_24put_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_dat); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_26put_bool_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_val); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_28put_int_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_v_val); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_30put_float_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, float __pyx_v_val); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_32remove(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_34get_param_path(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_36all_keys(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_38__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_10params_pyx_6Params_40__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_tp_new_6common_10params_pyx_Params(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_get = {0, 0, 0, 0, 0}; -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -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 - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type_6common_10params_pyx_Params; - PyObject *__Pyx_EnumMeta; - #endif - PyTypeObject *__pyx_ptype_6common_10params_pyx_Params; - PyTypeObject *__pyx_ptype___Pyx_EnumMeta; - PyObject *__pyx_kp_s_; - PyObject *__pyx_kp_u_; - PyObject *__pyx_n_s_ALL; - PyObject *__pyx_n_s_CLEAR_ON_MANAGER_START; - PyObject *__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION; - PyObject *__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION; - PyObject *__pyx_n_s_DEVELOPMENT_ONLY; - PyObject *__pyx_n_s_EnumBase; - PyObject *__pyx_n_s_EnumType; - PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; - PyObject *__pyx_n_s_IntEnum; - PyObject *__pyx_n_s_IntFlag; - PyObject *__pyx_n_s_KeyboardInterrupt; - PyObject *__pyx_n_s_MemoryError; - PyObject *__pyx_n_s_OrderedDict; - PyObject *__pyx_n_s_PERSISTENT; - PyObject *__pyx_n_s_ParamKeyType; - PyObject *__pyx_n_s_Params; - PyObject *__pyx_n_s_Params___reduce_cython; - PyObject *__pyx_n_s_Params___setstate_cython; - PyObject *__pyx_n_s_Params_all_keys; - PyObject *__pyx_n_s_Params_check_key; - PyObject *__pyx_n_s_Params_clear_all; - PyObject *__pyx_n_s_Params_get; - PyObject *__pyx_n_s_Params_get_bool; - PyObject *__pyx_n_s_Params_get_float; - PyObject *__pyx_n_s_Params_get_int; - PyObject *__pyx_n_s_Params_get_param_path; - PyObject *__pyx_n_s_Params_put; - PyObject *__pyx_n_s_Params_put_bool; - PyObject *__pyx_n_s_Params_put_bool_nonblocking; - PyObject *__pyx_n_s_Params_put_float; - PyObject *__pyx_n_s_Params_put_float_nonblocking; - PyObject *__pyx_n_s_Params_put_int; - PyObject *__pyx_n_s_Params_put_int_nonblocking; - PyObject *__pyx_n_s_Params_put_nonblocking; - PyObject *__pyx_n_s_Params_remove; - PyObject *__pyx_n_s_PickleError; - PyObject *__pyx_n_s_Pyx_EnumBase; - PyObject *__pyx_n_s_Pyx_EnumBase___new; - PyObject *__pyx_n_s_Pyx_EnumBase___repr; - PyObject *__pyx_n_s_Pyx_EnumBase___str; - PyObject *__pyx_n_s_Pyx_EnumMeta___reduce_cython; - PyObject *__pyx_n_s_Pyx_EnumMeta___setstate_cython; - PyObject *__pyx_n_s_Pyx_FlagBase; - PyObject *__pyx_n_s_Pyx_FlagBase___new; - PyObject *__pyx_n_s_Pyx_FlagBase___repr; - PyObject *__pyx_n_s_Pyx_FlagBase___str; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_n_s_UnknownKeyName; - PyObject *__pyx_kp_s_Unknown_enum_value_s; - PyObject *__pyx_n_s_ValueError; - PyObject *__pyx_kp_u__3; - PyObject *__pyx_n_s__52; - PyObject *__pyx_n_s_all_keys; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_block; - PyObject *__pyx_n_s_check_key; - PyObject *__pyx_n_s_class; - PyObject *__pyx_n_s_class_getitem; - PyObject *__pyx_n_s_clear_all; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_cls; - PyObject *__pyx_n_s_collections; - PyObject *__pyx_kp_s_common_params_pyx; - PyObject *__pyx_kp_s_common_params_pyx_pyx; - PyObject *__pyx_n_s_d; - PyObject *__pyx_n_s_dat; - PyObject *__pyx_n_s_dat_bytes; - PyObject *__pyx_n_s_dct; - PyObject *__pyx_n_s_decode; - PyObject *__pyx_n_s_dict; - PyObject *__pyx_n_s_dict_2; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_n_s_doc; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_n_s_encode; - PyObject *__pyx_n_s_encoding; - PyObject *__pyx_n_s_ensure_bytes; - PyObject *__pyx_n_s_enum; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_get; - PyObject *__pyx_n_s_get_bool; - PyObject *__pyx_n_s_get_float; - PyObject *__pyx_n_s_get_int; - PyObject *__pyx_n_s_get_param_path; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_init; - PyObject *__pyx_n_s_init_subclass; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_k; - PyObject *__pyx_n_s_key; - PyObject *__pyx_n_s_key_bytes; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_member_names; - PyObject *__pyx_n_s_members; - PyObject *__pyx_n_s_metaclass; - PyObject *__pyx_n_s_module; - PyObject *__pyx_n_s_module_2; - PyObject *__pyx_n_s_mro_entries; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_name_2; - PyObject *__pyx_n_s_new; - PyObject *__pyx_kp_s_no_default___reduce___due_to_non; - PyObject *__pyx_n_s_parents; - PyObject *__pyx_n_s_pickle; - PyObject *__pyx_n_s_prepare; - PyObject *__pyx_n_s_put; - PyObject *__pyx_n_s_put_bool; - PyObject *__pyx_n_s_put_bool_nonblocking; - PyObject *__pyx_n_s_put_float; - PyObject *__pyx_n_s_put_float_nonblocking; - PyObject *__pyx_n_s_put_int; - PyObject *__pyx_n_s_put_int_nonblocking; - PyObject *__pyx_n_s_put_nonblocking; - PyObject *__pyx_n_s_pyx_PickleError; - PyObject *__pyx_n_s_pyx_checksum; - PyObject *__pyx_n_s_pyx_result; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_pyx_type; - PyObject *__pyx_n_s_pyx_unpickle___Pyx_EnumMeta; - PyObject *__pyx_n_s_qualname; - PyObject *__pyx_n_s_r; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_remove; - PyObject *__pyx_n_s_repr; - PyObject *__pyx_n_s_res; - PyObject *__pyx_kp_s_s_s; - PyObject *__pyx_kp_s_s_s_d; - PyObject *__pyx_n_s_self; - PyObject *__pyx_n_s_set_name; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_n_s_state; - PyObject *__pyx_n_s_str; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_super; - PyObject *__pyx_n_s_test; - PyObject *__pyx_n_s_tx_type; - PyObject *__pyx_n_s_update; - PyObject *__pyx_n_s_use_setstate; - PyObject *__pyx_n_s_v; - PyObject *__pyx_n_s_val; - PyObject *__pyx_n_s_value; - PyObject *__pyx_n_s_values; - PyObject *__pyx_int_222419149; - PyObject *__pyx_int_228825662; - PyObject *__pyx_int_238750788; - PyObject *__pyx_k__4; - PyObject *__pyx_tuple__2; - PyObject *__pyx_tuple__5; - PyObject *__pyx_tuple__7; - PyObject *__pyx_tuple__9; - PyObject *__pyx_tuple__11; - PyObject *__pyx_tuple__12; - PyObject *__pyx_tuple__18; - PyObject *__pyx_tuple__20; - PyObject *__pyx_tuple__22; - PyObject *__pyx_tuple__24; - PyObject *__pyx_tuple__26; - PyObject *__pyx_tuple__28; - PyObject *__pyx_tuple__29; - PyObject *__pyx_tuple__31; - PyObject *__pyx_tuple__34; - PyObject *__pyx_tuple__36; - PyObject *__pyx_tuple__44; - PyObject *__pyx_tuple__46; - PyObject *__pyx_tuple__48; - PyObject *__pyx_codeobj__6; - PyObject *__pyx_codeobj__8; - PyObject *__pyx_codeobj__10; - PyObject *__pyx_codeobj__13; - PyObject *__pyx_codeobj__14; - PyObject *__pyx_codeobj__15; - PyObject *__pyx_codeobj__16; - PyObject *__pyx_codeobj__17; - PyObject *__pyx_codeobj__19; - PyObject *__pyx_codeobj__21; - PyObject *__pyx_codeobj__23; - PyObject *__pyx_codeobj__25; - PyObject *__pyx_codeobj__27; - PyObject *__pyx_codeobj__30; - PyObject *__pyx_codeobj__32; - PyObject *__pyx_codeobj__33; - PyObject *__pyx_codeobj__35; - PyObject *__pyx_codeobj__37; - PyObject *__pyx_codeobj__38; - PyObject *__pyx_codeobj__39; - PyObject *__pyx_codeobj__40; - PyObject *__pyx_codeobj__41; - PyObject *__pyx_codeobj__42; - PyObject *__pyx_codeobj__43; - PyObject *__pyx_codeobj__45; - PyObject *__pyx_codeobj__47; - PyObject *__pyx_codeobj__49; - PyObject *__pyx_codeobj__50; - PyObject *__pyx_codeobj__51; -} __pyx_mstate; - -#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(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(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 - Py_CLEAR(clear_module_state->__pyx_ptype_6common_10params_pyx_Params); - Py_CLEAR(clear_module_state->__pyx_type_6common_10params_pyx_Params); - Py_CLEAR(clear_module_state->__pyx_ptype___Pyx_EnumMeta); - Py_CLEAR(clear_module_state->__Pyx_EnumMeta); - Py_CLEAR(clear_module_state->__pyx_kp_s_); - Py_CLEAR(clear_module_state->__pyx_kp_u_); - Py_CLEAR(clear_module_state->__pyx_n_s_ALL); - Py_CLEAR(clear_module_state->__pyx_n_s_CLEAR_ON_MANAGER_START); - Py_CLEAR(clear_module_state->__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); - Py_CLEAR(clear_module_state->__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); - Py_CLEAR(clear_module_state->__pyx_n_s_DEVELOPMENT_ONLY); - Py_CLEAR(clear_module_state->__pyx_n_s_EnumBase); - Py_CLEAR(clear_module_state->__pyx_n_s_EnumType); - Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_CLEAR(clear_module_state->__pyx_n_s_IntEnum); - Py_CLEAR(clear_module_state->__pyx_n_s_IntFlag); - Py_CLEAR(clear_module_state->__pyx_n_s_KeyboardInterrupt); - Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); - Py_CLEAR(clear_module_state->__pyx_n_s_OrderedDict); - Py_CLEAR(clear_module_state->__pyx_n_s_PERSISTENT); - Py_CLEAR(clear_module_state->__pyx_n_s_ParamKeyType); - Py_CLEAR(clear_module_state->__pyx_n_s_Params); - Py_CLEAR(clear_module_state->__pyx_n_s_Params___reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_Params___setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_all_keys); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_check_key); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_clear_all); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_get); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_get_bool); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_get_float); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_get_int); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_get_param_path); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_bool); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_bool_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_float); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_float_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_int); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_int_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_put_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_Params_remove); - Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_EnumBase); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_EnumBase___new); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_EnumBase___repr); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_EnumBase___str); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_EnumMeta___reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_EnumMeta___setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_FlagBase); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_FlagBase___new); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_FlagBase___repr); - Py_CLEAR(clear_module_state->__pyx_n_s_Pyx_FlagBase___str); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_n_s_UnknownKeyName); - Py_CLEAR(clear_module_state->__pyx_kp_s_Unknown_enum_value_s); - Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); - Py_CLEAR(clear_module_state->__pyx_kp_u__3); - Py_CLEAR(clear_module_state->__pyx_n_s__52); - Py_CLEAR(clear_module_state->__pyx_n_s_all_keys); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_block); - Py_CLEAR(clear_module_state->__pyx_n_s_check_key); - Py_CLEAR(clear_module_state->__pyx_n_s_class); - Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_clear_all); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_cls); - Py_CLEAR(clear_module_state->__pyx_n_s_collections); - Py_CLEAR(clear_module_state->__pyx_kp_s_common_params_pyx); - Py_CLEAR(clear_module_state->__pyx_kp_s_common_params_pyx_pyx); - Py_CLEAR(clear_module_state->__pyx_n_s_d); - Py_CLEAR(clear_module_state->__pyx_n_s_dat); - Py_CLEAR(clear_module_state->__pyx_n_s_dat_bytes); - Py_CLEAR(clear_module_state->__pyx_n_s_dct); - Py_CLEAR(clear_module_state->__pyx_n_s_decode); - Py_CLEAR(clear_module_state->__pyx_n_s_dict); - Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_n_s_doc); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_n_s_encode); - Py_CLEAR(clear_module_state->__pyx_n_s_encoding); - Py_CLEAR(clear_module_state->__pyx_n_s_ensure_bytes); - Py_CLEAR(clear_module_state->__pyx_n_s_enum); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_get); - Py_CLEAR(clear_module_state->__pyx_n_s_get_bool); - Py_CLEAR(clear_module_state->__pyx_n_s_get_float); - Py_CLEAR(clear_module_state->__pyx_n_s_get_int); - Py_CLEAR(clear_module_state->__pyx_n_s_get_param_path); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_init); - Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_k); - Py_CLEAR(clear_module_state->__pyx_n_s_key); - Py_CLEAR(clear_module_state->__pyx_n_s_key_bytes); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_member_names); - Py_CLEAR(clear_module_state->__pyx_n_s_members); - Py_CLEAR(clear_module_state->__pyx_n_s_metaclass); - Py_CLEAR(clear_module_state->__pyx_n_s_module); - Py_CLEAR(clear_module_state->__pyx_n_s_module_2); - Py_CLEAR(clear_module_state->__pyx_n_s_mro_entries); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_name_2); - Py_CLEAR(clear_module_state->__pyx_n_s_new); - Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_CLEAR(clear_module_state->__pyx_n_s_parents); - Py_CLEAR(clear_module_state->__pyx_n_s_pickle); - Py_CLEAR(clear_module_state->__pyx_n_s_prepare); - Py_CLEAR(clear_module_state->__pyx_n_s_put); - Py_CLEAR(clear_module_state->__pyx_n_s_put_bool); - Py_CLEAR(clear_module_state->__pyx_n_s_put_bool_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_put_float); - Py_CLEAR(clear_module_state->__pyx_n_s_put_float_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_put_int); - Py_CLEAR(clear_module_state->__pyx_n_s_put_int_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_put_nonblocking); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle___Pyx_EnumMeta); - Py_CLEAR(clear_module_state->__pyx_n_s_qualname); - Py_CLEAR(clear_module_state->__pyx_n_s_r); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_remove); - Py_CLEAR(clear_module_state->__pyx_n_s_repr); - Py_CLEAR(clear_module_state->__pyx_n_s_res); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_s); - Py_CLEAR(clear_module_state->__pyx_kp_s_s_s_d); - Py_CLEAR(clear_module_state->__pyx_n_s_self); - Py_CLEAR(clear_module_state->__pyx_n_s_set_name); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_state); - Py_CLEAR(clear_module_state->__pyx_n_s_str); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_super); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_n_s_tx_type); - Py_CLEAR(clear_module_state->__pyx_n_s_update); - Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_v); - Py_CLEAR(clear_module_state->__pyx_n_s_val); - Py_CLEAR(clear_module_state->__pyx_n_s_value); - Py_CLEAR(clear_module_state->__pyx_n_s_values); - Py_CLEAR(clear_module_state->__pyx_int_222419149); - Py_CLEAR(clear_module_state->__pyx_int_228825662); - Py_CLEAR(clear_module_state->__pyx_int_238750788); - Py_CLEAR(clear_module_state->__pyx_k__4); - Py_CLEAR(clear_module_state->__pyx_tuple__2); - Py_CLEAR(clear_module_state->__pyx_tuple__5); - Py_CLEAR(clear_module_state->__pyx_tuple__7); - Py_CLEAR(clear_module_state->__pyx_tuple__9); - Py_CLEAR(clear_module_state->__pyx_tuple__11); - Py_CLEAR(clear_module_state->__pyx_tuple__12); - Py_CLEAR(clear_module_state->__pyx_tuple__18); - Py_CLEAR(clear_module_state->__pyx_tuple__20); - Py_CLEAR(clear_module_state->__pyx_tuple__22); - Py_CLEAR(clear_module_state->__pyx_tuple__24); - Py_CLEAR(clear_module_state->__pyx_tuple__26); - Py_CLEAR(clear_module_state->__pyx_tuple__28); - Py_CLEAR(clear_module_state->__pyx_tuple__29); - Py_CLEAR(clear_module_state->__pyx_tuple__31); - Py_CLEAR(clear_module_state->__pyx_tuple__34); - Py_CLEAR(clear_module_state->__pyx_tuple__36); - Py_CLEAR(clear_module_state->__pyx_tuple__44); - Py_CLEAR(clear_module_state->__pyx_tuple__46); - Py_CLEAR(clear_module_state->__pyx_tuple__48); - Py_CLEAR(clear_module_state->__pyx_codeobj__6); - Py_CLEAR(clear_module_state->__pyx_codeobj__8); - Py_CLEAR(clear_module_state->__pyx_codeobj__10); - Py_CLEAR(clear_module_state->__pyx_codeobj__13); - Py_CLEAR(clear_module_state->__pyx_codeobj__14); - Py_CLEAR(clear_module_state->__pyx_codeobj__15); - Py_CLEAR(clear_module_state->__pyx_codeobj__16); - Py_CLEAR(clear_module_state->__pyx_codeobj__17); - Py_CLEAR(clear_module_state->__pyx_codeobj__19); - Py_CLEAR(clear_module_state->__pyx_codeobj__21); - Py_CLEAR(clear_module_state->__pyx_codeobj__23); - Py_CLEAR(clear_module_state->__pyx_codeobj__25); - Py_CLEAR(clear_module_state->__pyx_codeobj__27); - Py_CLEAR(clear_module_state->__pyx_codeobj__30); - Py_CLEAR(clear_module_state->__pyx_codeobj__32); - Py_CLEAR(clear_module_state->__pyx_codeobj__33); - Py_CLEAR(clear_module_state->__pyx_codeobj__35); - Py_CLEAR(clear_module_state->__pyx_codeobj__37); - Py_CLEAR(clear_module_state->__pyx_codeobj__38); - Py_CLEAR(clear_module_state->__pyx_codeobj__39); - Py_CLEAR(clear_module_state->__pyx_codeobj__40); - Py_CLEAR(clear_module_state->__pyx_codeobj__41); - Py_CLEAR(clear_module_state->__pyx_codeobj__42); - Py_CLEAR(clear_module_state->__pyx_codeobj__43); - Py_CLEAR(clear_module_state->__pyx_codeobj__45); - Py_CLEAR(clear_module_state->__pyx_codeobj__47); - Py_CLEAR(clear_module_state->__pyx_codeobj__49); - Py_CLEAR(clear_module_state->__pyx_codeobj__50); - Py_CLEAR(clear_module_state->__pyx_codeobj__51); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(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); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(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_6common_10params_pyx_Params); - Py_VISIT(traverse_module_state->__pyx_type_6common_10params_pyx_Params); - Py_VISIT(traverse_module_state->__pyx_ptype___Pyx_EnumMeta); - Py_VISIT(traverse_module_state->__Pyx_EnumMeta); - Py_VISIT(traverse_module_state->__pyx_kp_s_); - Py_VISIT(traverse_module_state->__pyx_kp_u_); - Py_VISIT(traverse_module_state->__pyx_n_s_ALL); - Py_VISIT(traverse_module_state->__pyx_n_s_CLEAR_ON_MANAGER_START); - Py_VISIT(traverse_module_state->__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); - Py_VISIT(traverse_module_state->__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); - Py_VISIT(traverse_module_state->__pyx_n_s_DEVELOPMENT_ONLY); - Py_VISIT(traverse_module_state->__pyx_n_s_EnumBase); - Py_VISIT(traverse_module_state->__pyx_n_s_EnumType); - Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_VISIT(traverse_module_state->__pyx_n_s_IntEnum); - Py_VISIT(traverse_module_state->__pyx_n_s_IntFlag); - Py_VISIT(traverse_module_state->__pyx_n_s_KeyboardInterrupt); - Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); - Py_VISIT(traverse_module_state->__pyx_n_s_OrderedDict); - Py_VISIT(traverse_module_state->__pyx_n_s_PERSISTENT); - Py_VISIT(traverse_module_state->__pyx_n_s_ParamKeyType); - Py_VISIT(traverse_module_state->__pyx_n_s_Params); - Py_VISIT(traverse_module_state->__pyx_n_s_Params___reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_Params___setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_all_keys); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_check_key); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_clear_all); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_get); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_get_bool); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_get_float); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_get_int); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_get_param_path); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_bool); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_bool_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_float); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_float_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_int); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_int_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_put_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_Params_remove); - Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_EnumBase); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_EnumBase___new); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_EnumBase___repr); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_EnumBase___str); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_EnumMeta___reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_EnumMeta___setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_FlagBase); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_FlagBase___new); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_FlagBase___repr); - Py_VISIT(traverse_module_state->__pyx_n_s_Pyx_FlagBase___str); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_n_s_UnknownKeyName); - Py_VISIT(traverse_module_state->__pyx_kp_s_Unknown_enum_value_s); - Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); - Py_VISIT(traverse_module_state->__pyx_kp_u__3); - Py_VISIT(traverse_module_state->__pyx_n_s__52); - Py_VISIT(traverse_module_state->__pyx_n_s_all_keys); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_block); - Py_VISIT(traverse_module_state->__pyx_n_s_check_key); - Py_VISIT(traverse_module_state->__pyx_n_s_class); - Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_clear_all); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_cls); - Py_VISIT(traverse_module_state->__pyx_n_s_collections); - Py_VISIT(traverse_module_state->__pyx_kp_s_common_params_pyx); - Py_VISIT(traverse_module_state->__pyx_kp_s_common_params_pyx_pyx); - Py_VISIT(traverse_module_state->__pyx_n_s_d); - Py_VISIT(traverse_module_state->__pyx_n_s_dat); - Py_VISIT(traverse_module_state->__pyx_n_s_dat_bytes); - Py_VISIT(traverse_module_state->__pyx_n_s_dct); - Py_VISIT(traverse_module_state->__pyx_n_s_decode); - Py_VISIT(traverse_module_state->__pyx_n_s_dict); - Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_n_s_doc); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_n_s_encode); - Py_VISIT(traverse_module_state->__pyx_n_s_encoding); - Py_VISIT(traverse_module_state->__pyx_n_s_ensure_bytes); - Py_VISIT(traverse_module_state->__pyx_n_s_enum); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_get); - Py_VISIT(traverse_module_state->__pyx_n_s_get_bool); - Py_VISIT(traverse_module_state->__pyx_n_s_get_float); - Py_VISIT(traverse_module_state->__pyx_n_s_get_int); - Py_VISIT(traverse_module_state->__pyx_n_s_get_param_path); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_init); - Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_k); - Py_VISIT(traverse_module_state->__pyx_n_s_key); - Py_VISIT(traverse_module_state->__pyx_n_s_key_bytes); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_member_names); - Py_VISIT(traverse_module_state->__pyx_n_s_members); - Py_VISIT(traverse_module_state->__pyx_n_s_metaclass); - Py_VISIT(traverse_module_state->__pyx_n_s_module); - Py_VISIT(traverse_module_state->__pyx_n_s_module_2); - Py_VISIT(traverse_module_state->__pyx_n_s_mro_entries); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_name_2); - Py_VISIT(traverse_module_state->__pyx_n_s_new); - Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_VISIT(traverse_module_state->__pyx_n_s_parents); - Py_VISIT(traverse_module_state->__pyx_n_s_pickle); - Py_VISIT(traverse_module_state->__pyx_n_s_prepare); - Py_VISIT(traverse_module_state->__pyx_n_s_put); - Py_VISIT(traverse_module_state->__pyx_n_s_put_bool); - Py_VISIT(traverse_module_state->__pyx_n_s_put_bool_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_put_float); - Py_VISIT(traverse_module_state->__pyx_n_s_put_float_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_put_int); - Py_VISIT(traverse_module_state->__pyx_n_s_put_int_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_put_nonblocking); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle___Pyx_EnumMeta); - Py_VISIT(traverse_module_state->__pyx_n_s_qualname); - Py_VISIT(traverse_module_state->__pyx_n_s_r); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_remove); - Py_VISIT(traverse_module_state->__pyx_n_s_repr); - Py_VISIT(traverse_module_state->__pyx_n_s_res); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_s); - Py_VISIT(traverse_module_state->__pyx_kp_s_s_s_d); - Py_VISIT(traverse_module_state->__pyx_n_s_self); - Py_VISIT(traverse_module_state->__pyx_n_s_set_name); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_state); - Py_VISIT(traverse_module_state->__pyx_n_s_str); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_super); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_n_s_tx_type); - Py_VISIT(traverse_module_state->__pyx_n_s_update); - Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_v); - Py_VISIT(traverse_module_state->__pyx_n_s_val); - Py_VISIT(traverse_module_state->__pyx_n_s_value); - Py_VISIT(traverse_module_state->__pyx_n_s_values); - Py_VISIT(traverse_module_state->__pyx_int_222419149); - Py_VISIT(traverse_module_state->__pyx_int_228825662); - Py_VISIT(traverse_module_state->__pyx_int_238750788); - Py_VISIT(traverse_module_state->__pyx_k__4); - Py_VISIT(traverse_module_state->__pyx_tuple__2); - Py_VISIT(traverse_module_state->__pyx_tuple__5); - Py_VISIT(traverse_module_state->__pyx_tuple__7); - Py_VISIT(traverse_module_state->__pyx_tuple__9); - Py_VISIT(traverse_module_state->__pyx_tuple__11); - Py_VISIT(traverse_module_state->__pyx_tuple__12); - Py_VISIT(traverse_module_state->__pyx_tuple__18); - Py_VISIT(traverse_module_state->__pyx_tuple__20); - Py_VISIT(traverse_module_state->__pyx_tuple__22); - Py_VISIT(traverse_module_state->__pyx_tuple__24); - Py_VISIT(traverse_module_state->__pyx_tuple__26); - Py_VISIT(traverse_module_state->__pyx_tuple__28); - Py_VISIT(traverse_module_state->__pyx_tuple__29); - Py_VISIT(traverse_module_state->__pyx_tuple__31); - Py_VISIT(traverse_module_state->__pyx_tuple__34); - Py_VISIT(traverse_module_state->__pyx_tuple__36); - Py_VISIT(traverse_module_state->__pyx_tuple__44); - Py_VISIT(traverse_module_state->__pyx_tuple__46); - Py_VISIT(traverse_module_state->__pyx_tuple__48); - Py_VISIT(traverse_module_state->__pyx_codeobj__6); - Py_VISIT(traverse_module_state->__pyx_codeobj__8); - Py_VISIT(traverse_module_state->__pyx_codeobj__10); - Py_VISIT(traverse_module_state->__pyx_codeobj__13); - Py_VISIT(traverse_module_state->__pyx_codeobj__14); - Py_VISIT(traverse_module_state->__pyx_codeobj__15); - Py_VISIT(traverse_module_state->__pyx_codeobj__16); - Py_VISIT(traverse_module_state->__pyx_codeobj__17); - Py_VISIT(traverse_module_state->__pyx_codeobj__19); - Py_VISIT(traverse_module_state->__pyx_codeobj__21); - Py_VISIT(traverse_module_state->__pyx_codeobj__23); - Py_VISIT(traverse_module_state->__pyx_codeobj__25); - Py_VISIT(traverse_module_state->__pyx_codeobj__27); - Py_VISIT(traverse_module_state->__pyx_codeobj__30); - Py_VISIT(traverse_module_state->__pyx_codeobj__32); - Py_VISIT(traverse_module_state->__pyx_codeobj__33); - Py_VISIT(traverse_module_state->__pyx_codeobj__35); - Py_VISIT(traverse_module_state->__pyx_codeobj__37); - Py_VISIT(traverse_module_state->__pyx_codeobj__38); - Py_VISIT(traverse_module_state->__pyx_codeobj__39); - Py_VISIT(traverse_module_state->__pyx_codeobj__40); - Py_VISIT(traverse_module_state->__pyx_codeobj__41); - Py_VISIT(traverse_module_state->__pyx_codeobj__42); - Py_VISIT(traverse_module_state->__pyx_codeobj__43); - Py_VISIT(traverse_module_state->__pyx_codeobj__45); - Py_VISIT(traverse_module_state->__pyx_codeobj__47); - Py_VISIT(traverse_module_state->__pyx_codeobj__49); - Py_VISIT(traverse_module_state->__pyx_codeobj__50); - Py_VISIT(traverse_module_state->__pyx_codeobj__51); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#define __pyx_type_6common_10params_pyx_Params __pyx_mstate_global->__pyx_type_6common_10params_pyx_Params -#define __Pyx_EnumMeta __pyx_mstate_global->__Pyx_EnumMeta -#endif -#define __pyx_ptype_6common_10params_pyx_Params __pyx_mstate_global->__pyx_ptype_6common_10params_pyx_Params -#define __pyx_ptype___Pyx_EnumMeta __pyx_mstate_global->__pyx_ptype___Pyx_EnumMeta -#define __pyx_kp_s_ __pyx_mstate_global->__pyx_kp_s_ -#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ -#define __pyx_n_s_ALL __pyx_mstate_global->__pyx_n_s_ALL -#define __pyx_n_s_CLEAR_ON_MANAGER_START __pyx_mstate_global->__pyx_n_s_CLEAR_ON_MANAGER_START -#define __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION __pyx_mstate_global->__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION -#define __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION __pyx_mstate_global->__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION -#define __pyx_n_s_DEVELOPMENT_ONLY __pyx_mstate_global->__pyx_n_s_DEVELOPMENT_ONLY -#define __pyx_n_s_EnumBase __pyx_mstate_global->__pyx_n_s_EnumBase -#define __pyx_n_s_EnumType __pyx_mstate_global->__pyx_n_s_EnumType -#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 -#define __pyx_n_s_IntEnum __pyx_mstate_global->__pyx_n_s_IntEnum -#define __pyx_n_s_IntFlag __pyx_mstate_global->__pyx_n_s_IntFlag -#define __pyx_n_s_KeyboardInterrupt __pyx_mstate_global->__pyx_n_s_KeyboardInterrupt -#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError -#define __pyx_n_s_OrderedDict __pyx_mstate_global->__pyx_n_s_OrderedDict -#define __pyx_n_s_PERSISTENT __pyx_mstate_global->__pyx_n_s_PERSISTENT -#define __pyx_n_s_ParamKeyType __pyx_mstate_global->__pyx_n_s_ParamKeyType -#define __pyx_n_s_Params __pyx_mstate_global->__pyx_n_s_Params -#define __pyx_n_s_Params___reduce_cython __pyx_mstate_global->__pyx_n_s_Params___reduce_cython -#define __pyx_n_s_Params___setstate_cython __pyx_mstate_global->__pyx_n_s_Params___setstate_cython -#define __pyx_n_s_Params_all_keys __pyx_mstate_global->__pyx_n_s_Params_all_keys -#define __pyx_n_s_Params_check_key __pyx_mstate_global->__pyx_n_s_Params_check_key -#define __pyx_n_s_Params_clear_all __pyx_mstate_global->__pyx_n_s_Params_clear_all -#define __pyx_n_s_Params_get __pyx_mstate_global->__pyx_n_s_Params_get -#define __pyx_n_s_Params_get_bool __pyx_mstate_global->__pyx_n_s_Params_get_bool -#define __pyx_n_s_Params_get_float __pyx_mstate_global->__pyx_n_s_Params_get_float -#define __pyx_n_s_Params_get_int __pyx_mstate_global->__pyx_n_s_Params_get_int -#define __pyx_n_s_Params_get_param_path __pyx_mstate_global->__pyx_n_s_Params_get_param_path -#define __pyx_n_s_Params_put __pyx_mstate_global->__pyx_n_s_Params_put -#define __pyx_n_s_Params_put_bool __pyx_mstate_global->__pyx_n_s_Params_put_bool -#define __pyx_n_s_Params_put_bool_nonblocking __pyx_mstate_global->__pyx_n_s_Params_put_bool_nonblocking -#define __pyx_n_s_Params_put_float __pyx_mstate_global->__pyx_n_s_Params_put_float -#define __pyx_n_s_Params_put_float_nonblocking __pyx_mstate_global->__pyx_n_s_Params_put_float_nonblocking -#define __pyx_n_s_Params_put_int __pyx_mstate_global->__pyx_n_s_Params_put_int -#define __pyx_n_s_Params_put_int_nonblocking __pyx_mstate_global->__pyx_n_s_Params_put_int_nonblocking -#define __pyx_n_s_Params_put_nonblocking __pyx_mstate_global->__pyx_n_s_Params_put_nonblocking -#define __pyx_n_s_Params_remove __pyx_mstate_global->__pyx_n_s_Params_remove -#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError -#define __pyx_n_s_Pyx_EnumBase __pyx_mstate_global->__pyx_n_s_Pyx_EnumBase -#define __pyx_n_s_Pyx_EnumBase___new __pyx_mstate_global->__pyx_n_s_Pyx_EnumBase___new -#define __pyx_n_s_Pyx_EnumBase___repr __pyx_mstate_global->__pyx_n_s_Pyx_EnumBase___repr -#define __pyx_n_s_Pyx_EnumBase___str __pyx_mstate_global->__pyx_n_s_Pyx_EnumBase___str -#define __pyx_n_s_Pyx_EnumMeta___reduce_cython __pyx_mstate_global->__pyx_n_s_Pyx_EnumMeta___reduce_cython -#define __pyx_n_s_Pyx_EnumMeta___setstate_cython __pyx_mstate_global->__pyx_n_s_Pyx_EnumMeta___setstate_cython -#define __pyx_n_s_Pyx_FlagBase __pyx_mstate_global->__pyx_n_s_Pyx_FlagBase -#define __pyx_n_s_Pyx_FlagBase___new __pyx_mstate_global->__pyx_n_s_Pyx_FlagBase___new -#define __pyx_n_s_Pyx_FlagBase___repr __pyx_mstate_global->__pyx_n_s_Pyx_FlagBase___repr -#define __pyx_n_s_Pyx_FlagBase___str __pyx_mstate_global->__pyx_n_s_Pyx_FlagBase___str -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_n_s_UnknownKeyName __pyx_mstate_global->__pyx_n_s_UnknownKeyName -#define __pyx_kp_s_Unknown_enum_value_s __pyx_mstate_global->__pyx_kp_s_Unknown_enum_value_s -#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError -#define __pyx_kp_u__3 __pyx_mstate_global->__pyx_kp_u__3 -#define __pyx_n_s__52 __pyx_mstate_global->__pyx_n_s__52 -#define __pyx_n_s_all_keys __pyx_mstate_global->__pyx_n_s_all_keys -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_block __pyx_mstate_global->__pyx_n_s_block -#define __pyx_n_s_check_key __pyx_mstate_global->__pyx_n_s_check_key -#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class -#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem -#define __pyx_n_s_clear_all __pyx_mstate_global->__pyx_n_s_clear_all -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_cls __pyx_mstate_global->__pyx_n_s_cls -#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections -#define __pyx_kp_s_common_params_pyx __pyx_mstate_global->__pyx_kp_s_common_params_pyx -#define __pyx_kp_s_common_params_pyx_pyx __pyx_mstate_global->__pyx_kp_s_common_params_pyx_pyx -#define __pyx_n_s_d __pyx_mstate_global->__pyx_n_s_d -#define __pyx_n_s_dat __pyx_mstate_global->__pyx_n_s_dat -#define __pyx_n_s_dat_bytes __pyx_mstate_global->__pyx_n_s_dat_bytes -#define __pyx_n_s_dct __pyx_mstate_global->__pyx_n_s_dct -#define __pyx_n_s_decode __pyx_mstate_global->__pyx_n_s_decode -#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict -#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_n_s_doc __pyx_mstate_global->__pyx_n_s_doc -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode -#define __pyx_n_s_encoding __pyx_mstate_global->__pyx_n_s_encoding -#define __pyx_n_s_ensure_bytes __pyx_mstate_global->__pyx_n_s_ensure_bytes -#define __pyx_n_s_enum __pyx_mstate_global->__pyx_n_s_enum -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get -#define __pyx_n_s_get_bool __pyx_mstate_global->__pyx_n_s_get_bool -#define __pyx_n_s_get_float __pyx_mstate_global->__pyx_n_s_get_float -#define __pyx_n_s_get_int __pyx_mstate_global->__pyx_n_s_get_int -#define __pyx_n_s_get_param_path __pyx_mstate_global->__pyx_n_s_get_param_path -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init -#define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_k __pyx_mstate_global->__pyx_n_s_k -#define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key -#define __pyx_n_s_key_bytes __pyx_mstate_global->__pyx_n_s_key_bytes -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_member_names __pyx_mstate_global->__pyx_n_s_member_names -#define __pyx_n_s_members __pyx_mstate_global->__pyx_n_s_members -#define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass -#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module -#define __pyx_n_s_module_2 __pyx_mstate_global->__pyx_n_s_module_2 -#define __pyx_n_s_mro_entries __pyx_mstate_global->__pyx_n_s_mro_entries -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 -#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new -#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non -#define __pyx_n_s_parents __pyx_mstate_global->__pyx_n_s_parents -#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle -#define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare -#define __pyx_n_s_put __pyx_mstate_global->__pyx_n_s_put -#define __pyx_n_s_put_bool __pyx_mstate_global->__pyx_n_s_put_bool -#define __pyx_n_s_put_bool_nonblocking __pyx_mstate_global->__pyx_n_s_put_bool_nonblocking -#define __pyx_n_s_put_float __pyx_mstate_global->__pyx_n_s_put_float -#define __pyx_n_s_put_float_nonblocking __pyx_mstate_global->__pyx_n_s_put_float_nonblocking -#define __pyx_n_s_put_int __pyx_mstate_global->__pyx_n_s_put_int -#define __pyx_n_s_put_int_nonblocking __pyx_mstate_global->__pyx_n_s_put_int_nonblocking -#define __pyx_n_s_put_nonblocking __pyx_mstate_global->__pyx_n_s_put_nonblocking -#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError -#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum -#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type -#define __pyx_n_s_pyx_unpickle___Pyx_EnumMeta __pyx_mstate_global->__pyx_n_s_pyx_unpickle___Pyx_EnumMeta -#define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname -#define __pyx_n_s_r __pyx_mstate_global->__pyx_n_s_r -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_remove __pyx_mstate_global->__pyx_n_s_remove -#define __pyx_n_s_repr __pyx_mstate_global->__pyx_n_s_repr -#define __pyx_n_s_res __pyx_mstate_global->__pyx_n_s_res -#define __pyx_kp_s_s_s __pyx_mstate_global->__pyx_kp_s_s_s -#define __pyx_kp_s_s_s_d __pyx_mstate_global->__pyx_kp_s_s_s_d -#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self -#define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state -#define __pyx_n_s_str __pyx_mstate_global->__pyx_n_s_str -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_n_s_tx_type __pyx_mstate_global->__pyx_n_s_tx_type -#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update -#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate -#define __pyx_n_s_v __pyx_mstate_global->__pyx_n_s_v -#define __pyx_n_s_val __pyx_mstate_global->__pyx_n_s_val -#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value -#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values -#define __pyx_int_222419149 __pyx_mstate_global->__pyx_int_222419149 -#define __pyx_int_228825662 __pyx_mstate_global->__pyx_int_228825662 -#define __pyx_int_238750788 __pyx_mstate_global->__pyx_int_238750788 -#define __pyx_k__4 __pyx_mstate_global->__pyx_k__4 -#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 -#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 -#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 -#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 -#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 -#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 -#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 -#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 -#define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22 -#define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24 -#define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26 -#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 -#define __pyx_tuple__29 __pyx_mstate_global->__pyx_tuple__29 -#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31 -#define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 -#define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 -#define __pyx_tuple__44 __pyx_mstate_global->__pyx_tuple__44 -#define __pyx_tuple__46 __pyx_mstate_global->__pyx_tuple__46 -#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48 -#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 -#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8 -#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10 -#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 -#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 -#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 -#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16 -#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 -#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 -#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 -#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 -#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 -#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 -#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 -#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32 -#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 -#define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 -#define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 -#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38 -#define __pyx_codeobj__39 __pyx_mstate_global->__pyx_codeobj__39 -#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40 -#define __pyx_codeobj__41 __pyx_mstate_global->__pyx_codeobj__41 -#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42 -#define __pyx_codeobj__43 __pyx_mstate_global->__pyx_codeobj__43 -#define __pyx_codeobj__45 __pyx_mstate_global->__pyx_codeobj__45 -#define __pyx_codeobj__47 __pyx_mstate_global->__pyx_codeobj__47 -#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49 -#define __pyx_codeobj__50 __pyx_mstate_global->__pyx_codeobj__50 -#define __pyx_codeobj__51 __pyx_mstate_global->__pyx_codeobj__51 -/* #### Code section: module_code ### */ - -/* "EnumTypeToPy":132 - * - * @cname("__Pyx_Enum_enum__space_ParamKeyType_to_py") - * cdef __Pyx_Enum_enum__space_ParamKeyType_to_py(ParamKeyType c_val): # <<<<<<<<<<<<<< - * cdef object __pyx_enum - * - */ - -static PyObject *__Pyx_Enum_enum__space_ParamKeyType_to_py(enum ParamKeyType __pyx_v_c_val) { - PyObject *__pyx_v___pyx_enum = 0; - int __pyx_v_underlying_c_val; - 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; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_Enum_enum__space_ParamKeyType_to_py", 1); - - /* "EnumTypeToPy":137 - * - * - * __pyx_enum = ParamKeyType # <<<<<<<<<<<<<< - * - * if 0: - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v___pyx_enum = __pyx_t_1; - __pyx_t_1 = 0; - - /* "EnumTypeToPy":141 - * if 0: - * pass - * elif c_val == ParamKeyType.PERSISTENT: # <<<<<<<<<<<<<< - * return __pyx_enum.PERSISTENT - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: - */ - __pyx_t_2 = (__pyx_v_c_val == PERSISTENT); - if (__pyx_t_2) { - - /* "EnumTypeToPy":142 - * pass - * elif c_val == ParamKeyType.PERSISTENT: - * return __pyx_enum.PERSISTENT # <<<<<<<<<<<<<< - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: - * return __pyx_enum.CLEAR_ON_MANAGER_START - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_n_s_PERSISTENT); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumTypeToPy":141 - * if 0: - * pass - * elif c_val == ParamKeyType.PERSISTENT: # <<<<<<<<<<<<<< - * return __pyx_enum.PERSISTENT - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: - */ - } - - /* "EnumTypeToPy":143 - * elif c_val == ParamKeyType.PERSISTENT: - * return __pyx_enum.PERSISTENT - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: # <<<<<<<<<<<<<< - * return __pyx_enum.CLEAR_ON_MANAGER_START - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: - */ - __pyx_t_2 = (__pyx_v_c_val == CLEAR_ON_MANAGER_START); - if (__pyx_t_2) { - - /* "EnumTypeToPy":144 - * return __pyx_enum.PERSISTENT - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: - * return __pyx_enum.CLEAR_ON_MANAGER_START # <<<<<<<<<<<<<< - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_n_s_CLEAR_ON_MANAGER_START); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumTypeToPy":143 - * elif c_val == ParamKeyType.PERSISTENT: - * return __pyx_enum.PERSISTENT - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: # <<<<<<<<<<<<<< - * return __pyx_enum.CLEAR_ON_MANAGER_START - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: - */ - } - - /* "EnumTypeToPy":145 - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: - * return __pyx_enum.CLEAR_ON_MANAGER_START - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: # <<<<<<<<<<<<<< - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: - */ - __pyx_t_2 = (__pyx_v_c_val == CLEAR_ON_ONROAD_TRANSITION); - if (__pyx_t_2) { - - /* "EnumTypeToPy":146 - * return __pyx_enum.CLEAR_ON_MANAGER_START - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION # <<<<<<<<<<<<<< - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumTypeToPy":145 - * elif c_val == ParamKeyType.CLEAR_ON_MANAGER_START: - * return __pyx_enum.CLEAR_ON_MANAGER_START - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: # <<<<<<<<<<<<<< - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: - */ - } - - /* "EnumTypeToPy":147 - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: # <<<<<<<<<<<<<< - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: - */ - __pyx_t_2 = (__pyx_v_c_val == CLEAR_ON_OFFROAD_TRANSITION); - if (__pyx_t_2) { - - /* "EnumTypeToPy":148 - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION # <<<<<<<<<<<<<< - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: - * return __pyx_enum.DEVELOPMENT_ONLY - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumTypeToPy":147 - * elif c_val == ParamKeyType.CLEAR_ON_ONROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_ONROAD_TRANSITION - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: # <<<<<<<<<<<<<< - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: - */ - } - - /* "EnumTypeToPy":149 - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: # <<<<<<<<<<<<<< - * return __pyx_enum.DEVELOPMENT_ONLY - * elif c_val == ParamKeyType.ALL: - */ - __pyx_t_2 = (__pyx_v_c_val == DEVELOPMENT_ONLY); - if (__pyx_t_2) { - - /* "EnumTypeToPy":150 - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: - * return __pyx_enum.DEVELOPMENT_ONLY # <<<<<<<<<<<<<< - * elif c_val == ParamKeyType.ALL: - * return __pyx_enum.ALL - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_n_s_DEVELOPMENT_ONLY); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 150, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumTypeToPy":149 - * elif c_val == ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION: - * return __pyx_enum.CLEAR_ON_OFFROAD_TRANSITION - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: # <<<<<<<<<<<<<< - * return __pyx_enum.DEVELOPMENT_ONLY - * elif c_val == ParamKeyType.ALL: - */ - } - - /* "EnumTypeToPy":151 - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: - * return __pyx_enum.DEVELOPMENT_ONLY - * elif c_val == ParamKeyType.ALL: # <<<<<<<<<<<<<< - * return __pyx_enum.ALL - * else: - */ - __pyx_t_2 = (__pyx_v_c_val == ALL); - if (__pyx_t_2) { - - /* "EnumTypeToPy":152 - * return __pyx_enum.DEVELOPMENT_ONLY - * elif c_val == ParamKeyType.ALL: - * return __pyx_enum.ALL # <<<<<<<<<<<<<< - * else: - * underlying_c_val = c_val - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v___pyx_enum, __pyx_n_s_ALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumTypeToPy":151 - * elif c_val == ParamKeyType.DEVELOPMENT_ONLY: - * return __pyx_enum.DEVELOPMENT_ONLY - * elif c_val == ParamKeyType.ALL: # <<<<<<<<<<<<<< - * return __pyx_enum.ALL - * else: - */ - } - - /* "EnumTypeToPy":154 - * return __pyx_enum.ALL - * else: - * underlying_c_val = c_val # <<<<<<<<<<<<<< - * return __pyx_enum(underlying_c_val) - * - */ - /*else*/ { - __pyx_v_underlying_c_val = ((int)__pyx_v_c_val); - - /* "EnumTypeToPy":155 - * else: - * underlying_c_val = c_val - * return __pyx_enum(underlying_c_val) # <<<<<<<<<<<<<< - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_underlying_c_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 155, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v___pyx_enum); - __pyx_t_4 = __pyx_v___pyx_enum; __pyx_t_5 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 155, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - } - - /* "EnumTypeToPy":132 - * - * @cname("__Pyx_Enum_enum__space_ParamKeyType_to_py") - * cdef __Pyx_Enum_enum__space_ParamKeyType_to_py(ParamKeyType c_val): # <<<<<<<<<<<<<< - * cdef object __pyx_enum - * - */ - - /* 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_5); - __Pyx_AddTraceback("EnumTypeToPy.__Pyx_Enum_enum__space_ParamKeyType_to_py", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_enum); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.from_py":13 - * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - */ - -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { - Py_ssize_t __pyx_v_length; - char const *__pyx_v_data; - std::string __pyx_r; - char const *__pyx_t_1; - std::string __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "string.from_py":14 - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) - */ - __pyx_v_length = 0; - - /* "string.from_py":15 - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< - * return string(data, length) - * - */ - __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) - __pyx_v_data = __pyx_t_1; - - /* "string.from_py":16 - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) # <<<<<<<<<<<<<< - * - * - */ - try { - __pyx_t_2 = std::string(__pyx_v_data, __pyx_v_length); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(1, 16, __pyx_L1_error) - } - __pyx_r = __pyx_t_2; - goto __pyx_L0; - - /* "string.from_py":13 - * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - return __pyx_r; -} - -/* "string.to_py":31 - * - * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &__pyx_v_s) { - 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("__pyx_convert_PyObject_string_to_py_std__in_string", 1); - - /* "string.to_py":32 - * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): - * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":31 - * - * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":37 - * - * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &__pyx_v_s) { - 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("__pyx_convert_PyUnicode_string_to_py_std__in_string", 1); - - /* "string.to_py":38 - * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): - * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyStr_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":37 - * - * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":43 - * - * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &__pyx_v_s) { - 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("__pyx_convert_PyStr_string_to_py_std__in_string", 1); - - /* "string.to_py":44 - * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): - * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyStr_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":43 - * - * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyStr_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":49 - * - * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &__pyx_v_s) { - 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("__pyx_convert_PyBytes_string_to_py_std__in_string", 1); - - /* "string.to_py":50 - * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): - * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":49 - * - * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":55 - * - * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) - * - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &__pyx_v_s) { - 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("__pyx_convert_PyByteArray_string_to_py_std__in_string", 1); - - /* "string.to_py":56 - * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): - * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":55 - * - * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "vector.to_py":66 - * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_string") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_string(const vector[X]& v): # <<<<<<<<<<<<<< - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() - */ - -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_string(std::vector const &__pyx_v_v) { - Py_ssize_t __pyx_v_v_size_signed; - PyObject *__pyx_v_o = NULL; - Py_ssize_t __pyx_v_i; - PyObject *__pyx_v_item = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_string", 1); - - /* "vector.to_py":67 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_string") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_string(const vector[X]& v): - * if v.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< - * raise MemoryError() - * v_size_signed = v.size() - */ - __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX)); - if (unlikely(__pyx_t_1)) { - - /* "vector.to_py":68 - * cdef object __pyx_convert_vector_to_py_std_3a__3a_string(const vector[X]& v): - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() # <<<<<<<<<<<<<< - * v_size_signed = v.size() - * - */ - PyErr_NoMemory(); __PYX_ERR(1, 68, __pyx_L1_error) - - /* "vector.to_py":67 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_string") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_string(const vector[X]& v): - * if v.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< - * raise MemoryError() - * v_size_signed = v.size() - */ - } - - /* "vector.to_py":69 - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() - * v_size_signed = v.size() # <<<<<<<<<<<<<< - * - * o = PyList_New(v_size_signed) - */ - __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size()); - - /* "vector.to_py":71 - * v_size_signed = v.size() - * - * o = PyList_New(v_size_signed) # <<<<<<<<<<<<<< - * - * cdef Py_ssize_t i - */ - __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_v_o = ((PyObject*)__pyx_t_2); - __pyx_t_2 = 0; - - /* "vector.to_py":76 - * cdef object item - * - * for i in range(v_size_signed): # <<<<<<<<<<<<<< - * item = v[i] - * Py_INCREF(item) - */ - __pyx_t_3 = __pyx_v_v_size_signed; - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "vector.to_py":77 - * - * for i in range(v_size_signed): - * item = v[i] # <<<<<<<<<<<<<< - * Py_INCREF(item) - * PyList_SET_ITEM(o, i, item) - */ - __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2); - __pyx_t_2 = 0; - - /* "vector.to_py":78 - * for i in range(v_size_signed): - * item = v[i] - * Py_INCREF(item) # <<<<<<<<<<<<<< - * PyList_SET_ITEM(o, i, item) - * - */ - Py_INCREF(__pyx_v_item); - - /* "vector.to_py":79 - * item = v[i] - * Py_INCREF(item) - * PyList_SET_ITEM(o, i, item) # <<<<<<<<<<<<<< - * - * return o - */ - PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); - } - - /* "vector.to_py":81 - * PyList_SET_ITEM(o, i, item) - * - * return o # <<<<<<<<<<<<<< - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_o); - __pyx_r = __pyx_v_o; - goto __pyx_L0; - - /* "vector.to_py":66 - * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_string") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_string(const vector[X]& v): # <<<<<<<<<<<<<< - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_o); - __Pyx_XDECREF(__pyx_v_item); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":17 - * @cython.internal - * cdef class __Pyx_EnumMeta(type): - * def __init__(cls, name, parents, dct): # <<<<<<<<<<<<<< - * type.__init__(cls, name, parents, dct) - * cls.__members__ = __Pyx_OrderedDict() - */ - -/* Python wrapper */ -static int __pyx_pw_8EnumBase_14__Pyx_EnumMeta_1__init__(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_8EnumBase_14__Pyx_EnumMeta_1__init__(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_name = 0; - PyObject *__pyx_v_parents = 0; - PyObject *__pyx_v_dct = 0; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - 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; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_parents,&__pyx_n_s_dct,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 17, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_parents)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 17, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(1, 17, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dct)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 17, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(1, 17, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 17, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - } - __pyx_v_name = values[0]; - __pyx_v_parents = values[1]; - __pyx_v_dct = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 17, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumMeta___init__(((struct __pyx_obj___Pyx_EnumMeta *)__pyx_v_cls), __pyx_v_name, __pyx_v_parents, __pyx_v_dct); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_8EnumBase_14__Pyx_EnumMeta___init__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_cls, PyObject *__pyx_v_name, PyObject *__pyx_v_parents, PyObject *__pyx_v_dct) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 1); - - /* "EnumBase":18 - * cdef class __Pyx_EnumMeta(type): - * def __init__(cls, name, parents, dct): - * type.__init__(cls, name, parents, dct) # <<<<<<<<<<<<<< - * cls.__members__ = __Pyx_OrderedDict() - * def __iter__(cls): - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyType_Type)), __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[5] = {__pyx_t_3, ((PyObject *)__pyx_v_cls), __pyx_v_name, __pyx_v_parents, __pyx_v_dct}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 4+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "EnumBase":19 - * def __init__(cls, name, parents, dct): - * type.__init__(cls, name, parents, dct) - * cls.__members__ = __Pyx_OrderedDict() # <<<<<<<<<<<<<< - * def __iter__(cls): - * return iter(cls.__members__.values()) - */ - __Pyx_INCREF(__Pyx_OrderedDict); - __pyx_t_2 = __Pyx_OrderedDict; __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_cls), __pyx_n_s_members, __pyx_t_1) < 0) __PYX_ERR(1, 19, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "EnumBase":17 - * @cython.internal - * cdef class __Pyx_EnumMeta(type): - * def __init__(cls, name, parents, dct): # <<<<<<<<<<<<<< - * type.__init__(cls, name, parents, dct) - * cls.__members__ = __Pyx_OrderedDict() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":20 - * type.__init__(cls, name, parents, dct) - * cls.__members__ = __Pyx_OrderedDict() - * def __iter__(cls): # <<<<<<<<<<<<<< - * return iter(cls.__members__.values()) - * def __getitem__(cls, name): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_3__iter__(PyObject *__pyx_v_cls); /*proto*/ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_3__iter__(PyObject *__pyx_v_cls) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumMeta_2__iter__(((struct __pyx_obj___Pyx_EnumMeta *)__pyx_v_cls)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_2__iter__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_cls) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__iter__", 1); - - /* "EnumBase":21 - * cls.__members__ = __Pyx_OrderedDict() - * def __iter__(cls): - * return iter(cls.__members__.values()) # <<<<<<<<<<<<<< - * def __getitem__(cls, name): - * return cls.__members__[name] - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cls), __pyx_n_s_members); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_values); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "EnumBase":20 - * type.__init__(cls, name, parents, dct) - * cls.__members__ = __Pyx_OrderedDict() - * def __iter__(cls): # <<<<<<<<<<<<<< - * return iter(cls.__members__.values()) - * def __getitem__(cls, name): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":22 - * def __iter__(cls): - * return iter(cls.__members__.values()) - * def __getitem__(cls, name): # <<<<<<<<<<<<<< - * return cls.__members__[name] - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_5__getitem__(PyObject *__pyx_v_cls, PyObject *__pyx_v_name); /*proto*/ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_5__getitem__(PyObject *__pyx_v_cls, PyObject *__pyx_v_name) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumMeta_4__getitem__(((struct __pyx_obj___Pyx_EnumMeta *)__pyx_v_cls), ((PyObject *)__pyx_v_name)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_4__getitem__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_cls, PyObject *__pyx_v_name) { - 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("__getitem__", 1); - - /* "EnumBase":23 - * return iter(cls.__members__.values()) - * def __getitem__(cls, name): - * return cls.__members__[name] # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cls), __pyx_n_s_members); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "EnumBase":22 - * def __iter__(cls): - * return iter(cls.__members__.values()) - * def __getitem__(cls, name): # <<<<<<<<<<<<<< - * return cls.__members__[name] - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_7__reduce_cython__(PyObject *__pyx_v_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_8EnumBase_14__Pyx_EnumMeta_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_7__reduce_cython__(PyObject *__pyx_v_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 -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumMeta_6__reduce_cython__(((struct __pyx_obj___Pyx_EnumMeta *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_6__reduce_cython__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; - 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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = () # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_v_state = __pyx_empty_tuple; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = () - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = () - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __pyx_t_2 = (__pyx_v__dict != Py_None); - if (__pyx_t_2) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); - __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = False - */ - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = () - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = False # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, None), state - */ - /*else*/ { - __pyx_v_use_setstate = 0; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = False - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, None), state - * else: - */ - if (__pyx_v_use_setstate) { - - /* "(tree fragment)":13 - * use_setstate = False - * if use_setstate: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle___Pyx_EnumMeta); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_238750788); - __Pyx_GIVEREF(__pyx_int_238750788); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = False - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, None), state - * else: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle___Pyx_EnumMeta__set_state(self, __pyx_state) - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle___Pyx_EnumMeta); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_238750788); - __Pyx_GIVEREF(__pyx_int_238750788); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle___Pyx_EnumMeta__set_state(self, __pyx_state) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_9__setstate_cython__(PyObject *__pyx_v_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_8EnumBase_14__Pyx_EnumMeta_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumMeta_9__setstate_cython__(PyObject *__pyx_v_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___pyx_state = 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("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumMeta_8__setstate_cython__(((struct __pyx_obj___Pyx_EnumMeta *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumMeta_8__setstate_cython__(struct __pyx_obj___Pyx_EnumMeta *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - 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("__setstate_cython__", 1); - - /* "(tree fragment)":17 - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle___Pyx_EnumMeta__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle___Pyx_EnumMeta__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle___Pyx_EnumMeta__set_state(self, __pyx_state) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumMeta.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":28 - * cdef object __Pyx_EnumBase - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumBase_1__new__(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_8EnumBase_14__Pyx_EnumBase_1__new__ = {"__new__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumBase_1__new__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumBase_1__new__(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_cls = 0; - PyObject *__pyx_v_value = 0; - PyObject *__pyx_v_name = 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("__new__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_cls,&__pyx_n_s_value,&__pyx_n_s_name,0}; - values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cls)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 28, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 28, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__new__", 0, 2, 3, 1); __PYX_ERR(1, 28, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 28, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__new__") < 0)) __PYX_ERR(1, 28, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_cls = values[0]; - __pyx_v_value = values[1]; - __pyx_v_name = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__new__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 28, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_EnumBase.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumBase___new__(__pyx_self, __pyx_v_cls, __pyx_v_value, __pyx_v_name); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumBase___new__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_cls, PyObject *__pyx_v_value, PyObject *__pyx_v_name) { - PyObject *__pyx_v_v = NULL; - PyObject *__pyx_v_res = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *(*__pyx_t_3)(PyObject *); - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__new__", 1); - - /* "EnumBase":29 - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): - * for v in cls: # <<<<<<<<<<<<<< - * if v == value: - * return v - */ - if (likely(PyList_CheckExact(__pyx_v_cls)) || PyTuple_CheckExact(__pyx_v_cls)) { - __pyx_t_1 = __pyx_v_cls; __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = 0; - __pyx_t_3 = NULL; - } else { - __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 29, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_3)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 29, __pyx_L1_error) - #endif - if (__pyx_t_2 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 29, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 29, __pyx_L1_error) - #endif - if (__pyx_t_2 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 29, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_3(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 29, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_4); - __pyx_t_4 = 0; - - /* "EnumBase":30 - * def __new__(cls, value, name=None): - * for v in cls: - * if v == value: # <<<<<<<<<<<<<< - * return v - * if name is None: - */ - __pyx_t_4 = PyObject_RichCompare(__pyx_v_v, __pyx_v_value, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 30, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 30, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_5) { - - /* "EnumBase":31 - * for v in cls: - * if v == value: - * return v # <<<<<<<<<<<<<< - * if name is None: - * raise ValueError("Unknown enum value: '%s'" % value) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_v); - __pyx_r = __pyx_v_v; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumBase":30 - * def __new__(cls, value, name=None): - * for v in cls: - * if v == value: # <<<<<<<<<<<<<< - * return v - * if name is None: - */ - } - - /* "EnumBase":29 - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): - * for v in cls: # <<<<<<<<<<<<<< - * if v == value: - * return v - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "EnumBase":32 - * if v == value: - * return v - * if name is None: # <<<<<<<<<<<<<< - * raise ValueError("Unknown enum value: '%s'" % value) - * res = int.__new__(cls, value) - */ - __pyx_t_5 = (__pyx_v_name == Py_None); - if (unlikely(__pyx_t_5)) { - - /* "EnumBase":33 - * return v - * if name is None: - * raise ValueError("Unknown enum value: '%s'" % value) # <<<<<<<<<<<<<< - * res = int.__new__(cls, value) - * res.name = name - */ - __pyx_t_1 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Unknown_enum_value_s, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 33, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 33, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 33, __pyx_L1_error) - - /* "EnumBase":32 - * if v == value: - * return v - * if name is None: # <<<<<<<<<<<<<< - * raise ValueError("Unknown enum value: '%s'" % value) - * res = int.__new__(cls, value) - */ - } - - /* "EnumBase":34 - * if name is None: - * raise ValueError("Unknown enum value: '%s'" % value) - * res = int.__new__(cls, value) # <<<<<<<<<<<<<< - * res.name = name - * setattr(cls, name, res) - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyInt_Type)), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_7 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_cls, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_v_res = __pyx_t_4; - __pyx_t_4 = 0; - - /* "EnumBase":35 - * raise ValueError("Unknown enum value: '%s'" % value) - * res = int.__new__(cls, value) - * res.name = name # <<<<<<<<<<<<<< - * setattr(cls, name, res) - * cls.__members__[name] = res - */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 35, __pyx_L1_error) - - /* "EnumBase":36 - * res = int.__new__(cls, value) - * res.name = name - * setattr(cls, name, res) # <<<<<<<<<<<<<< - * cls.__members__[name] = res - * return res - */ - __pyx_t_8 = PyObject_SetAttr(__pyx_v_cls, __pyx_v_name, __pyx_v_res); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 36, __pyx_L1_error) - - /* "EnumBase":37 - * res.name = name - * setattr(cls, name, res) - * cls.__members__[name] = res # <<<<<<<<<<<<<< - * return res - * def __repr__(self): - */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_cls, __pyx_n_s_members); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_v_name, __pyx_v_res) < 0))) __PYX_ERR(1, 37, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "EnumBase":38 - * setattr(cls, name, res) - * cls.__members__[name] = res - * return res # <<<<<<<<<<<<<< - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_res); - __pyx_r = __pyx_v_res; - goto __pyx_L0; - - /* "EnumBase":28 - * cdef object __Pyx_EnumBase - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumBase.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_v); - __Pyx_XDECREF(__pyx_v_res); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":39 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumBase_3__repr__(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_8EnumBase_14__Pyx_EnumBase_3__repr__ = {"__repr__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumBase_3__repr__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumBase_3__repr__(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("__repr__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 39, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__repr__") < 0)) __PYX_ERR(1, 39, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_self = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 39, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_EnumBase.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumBase_2__repr__(__pyx_self, __pyx_v_self); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumBase_2__repr__(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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 1); - - /* "EnumBase":40 - * return res - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) # <<<<<<<<<<<<<< - * def __str__(self): - * return "%s.%s" % (self.__class__.__name__, self.name) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 40, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 40, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_self)) __PYX_ERR(1, 40, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumBase":39 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumBase.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":41 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumBase_5__str__(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_8EnumBase_14__Pyx_EnumBase_5__str__ = {"__str__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumBase_5__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_EnumBase_5__str__(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("__str__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 41, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__str__") < 0)) __PYX_ERR(1, 41, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_self = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 41, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_EnumBase.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_EnumBase_4__str__(__pyx_self, __pyx_v_self); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_EnumBase_4__str__(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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 1); - - /* "EnumBase":42 - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - * return "%s.%s" % (self.__class__.__name__, self.name) # <<<<<<<<<<<<<< - * - * if PY_VERSION_HEX >= 0x03040000: - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 42, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 42, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumBase":41 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("EnumBase.__Pyx_EnumBase.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":49 - * cdef object __Pyx_FlagBase - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_FlagBase_1__new__(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_8EnumBase_14__Pyx_FlagBase_1__new__ = {"__new__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_FlagBase_1__new__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_FlagBase_1__new__(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_cls = 0; - PyObject *__pyx_v_value = 0; - PyObject *__pyx_v_name = 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("__new__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_cls,&__pyx_n_s_value,&__pyx_n_s_name,0}; - values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cls)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 49, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 49, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__new__", 0, 2, 3, 1); __PYX_ERR(1, 49, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 49, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__new__") < 0)) __PYX_ERR(1, 49, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_cls = values[0]; - __pyx_v_value = values[1]; - __pyx_v_name = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__new__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 49, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_FlagBase.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_FlagBase___new__(__pyx_self, __pyx_v_cls, __pyx_v_value, __pyx_v_name); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_FlagBase___new__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_cls, PyObject *__pyx_v_value, PyObject *__pyx_v_name) { - PyObject *__pyx_v_v = NULL; - PyObject *__pyx_v_res = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *(*__pyx_t_3)(PyObject *); - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__new__", 1); - - /* "EnumBase":50 - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): - * for v in cls: # <<<<<<<<<<<<<< - * if v == value: - * return v - */ - if (likely(PyList_CheckExact(__pyx_v_cls)) || PyTuple_CheckExact(__pyx_v_cls)) { - __pyx_t_1 = __pyx_v_cls; __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = 0; - __pyx_t_3 = NULL; - } else { - __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 50, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_3)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 50, __pyx_L1_error) - #endif - if (__pyx_t_2 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 50, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 50, __pyx_L1_error) - #endif - if (__pyx_t_2 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 50, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_3(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 50, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_4); - __pyx_t_4 = 0; - - /* "EnumBase":51 - * def __new__(cls, value, name=None): - * for v in cls: - * if v == value: # <<<<<<<<<<<<<< - * return v - * res = int.__new__(cls, value) - */ - __pyx_t_4 = PyObject_RichCompare(__pyx_v_v, __pyx_v_value, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 51, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 51, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_5) { - - /* "EnumBase":52 - * for v in cls: - * if v == value: - * return v # <<<<<<<<<<<<<< - * res = int.__new__(cls, value) - * if name is None: - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_v); - __pyx_r = __pyx_v_v; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumBase":51 - * def __new__(cls, value, name=None): - * for v in cls: - * if v == value: # <<<<<<<<<<<<<< - * return v - * res = int.__new__(cls, value) - */ - } - - /* "EnumBase":50 - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): - * for v in cls: # <<<<<<<<<<<<<< - * if v == value: - * return v - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "EnumBase":53 - * if v == value: - * return v - * res = int.__new__(cls, value) # <<<<<<<<<<<<<< - * if name is None: - * - */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyInt_Type)), __pyx_n_s_new); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_cls, __pyx_v_value}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __pyx_v_res = __pyx_t_1; - __pyx_t_1 = 0; - - /* "EnumBase":54 - * return v - * res = int.__new__(cls, value) - * if name is None: # <<<<<<<<<<<<<< - * - * res.name = "" - */ - __pyx_t_5 = (__pyx_v_name == Py_None); - if (__pyx_t_5) { - - /* "EnumBase":56 - * if name is None: - * - * res.name = "" # <<<<<<<<<<<<<< - * else: - * res.name = name - */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_name, __pyx_kp_s_) < 0) __PYX_ERR(1, 56, __pyx_L1_error) - - /* "EnumBase":54 - * return v - * res = int.__new__(cls, value) - * if name is None: # <<<<<<<<<<<<<< - * - * res.name = "" - */ - goto __pyx_L7; - } - - /* "EnumBase":58 - * res.name = "" - * else: - * res.name = name # <<<<<<<<<<<<<< - * setattr(cls, name, res) - * cls.__members__[name] = res - */ - /*else*/ { - if (__Pyx_PyObject_SetAttrStr(__pyx_v_res, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 58, __pyx_L1_error) - - /* "EnumBase":59 - * else: - * res.name = name - * setattr(cls, name, res) # <<<<<<<<<<<<<< - * cls.__members__[name] = res - * return res - */ - __pyx_t_8 = PyObject_SetAttr(__pyx_v_cls, __pyx_v_name, __pyx_v_res); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 59, __pyx_L1_error) - - /* "EnumBase":60 - * res.name = name - * setattr(cls, name, res) - * cls.__members__[name] = res # <<<<<<<<<<<<<< - * return res - * def __repr__(self): - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cls, __pyx_n_s_members); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_res) < 0))) __PYX_ERR(1, 60, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L7:; - - /* "EnumBase":61 - * setattr(cls, name, res) - * cls.__members__[name] = res - * return res # <<<<<<<<<<<<<< - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_res); - __pyx_r = __pyx_v_res; - goto __pyx_L0; - - /* "EnumBase":49 - * cdef object __Pyx_FlagBase - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("EnumBase.__Pyx_FlagBase.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_v); - __Pyx_XDECREF(__pyx_v_res); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":62 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_FlagBase_3__repr__(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_8EnumBase_14__Pyx_FlagBase_3__repr__ = {"__repr__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_FlagBase_3__repr__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_FlagBase_3__repr__(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("__repr__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 62, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__repr__") < 0)) __PYX_ERR(1, 62, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_self = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 62, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_FlagBase.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_FlagBase_2__repr__(__pyx_self, __pyx_v_self); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_FlagBase_2__repr__(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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 1); - - /* "EnumBase":63 - * return res - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) # <<<<<<<<<<<<<< - * def __str__(self): - * return "%s.%s" % (self.__class__.__name__, self.name) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 63, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_self); - __Pyx_GIVEREF(__pyx_v_self); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_self)) __PYX_ERR(1, 63, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumBase":62 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("EnumBase.__Pyx_FlagBase.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "EnumBase":64 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_14__Pyx_FlagBase_5__str__(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_8EnumBase_14__Pyx_FlagBase_5__str__ = {"__str__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_FlagBase_5__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_14__Pyx_FlagBase_5__str__(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("__str__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 64, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__str__") < 0)) __PYX_ERR(1, 64, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_self = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 64, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__Pyx_FlagBase.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase_14__Pyx_FlagBase_4__str__(__pyx_self, __pyx_v_self); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase_14__Pyx_FlagBase_4__str__(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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 1); - - /* "EnumBase":65 - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - * return "%s.%s" % (self.__class__.__name__, self.name) # <<<<<<<<<<<<<< - * - * if PY_VERSION_HEX >= 0x03060000: - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "EnumBase":64 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("EnumBase.__Pyx_FlagBase.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __pyx_unpickle___Pyx_EnumMeta(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_8EnumBase_1__pyx_unpickle___Pyx_EnumMeta(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_8EnumBase_1__pyx_unpickle___Pyx_EnumMeta = {"__pyx_unpickle___Pyx_EnumMeta", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_1__pyx_unpickle___Pyx_EnumMeta, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_8EnumBase_1__pyx_unpickle___Pyx_EnumMeta(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___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 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("__pyx_unpickle___Pyx_EnumMeta (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___Pyx_EnumMeta", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___Pyx_EnumMeta", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle___Pyx_EnumMeta") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___Pyx_EnumMeta", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("EnumBase.__pyx_unpickle___Pyx_EnumMeta", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_8EnumBase___pyx_unpickle___Pyx_EnumMeta(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_8EnumBase___pyx_unpickle___Pyx_EnumMeta(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - 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; - int __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle___Pyx_EnumMeta", 1); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - */ - __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__2, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__pyx_t_2) { - - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - * __pyx_result = __Pyx_EnumMeta.__new__(__pyx_type) - */ - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_t_1); - __pyx_v___pyx_PickleError = __pyx_t_1; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":6 - * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< - * __pyx_result = __Pyx_EnumMeta.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - */ - } - - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - * __pyx_result = __Pyx_EnumMeta.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) - */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype___Pyx_EnumMeta), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_v___pyx_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - * __pyx_result = __Pyx_EnumMeta.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) - * return __pyx_result - */ - __pyx_t_2 = (__pyx_v___pyx_state != Py_None); - if (__pyx_t_2) { - - /* "(tree fragment)":9 - * __pyx_result = __Pyx_EnumMeta.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle___Pyx_EnumMeta__set_state(((struct __pyx_obj___Pyx_EnumMeta *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - * __pyx_result = __Pyx_EnumMeta.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) - * return __pyx_result - */ - } - - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): - * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; - - /* "(tree fragment)":1 - * def __pyx_unpickle___Pyx_EnumMeta(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("EnumBase.__pyx_unpickle___Pyx_EnumMeta", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":11 - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[0]) - */ - -static PyObject *__pyx_unpickle___Pyx_EnumMeta__set_state(struct __pyx_obj___Pyx_EnumMeta *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - 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("__pyx_unpickle___Pyx_EnumMeta__set_state", 1); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): - * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[0]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 12, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_2 > 0); - if (__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error) - __pyx_t_1 = __pyx_t_3; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "(tree fragment)":13 - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): - * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 13, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_8 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): - * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[0]) - */ - } - - /* "(tree fragment)":11 - * __pyx_unpickle___Pyx_EnumMeta__set_state(<__Pyx_EnumMeta> __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle___Pyx_EnumMeta__set_state(__Pyx_EnumMeta __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[0]) - */ - - /* 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_AddTraceback("EnumBase.__pyx_unpickle___Pyx_EnumMeta__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":37 - * - * - * def ensure_bytes(v): # <<<<<<<<<<<<<< - * return v.encode() if isinstance(v, str) else v - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_1ensure_bytes(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_6common_10params_pyx_1ensure_bytes = {"ensure_bytes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_1ensure_bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_1ensure_bytes(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_v = 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("ensure_bytes (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_v,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_v)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 37, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ensure_bytes") < 0)) __PYX_ERR(0, 37, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_v = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ensure_bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 37, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.ensure_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_ensure_bytes(__pyx_self, __pyx_v_v); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_ensure_bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_v) { - 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; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ensure_bytes", 1); - - /* "common/params_pyx.pyx":38 - * - * def ensure_bytes(v): - * return v.encode() if isinstance(v, str) else v # <<<<<<<<<<<<<< - * - * class UnknownKeyName(Exception): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyUnicode_Check(__pyx_v_v); - if (__pyx_t_2) { - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - } else { - __Pyx_INCREF(__pyx_v_v); - __pyx_t_1 = __pyx_v_v; - } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":37 - * - * - * def ensure_bytes(v): # <<<<<<<<<<<<<< - * return v.encode() if isinstance(v, str) else v - * - */ - - /* 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_5); - __Pyx_AddTraceback("common.params_pyx.ensure_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":46 - * cdef c_Params* p - * - * def __cinit__(self, d=""): # <<<<<<<<<<<<<< - * cdef string path = d.encode() - * with nogil: - */ - -/* Python wrapper */ -static int __pyx_pw_6common_10params_pyx_6Params_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6common_10params_pyx_6Params_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_d = 0; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_d,0}; - values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_kp_u_)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_d); - if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 46, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_d = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 46, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params___cinit__(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_d); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_6common_10params_pyx_6Params___cinit__(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_d) { - std::string __pyx_v_path; - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - Params *__pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 1); - - /* "common/params_pyx.pyx":47 - * - * def __cinit__(self, d=""): - * cdef string path = d.encode() # <<<<<<<<<<<<<< - * with nogil: - * self.p = new c_Params(path) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_d, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_path = ((std::string)__pyx_t_5); - - /* "common/params_pyx.pyx":48 - * def __cinit__(self, d=""): - * cdef string path = d.encode() - * with nogil: # <<<<<<<<<<<<<< - * self.p = new c_Params(path) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":49 - * cdef string path = d.encode() - * with nogil: - * self.p = new c_Params(path) # <<<<<<<<<<<<<< - * - * def __dealloc__(self): - */ - try { - __pyx_t_6 = new Params(__pyx_v_path); - } catch(...) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_CppExn2PyErr(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __PYX_ERR(0, 49, __pyx_L4_error) - } - __pyx_v_self->p = __pyx_t_6; - } - - /* "common/params_pyx.pyx":48 - * def __cinit__(self, d=""): - * cdef string path = d.encode() - * with nogil: # <<<<<<<<<<<<<< - * self.p = new c_Params(path) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L4_error: { - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L1_error; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":46 - * cdef c_Params* p - * - * def __cinit__(self, d=""): # <<<<<<<<<<<<<< - * cdef string path = d.encode() - * with nogil: - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("common.params_pyx.Params.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":51 - * self.p = new c_Params(path) - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * del self.p - * - */ - -/* Python wrapper */ -static void __pyx_pw_6common_10params_pyx_6Params_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_pw_6common_10params_pyx_6Params_3__dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_pf_6common_10params_pyx_6Params_2__dealloc__(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_6common_10params_pyx_6Params_2__dealloc__(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self) { - - /* "common/params_pyx.pyx":52 - * - * def __dealloc__(self): - * del self.p # <<<<<<<<<<<<<< - * - * def clear_all(self, tx_type=ParamKeyType.ALL): - */ - delete __pyx_v_self->p; - - /* "common/params_pyx.pyx":51 - * self.p = new c_Params(path) - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * del self.p - * - */ - - /* function exit code */ -} - -/* "common/params_pyx.pyx":54 - * del self.p - * - * def clear_all(self, tx_type=ParamKeyType.ALL): # <<<<<<<<<<<<<< - * self.p.clearAll(tx_type) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_5clear_all(PyObject *__pyx_v_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_6common_10params_pyx_6Params_5clear_all = {"clear_all", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_5clear_all, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_5clear_all(PyObject *__pyx_v_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_tx_type = 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("clear_all (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_tx_type,0}; - values[0] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__4); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_tx_type); - if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "clear_all") < 0)) __PYX_ERR(0, 54, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_tx_type = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("clear_all", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 54, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.clear_all", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_4clear_all(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_tx_type); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_4clear_all(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_tx_type) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - enum ParamKeyType __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("clear_all", 1); - - /* "common/params_pyx.pyx":55 - * - * def clear_all(self, tx_type=ParamKeyType.ALL): - * self.p.clearAll(tx_type) # <<<<<<<<<<<<<< - * - * def check_key(self, key): - */ - __pyx_t_1 = ((enum ParamKeyType)__Pyx_PyInt_As_enum__ParamKeyType(__pyx_v_tx_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error) - __pyx_v_self->p->clearAll(__pyx_t_1); - - /* "common/params_pyx.pyx":54 - * del self.p - * - * def clear_all(self, tx_type=ParamKeyType.ALL): # <<<<<<<<<<<<<< - * self.p.clearAll(tx_type) - * - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("common.params_pyx.Params.clear_all", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":57 - * self.p.clearAll(tx_type) - * - * def check_key(self, key): # <<<<<<<<<<<<<< - * key = ensure_bytes(key) - * if not self.p.checkKey(key): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_7check_key(PyObject *__pyx_v_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_6common_10params_pyx_6Params_7check_key = {"check_key", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_7check_key, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_7check_key(PyObject *__pyx_v_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_key = 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("check_key (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 57, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "check_key") < 0)) __PYX_ERR(0, 57, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_key = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("check_key", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 57, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.check_key", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_6check_key(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_6check_key(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("check_key", 0); - __Pyx_INCREF(__pyx_v_key); - - /* "common/params_pyx.pyx":58 - * - * def check_key(self, key): - * key = ensure_bytes(key) # <<<<<<<<<<<<<< - * if not self.p.checkKey(key): - * raise UnknownKeyName(key) - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ensure_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __Pyx_DECREF_SET(__pyx_v_key, __pyx_t_1); - __pyx_t_1 = 0; - - /* "common/params_pyx.pyx":59 - * def check_key(self, key): - * key = ensure_bytes(key) - * if not self.p.checkKey(key): # <<<<<<<<<<<<<< - * raise UnknownKeyName(key) - * return key - */ - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_v_key); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L1_error) - __pyx_t_6 = (!(__pyx_v_self->p->checkKey(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5)) != 0)); - if (unlikely(__pyx_t_6)) { - - /* "common/params_pyx.pyx":60 - * key = ensure_bytes(key) - * if not self.p.checkKey(key): - * raise UnknownKeyName(key) # <<<<<<<<<<<<<< - * return key - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_UnknownKeyName); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 60, __pyx_L1_error) - - /* "common/params_pyx.pyx":59 - * def check_key(self, key): - * key = ensure_bytes(key) - * if not self.p.checkKey(key): # <<<<<<<<<<<<<< - * raise UnknownKeyName(key) - * return key - */ - } - - /* "common/params_pyx.pyx":61 - * if not self.p.checkKey(key): - * raise UnknownKeyName(key) - * return key # <<<<<<<<<<<<<< - * - * def get(self, key, bool block=False, encoding=None): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_key); - __pyx_r = __pyx_v_key; - goto __pyx_L0; - - /* "common/params_pyx.pyx":57 - * self.p.clearAll(tx_type) - * - * def check_key(self, key): # <<<<<<<<<<<<<< - * key = ensure_bytes(key) - * if not self.p.checkKey(key): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("common.params_pyx.Params.check_key", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_key); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":63 - * return key - * - * def get(self, key, bool block=False, encoding=None): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string val - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_9get(PyObject *__pyx_v_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_6common_10params_pyx_6Params_9get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_9get, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_9get(PyObject *__pyx_v_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_key = 0; - bool __pyx_v_block; - 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[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("get (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_block,&__pyx_n_s_encoding,0}; - values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_block); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_encoding); - if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get") < 0)) __PYX_ERR(0, 63, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_key = values[0]; - if (values[1]) { - __pyx_v_block = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_block == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) - } else { - __pyx_v_block = ((bool)0); - } - __pyx_v_encoding = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 63, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.get", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_8get(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_block, __pyx_v_encoding); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_8get(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block, PyObject *__pyx_v_encoding) { - std::string __pyx_v_k; - std::string __pyx_v_val; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get", 1); - - /* "common/params_pyx.pyx":64 - * - * def get(self, key, bool block=False, encoding=None): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * cdef string val - * with nogil: - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":66 - * cdef string k = self.check_key(key) - * cdef string val - * with nogil: # <<<<<<<<<<<<<< - * val = self.p.get(k, block) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":67 - * cdef string val - * with nogil: - * val = self.p.get(k, block) # <<<<<<<<<<<<<< - * - * if val == b"": - */ - __pyx_v_val = __pyx_v_self->p->get(__pyx_v_k, __pyx_v_block); - } - - /* "common/params_pyx.pyx":66 - * cdef string k = self.check_key(key) - * cdef string val - * with nogil: # <<<<<<<<<<<<<< - * val = self.p.get(k, block) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":69 - * val = self.p.get(k, block) - * - * if val == b"": # <<<<<<<<<<<<<< - * if block: - * # If we got no value while running in blocked mode - */ - __pyx_t_6 = (__pyx_v_val == ((char const *)"")); - if (__pyx_t_6) { - - /* "common/params_pyx.pyx":70 - * - * if val == b"": - * if block: # <<<<<<<<<<<<<< - * # If we got no value while running in blocked mode - * # it means we got an interrupt while waiting - */ - __pyx_t_6 = (__pyx_v_block != 0); - if (unlikely(__pyx_t_6)) { - - /* "common/params_pyx.pyx":73 - * # If we got no value while running in blocked mode - * # it means we got an interrupt while waiting - * raise KeyboardInterrupt # <<<<<<<<<<<<<< - * else: - * return None - */ - __Pyx_Raise(__pyx_builtin_KeyboardInterrupt, 0, 0, 0); - __PYX_ERR(0, 73, __pyx_L1_error) - - /* "common/params_pyx.pyx":70 - * - * if val == b"": - * if block: # <<<<<<<<<<<<<< - * # If we got no value while running in blocked mode - * # it means we got an interrupt while waiting - */ - } - - /* "common/params_pyx.pyx":75 - * raise KeyboardInterrupt - * else: - * return None # <<<<<<<<<<<<<< - * - * return val if encoding is None else val.decode(encoding) - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - } - - /* "common/params_pyx.pyx":69 - * val = self.p.get(k, block) - * - * if val == b"": # <<<<<<<<<<<<<< - * if block: - * # If we got no value while running in blocked mode - */ - } - - /* "common/params_pyx.pyx":77 - * return None - * - * return val if encoding is None else val.decode(encoding) # <<<<<<<<<<<<<< - * - * def get_bool(self, key, bool block=False): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = (__pyx_v_encoding == Py_None); - if (__pyx_t_6) { - __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __pyx_t_2; - __pyx_t_2 = 0; - } else { - __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_decode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_encoding}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __pyx_t_1 = __pyx_t_2; - __pyx_t_2 = 0; - } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":63 - * return key - * - * def get(self, key, bool block=False, encoding=None): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string val - */ - - /* 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_7); - __Pyx_AddTraceback("common.params_pyx.Params.get", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":79 - * return val if encoding is None else val.decode(encoding) - * - * def get_bool(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef bool r - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_11get_bool(PyObject *__pyx_v_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_6common_10params_pyx_6Params_11get_bool = {"get_bool", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_11get_bool, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_11get_bool(PyObject *__pyx_v_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_key = 0; - bool __pyx_v_block; - #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("get_bool (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_block,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_block); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_bool") < 0)) __PYX_ERR(0, 79, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_key = values[0]; - if (values[1]) { - __pyx_v_block = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_block == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L3_error) - } else { - __pyx_v_block = ((bool)0); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_bool", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 79, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.get_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_10get_bool(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_block); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_10get_bool(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block) { - std::string __pyx_v_k; - bool __pyx_v_r; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_bool", 1); - - /* "common/params_pyx.pyx":80 - * - * def get_bool(self, key, bool block=False): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * cdef bool r - * with nogil: - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":82 - * cdef string k = self.check_key(key) - * cdef bool r - * with nogil: # <<<<<<<<<<<<<< - * r = self.p.getBool(k, block) - * return r - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":83 - * cdef bool r - * with nogil: - * r = self.p.getBool(k, block) # <<<<<<<<<<<<<< - * return r - * - */ - __pyx_v_r = __pyx_v_self->p->getBool(__pyx_v_k, __pyx_v_block); - } - - /* "common/params_pyx.pyx":82 - * cdef string k = self.check_key(key) - * cdef bool r - * with nogil: # <<<<<<<<<<<<<< - * r = self.p.getBool(k, block) - * return r - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":84 - * with nogil: - * r = self.p.getBool(k, block) - * return r # <<<<<<<<<<<<<< - * - * def get_int(self, key, bool block=False): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_r); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":79 - * return val if encoding is None else val.decode(encoding) - * - * def get_bool(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef bool r - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("common.params_pyx.Params.get_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":86 - * return r - * - * def get_int(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef int r - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_13get_int(PyObject *__pyx_v_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_6common_10params_pyx_6Params_13get_int = {"get_int", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_13get_int, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_13get_int(PyObject *__pyx_v_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_key = 0; - bool __pyx_v_block; - #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("get_int (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_block,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_block); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_int") < 0)) __PYX_ERR(0, 86, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_key = values[0]; - if (values[1]) { - __pyx_v_block = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_block == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L3_error) - } else { - __pyx_v_block = ((bool)0); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_int", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 86, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.get_int", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_12get_int(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_block); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_12get_int(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block) { - std::string __pyx_v_k; - int __pyx_v_r; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_int", 1); - - /* "common/params_pyx.pyx":87 - * - * def get_int(self, key, bool block=False): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * cdef int r - * with nogil: - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":89 - * cdef string k = self.check_key(key) - * cdef int r - * with nogil: # <<<<<<<<<<<<<< - * r = self.p.getInt(k, block) - * return r - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":90 - * cdef int r - * with nogil: - * r = self.p.getInt(k, block) # <<<<<<<<<<<<<< - * return r - * - */ - __pyx_v_r = __pyx_v_self->p->getInt(__pyx_v_k, __pyx_v_block); - } - - /* "common/params_pyx.pyx":89 - * cdef string k = self.check_key(key) - * cdef int r - * with nogil: # <<<<<<<<<<<<<< - * r = self.p.getInt(k, block) - * return r - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":91 - * with nogil: - * r = self.p.getInt(k, block) - * return r # <<<<<<<<<<<<<< - * - * def get_float(self, key, bool block=False): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_r); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":86 - * return r - * - * def get_int(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef int r - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("common.params_pyx.Params.get_int", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":93 - * return r - * - * def get_float(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef float r - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_15get_float(PyObject *__pyx_v_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_6common_10params_pyx_6Params_15get_float = {"get_float", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_15get_float, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_15get_float(PyObject *__pyx_v_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_key = 0; - bool __pyx_v_block; - #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("get_float (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_block,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_block); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_float") < 0)) __PYX_ERR(0, 93, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_key = values[0]; - if (values[1]) { - __pyx_v_block = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_block == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) - } else { - __pyx_v_block = ((bool)0); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_float", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 93, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.get_float", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_14get_float(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_block); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_14get_float(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_block) { - std::string __pyx_v_k; - float __pyx_v_r; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_float", 1); - - /* "common/params_pyx.pyx":94 - * - * def get_float(self, key, bool block=False): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * cdef float r - * with nogil: - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":96 - * cdef string k = self.check_key(key) - * cdef float r - * with nogil: # <<<<<<<<<<<<<< - * r = self.p.getFloat(k, block) - * return r - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":97 - * cdef float r - * with nogil: - * r = self.p.getFloat(k, block) # <<<<<<<<<<<<<< - * return r - * - */ - __pyx_v_r = __pyx_v_self->p->getFloat(__pyx_v_k, __pyx_v_block); - } - - /* "common/params_pyx.pyx":96 - * cdef string k = self.check_key(key) - * cdef float r - * with nogil: # <<<<<<<<<<<<<< - * r = self.p.getFloat(k, block) - * return r - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":98 - * with nogil: - * r = self.p.getFloat(k, block) - * return r # <<<<<<<<<<<<<< - * - * def put(self, key, dat): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_r); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":93 - * return r - * - * def get_float(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef float r - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("common.params_pyx.Params.get_float", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":100 - * return r - * - * def put(self, key, dat): # <<<<<<<<<<<<<< - * """ - * Warning: This function blocks until the param is written to disk! - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_17put(PyObject *__pyx_v_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_6common_10params_pyx_6Params_16put, "\n Warning: This function blocks until the param is written to disk!\n In very rare cases this can take over a second, and your code will hang.\n Use the put_nonblocking, put_bool_nonblocking in time sensitive code, but\n in general try to avoid writing params as much as possible.\n "); -static PyMethodDef __pyx_mdef_6common_10params_pyx_6Params_17put = {"put", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_17put, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6common_10params_pyx_6Params_16put}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_17put(PyObject *__pyx_v_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_key = 0; - PyObject *__pyx_v_dat = 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("put (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_dat,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dat)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, 1); __PYX_ERR(0, 100, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put") < 0)) __PYX_ERR(0, 100, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_dat = values[1]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 100, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_16put(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_dat); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_16put(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_dat) { - std::string __pyx_v_k; - std::string __pyx_v_dat_bytes; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put", 1); - - /* "common/params_pyx.pyx":107 - * in general try to avoid writing params as much as possible. - * """ - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":108 - * """ - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) # <<<<<<<<<<<<<< - * with nogil: - * self.p.put(k, dat_bytes) - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ensure_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_dat}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dat_bytes = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":109 - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: # <<<<<<<<<<<<<< - * self.p.put(k, dat_bytes) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":110 - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: - * self.p.put(k, dat_bytes) # <<<<<<<<<<<<<< - * - * def put_bool(self, key, bool val): - */ - (void)(__pyx_v_self->p->put(__pyx_v_k, __pyx_v_dat_bytes)); - } - - /* "common/params_pyx.pyx":109 - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: # <<<<<<<<<<<<<< - * self.p.put(k, dat_bytes) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":100 - * return r - * - * def put(self, key, dat): # <<<<<<<<<<<<<< - * """ - * Warning: This function blocks until the param is written to disk! - */ - - /* 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_AddTraceback("common.params_pyx.Params.put", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":112 - * self.p.put(k, dat_bytes) - * - * def put_bool(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_19put_bool(PyObject *__pyx_v_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_6common_10params_pyx_6Params_19put_bool = {"put_bool", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_19put_bool, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_19put_bool(PyObject *__pyx_v_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_key = 0; - bool __pyx_v_val; - #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("put_bool (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_bool", 1, 2, 2, 1); __PYX_ERR(0, 112, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_bool") < 0)) __PYX_ERR(0, 112, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_val = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_val == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_bool", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 112, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_18put_bool(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_val); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_18put_bool(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_val) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_bool", 1); - - /* "common/params_pyx.pyx":113 - * - * def put_bool(self, key, bool val): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putBool(k, val) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":114 - * def put_bool(self, key, bool val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putBool(k, val) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":115 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.putBool(k, val) # <<<<<<<<<<<<<< - * - * def put_int(self, key, int val): - */ - (void)(__pyx_v_self->p->putBool(__pyx_v_k, __pyx_v_val)); - } - - /* "common/params_pyx.pyx":114 - * def put_bool(self, key, bool val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putBool(k, val) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":112 - * self.p.put(k, dat_bytes) - * - * def put_bool(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":117 - * self.p.putBool(k, val) - * - * def put_int(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_21put_int(PyObject *__pyx_v_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_6common_10params_pyx_6Params_21put_int = {"put_int", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_21put_int, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_21put_int(PyObject *__pyx_v_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_key = 0; - int __pyx_v_val; - #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("put_int (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_int", 1, 2, 2, 1); __PYX_ERR(0, 117, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_int") < 0)) __PYX_ERR(0, 117, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_val = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_val == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_int", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 117, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_int", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_20put_int(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_val); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_20put_int(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_v_val) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_int", 1); - - /* "common/params_pyx.pyx":118 - * - * def put_int(self, key, int val): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putInt(k, val) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":119 - * def put_int(self, key, int val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putInt(k, val) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":120 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.putInt(k, val) # <<<<<<<<<<<<<< - * - * def put_float(self, key, float val): - */ - (void)(__pyx_v_self->p->putInt(__pyx_v_k, __pyx_v_val)); - } - - /* "common/params_pyx.pyx":119 - * def put_int(self, key, int val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putInt(k, val) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":117 - * self.p.putBool(k, val) - * - * def put_int(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_int", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":122 - * self.p.putInt(k, val) - * - * def put_float(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_23put_float(PyObject *__pyx_v_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_6common_10params_pyx_6Params_23put_float = {"put_float", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_23put_float, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_23put_float(PyObject *__pyx_v_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_key = 0; - float __pyx_v_val; - #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("put_float (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_float", 1, 2, 2, 1); __PYX_ERR(0, 122, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_float") < 0)) __PYX_ERR(0, 122, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_val = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_val == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_float", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 122, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_float", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_22put_float(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_val); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_22put_float(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, float __pyx_v_val) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_float", 1); - - /* "common/params_pyx.pyx":123 - * - * def put_float(self, key, float val): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putFloat(k, val) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":124 - * def put_float(self, key, float val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putFloat(k, val) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":125 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.putFloat(k, val) # <<<<<<<<<<<<<< - * - * def put_nonblocking(self, key, dat): - */ - (void)(__pyx_v_self->p->putFloat(__pyx_v_k, __pyx_v_val)); - } - - /* "common/params_pyx.pyx":124 - * def put_float(self, key, float val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putFloat(k, val) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":122 - * self.p.putInt(k, val) - * - * def put_float(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_float", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":127 - * self.p.putFloat(k, val) - * - * def put_nonblocking(self, key, dat): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_25put_nonblocking(PyObject *__pyx_v_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_6common_10params_pyx_6Params_25put_nonblocking = {"put_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_25put_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_25put_nonblocking(PyObject *__pyx_v_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_key = 0; - PyObject *__pyx_v_dat = 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("put_nonblocking (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_dat,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 127, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dat)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 127, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_nonblocking", 1, 2, 2, 1); __PYX_ERR(0, 127, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_nonblocking") < 0)) __PYX_ERR(0, 127, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_dat = values[1]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_nonblocking", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 127, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_24put_nonblocking(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_dat); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_24put_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_dat) { - std::string __pyx_v_k; - std::string __pyx_v_dat_bytes; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_nonblocking", 1); - - /* "common/params_pyx.pyx":128 - * - * def put_nonblocking(self, key, dat): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":129 - * def put_nonblocking(self, key, dat): - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putNonBlocking(k, dat_bytes) - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ensure_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_dat}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 129, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dat_bytes = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":130 - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putNonBlocking(k, dat_bytes) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":131 - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: - * self.p.putNonBlocking(k, dat_bytes) # <<<<<<<<<<<<<< - * - * def put_bool_nonblocking(self, key, bool val): - */ - __pyx_v_self->p->putNonBlocking(__pyx_v_k, __pyx_v_dat_bytes); - } - - /* "common/params_pyx.pyx":130 - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putNonBlocking(k, dat_bytes) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":127 - * self.p.putFloat(k, val) - * - * def put_nonblocking(self, key, dat): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":133 - * self.p.putNonBlocking(k, dat_bytes) - * - * def put_bool_nonblocking(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_27put_bool_nonblocking(PyObject *__pyx_v_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_6common_10params_pyx_6Params_27put_bool_nonblocking = {"put_bool_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_27put_bool_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_27put_bool_nonblocking(PyObject *__pyx_v_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_key = 0; - bool __pyx_v_val; - #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("put_bool_nonblocking (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 133, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 133, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_bool_nonblocking", 1, 2, 2, 1); __PYX_ERR(0, 133, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_bool_nonblocking") < 0)) __PYX_ERR(0, 133, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_val = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_val == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 133, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_bool_nonblocking", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 133, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_bool_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_26put_bool_nonblocking(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_val); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_26put_bool_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, bool __pyx_v_val) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_bool_nonblocking", 1); - - /* "common/params_pyx.pyx":134 - * - * def put_bool_nonblocking(self, key, bool val): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putBoolNonBlocking(k, val) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":135 - * def put_bool_nonblocking(self, key, bool val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putBoolNonBlocking(k, val) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":136 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.putBoolNonBlocking(k, val) # <<<<<<<<<<<<<< - * - * def put_int_nonblocking(self, key, int val): - */ - __pyx_v_self->p->putBoolNonBlocking(__pyx_v_k, __pyx_v_val); - } - - /* "common/params_pyx.pyx":135 - * def put_bool_nonblocking(self, key, bool val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putBoolNonBlocking(k, val) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":133 - * self.p.putNonBlocking(k, dat_bytes) - * - * def put_bool_nonblocking(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_bool_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":138 - * self.p.putBoolNonBlocking(k, val) - * - * def put_int_nonblocking(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_29put_int_nonblocking(PyObject *__pyx_v_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_6common_10params_pyx_6Params_29put_int_nonblocking = {"put_int_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_29put_int_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_29put_int_nonblocking(PyObject *__pyx_v_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_key = 0; - int __pyx_v_val; - #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("put_int_nonblocking (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_int_nonblocking", 1, 2, 2, 1); __PYX_ERR(0, 138, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_int_nonblocking") < 0)) __PYX_ERR(0, 138, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_val = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_val == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_int_nonblocking", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 138, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_int_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_28put_int_nonblocking(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_val); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_28put_int_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_v_val) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_int_nonblocking", 1); - - /* "common/params_pyx.pyx":139 - * - * def put_int_nonblocking(self, key, int val): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putIntNonBlocking(k, val) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 139, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":140 - * def put_int_nonblocking(self, key, int val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putIntNonBlocking(k, val) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":141 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.putIntNonBlocking(k, val) # <<<<<<<<<<<<<< - * - * def put_float_nonblocking(self, key, float val): - */ - __pyx_v_self->p->putIntNonBlocking(__pyx_v_k, __pyx_v_val); - } - - /* "common/params_pyx.pyx":140 - * def put_int_nonblocking(self, key, int val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putIntNonBlocking(k, val) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":138 - * self.p.putBoolNonBlocking(k, val) - * - * def put_int_nonblocking(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_int_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":143 - * self.p.putIntNonBlocking(k, val) - * - * def put_float_nonblocking(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_31put_float_nonblocking(PyObject *__pyx_v_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_6common_10params_pyx_6Params_31put_float_nonblocking = {"put_float_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_31put_float_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_31put_float_nonblocking(PyObject *__pyx_v_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_key = 0; - float __pyx_v_val; - #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("put_float_nonblocking (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 143, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 143, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("put_float_nonblocking", 1, 2, 2, 1); __PYX_ERR(0, 143, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "put_float_nonblocking") < 0)) __PYX_ERR(0, 143, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_key = values[0]; - __pyx_v_val = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_val == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 143, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("put_float_nonblocking", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 143, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.put_float_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_30put_float_nonblocking(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key, __pyx_v_val); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_30put_float_nonblocking(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key, float __pyx_v_val) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("put_float_nonblocking", 1); - - /* "common/params_pyx.pyx":144 - * - * def put_float_nonblocking(self, key, float val): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.putFloatNonBlocking(k, val) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":145 - * def put_float_nonblocking(self, key, float val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putFloatNonBlocking(k, val) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":146 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.putFloatNonBlocking(k, val) # <<<<<<<<<<<<<< - * - * def remove(self, key): - */ - __pyx_v_self->p->putFloatNonBlocking(__pyx_v_k, __pyx_v_val); - } - - /* "common/params_pyx.pyx":145 - * def put_float_nonblocking(self, key, float val): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.putFloatNonBlocking(k, val) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":143 - * self.p.putIntNonBlocking(k, val) - * - * def put_float_nonblocking(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.put_float_nonblocking", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":148 - * self.p.putFloatNonBlocking(k, val) - * - * def remove(self, key): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_33remove(PyObject *__pyx_v_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_6common_10params_pyx_6Params_33remove = {"remove", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_33remove, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_33remove(PyObject *__pyx_v_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_key = 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("remove (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "remove") < 0)) __PYX_ERR(0, 148, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_key = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("remove", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 148, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.remove", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_32remove(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_32remove(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key) { - std::string __pyx_v_k; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("remove", 1); - - /* "common/params_pyx.pyx":149 - * - * def remove(self, key): - * cdef string k = self.check_key(key) # <<<<<<<<<<<<<< - * with nogil: - * self.p.remove(k) - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_check_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_k = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":150 - * def remove(self, key): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.remove(k) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - - /* "common/params_pyx.pyx":151 - * cdef string k = self.check_key(key) - * with nogil: - * self.p.remove(k) # <<<<<<<<<<<<<< - * - * def get_param_path(self, key=""): - */ - (void)(__pyx_v_self->p->remove(__pyx_v_k)); - } - - /* "common/params_pyx.pyx":150 - * def remove(self, key): - * cdef string k = self.check_key(key) - * with nogil: # <<<<<<<<<<<<<< - * self.p.remove(k) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } - - /* "common/params_pyx.pyx":148 - * self.p.putFloatNonBlocking(k, val) - * - * def remove(self, key): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - - /* 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_AddTraceback("common.params_pyx.Params.remove", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":153 - * self.p.remove(k) - * - * def get_param_path(self, key=""): # <<<<<<<<<<<<<< - * cdef string key_bytes = ensure_bytes(key) - * return self.p.getParamPath(key_bytes).decode("utf-8") - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_35get_param_path(PyObject *__pyx_v_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_6common_10params_pyx_6Params_35get_param_path = {"get_param_path", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_35get_param_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_35get_param_path(PyObject *__pyx_v_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_key = 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_param_path (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_key,0}; - values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key); - if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 153, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_param_path") < 0)) __PYX_ERR(0, 153, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_key = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_param_path", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 153, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.get_param_path", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_34get_param_path(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v_key); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_34get_param_path(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, PyObject *__pyx_v_key) { - std::string __pyx_v_key_bytes; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_param_path", 1); - - /* "common/params_pyx.pyx":154 - * - * def get_param_path(self, key=""): - * cdef string key_bytes = ensure_bytes(key) # <<<<<<<<<<<<<< - * return self.p.getParamPath(key_bytes).decode("utf-8") - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ensure_bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_4 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_4 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_key}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_key_bytes = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_5); - - /* "common/params_pyx.pyx":155 - * def get_param_path(self, key=""): - * cdef string key_bytes = ensure_bytes(key) - * return self.p.getParamPath(key_bytes).decode("utf-8") # <<<<<<<<<<<<<< - * - * def all_keys(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_decode_cpp_string(__pyx_v_self->p->getParamPath(__pyx_v_key_bytes), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":153 - * self.p.remove(k) - * - * def get_param_path(self, key=""): # <<<<<<<<<<<<<< - * cdef string key_bytes = ensure_bytes(key) - * return self.p.getParamPath(key_bytes).decode("utf-8") - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("common.params_pyx.Params.get_param_path", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/params_pyx.pyx":157 - * return self.p.getParamPath(key_bytes).decode("utf-8") - * - * def all_keys(self): # <<<<<<<<<<<<<< - * return self.p.allKeys() - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_37all_keys(PyObject *__pyx_v_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_6common_10params_pyx_6Params_37all_keys = {"all_keys", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_37all_keys, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_37all_keys(PyObject *__pyx_v_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 -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("all_keys (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("all_keys", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "all_keys", 0))) return NULL; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_36all_keys(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_36all_keys(struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self) { - 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("all_keys", 1); - - /* "common/params_pyx.pyx":158 - * - * def all_keys(self): - * return self.p.allKeys() # <<<<<<<<<<<<<< - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_string(__pyx_v_self->p->allKeys()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/params_pyx.pyx":157 - * return self.p.getParamPath(key_bytes).decode("utf-8") - * - * def all_keys(self): # <<<<<<<<<<<<<< - * return self.p.allKeys() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.params_pyx.Params.all_keys", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_39__reduce_cython__(PyObject *__pyx_v_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_6common_10params_pyx_6Params_39__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_39__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_39__reduce_cython__(PyObject *__pyx_v_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 -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_38__reduce_cython__(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_38__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("common.params_pyx.Params.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_10params_pyx_6Params_41__setstate_cython__(PyObject *__pyx_v_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_6common_10params_pyx_6Params_41__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_41__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_10params_pyx_6Params_41__setstate_cython__(PyObject *__pyx_v_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 -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 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("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.params_pyx.Params.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_10params_pyx_6Params_40__setstate_cython__(((struct __pyx_obj_6common_10params_pyx_Params *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_10params_pyx_6Params_40__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6common_10params_pyx_Params *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":4 - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("common.params_pyx.Params.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_tp_new_6common_10params_pyx_Params(PyTypeObject *t, PyObject *a, 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 (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - if (unlikely(__pyx_pw_6common_10params_pyx_6Params_1__cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_6common_10params_pyx_Params(PyObject *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)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6common_10params_pyx_Params) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_pw_6common_10params_pyx_6Params_3__dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*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 PyMethodDef __pyx_methods_6common_10params_pyx_Params[] = { - {"clear_all", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_5clear_all, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"check_key", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_7check_key, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_9get, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"get_bool", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_11get_bool, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"get_int", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_13get_int, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"get_float", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_15get_float, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_17put, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_6common_10params_pyx_6Params_16put}, - {"put_bool", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_19put_bool, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put_int", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_21put_int, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put_float", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_23put_float, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_25put_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put_bool_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_27put_bool_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put_int_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_29put_int_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"put_float_nonblocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_31put_float_nonblocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"remove", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_33remove, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"get_param_path", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_35get_param_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"all_keys", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_37all_keys, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_39__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_10params_pyx_6Params_41__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type_6common_10params_pyx_Params_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6common_10params_pyx_Params}, - {Py_tp_methods, (void *)__pyx_methods_6common_10params_pyx_Params}, - {Py_tp_new, (void *)__pyx_tp_new_6common_10params_pyx_Params}, - {0, 0}, -}; -static PyType_Spec __pyx_type_6common_10params_pyx_Params_spec = { - "common.params_pyx.Params", - sizeof(struct __pyx_obj_6common_10params_pyx_Params), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, - __pyx_type_6common_10params_pyx_Params_slots, -}; -#else - -static PyTypeObject __pyx_type_6common_10params_pyx_Params = { - PyVarObject_HEAD_INIT(0, 0) - "common.params_pyx.""Params", /*tp_name*/ - sizeof(struct __pyx_obj_6common_10params_pyx_Params), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6common_10params_pyx_Params, /*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*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 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_BASETYPE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6common_10params_pyx_Params, /*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_6common_10params_pyx_Params, /*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 PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static int __pyx_tp_traverse___Pyx_EnumMeta(PyObject *o, visitproc v, void *a) { - int e; - if (!(&PyType_Type)->tp_traverse); else { e = (&PyType_Type)->tp_traverse(o,v,a); if (e) return e; } - return 0; -} - -static int __pyx_tp_clear___Pyx_EnumMeta(PyObject *o) { - if (!(&PyType_Type)->tp_clear); else (&PyType_Type)->tp_clear(o); - return 0; -} -static PyObject *__pyx_sq_item___Pyx_EnumMeta(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static PyMethodDef __pyx_methods___Pyx_EnumMeta[] = { - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __Pyx_EnumMeta_slots[] = { - {Py_sq_item, (void *)__pyx_sq_item___Pyx_EnumMeta}, - {Py_mp_subscript, (void *)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_5__getitem__}, - {Py_tp_traverse, (void *)__pyx_tp_traverse___Pyx_EnumMeta}, - {Py_tp_clear, (void *)__pyx_tp_clear___Pyx_EnumMeta}, - {Py_tp_iter, (void *)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_3__iter__}, - {Py_tp_methods, (void *)__pyx_methods___Pyx_EnumMeta}, - {Py_tp_init, (void *)__pyx_pw_8EnumBase_14__Pyx_EnumMeta_1__init__}, - {0, 0}, -}; -static PyType_Spec __Pyx_EnumMeta_spec = { - "common.params_pyx.__Pyx_EnumMeta", - sizeof(struct __pyx_obj___Pyx_EnumMeta), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, - __Pyx_EnumMeta_slots, -}; -#else - -static PySequenceMethods __pyx_tp_as_sequence___Pyx_EnumMeta = { - 0, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item___Pyx_EnumMeta, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping___Pyx_EnumMeta = { - 0, /*mp_length*/ - __pyx_pw_8EnumBase_14__Pyx_EnumMeta_5__getitem__, /*mp_subscript*/ - 0, /*mp_ass_subscript*/ -}; - -static PyTypeObject __Pyx_EnumMeta = { - PyVarObject_HEAD_INIT(0, 0) - "common.params_pyx.""__Pyx_EnumMeta", /*tp_name*/ - sizeof(struct __pyx_obj___Pyx_EnumMeta), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - 0, /*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*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence___Pyx_EnumMeta, /*tp_as_sequence*/ - &__pyx_tp_as_mapping___Pyx_EnumMeta, /*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_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse___Pyx_EnumMeta, /*tp_traverse*/ - __pyx_tp_clear___Pyx_EnumMeta, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - __pyx_pw_8EnumBase_14__Pyx_EnumMeta_3__iter__, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods___Pyx_EnumMeta, /*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 - __pyx_pw_8EnumBase_14__Pyx_EnumMeta_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - 0, /*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 PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #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 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} -}; -#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 -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, - {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, - {&__pyx_n_s_ALL, __pyx_k_ALL, sizeof(__pyx_k_ALL), 0, 0, 1, 1}, - {&__pyx_n_s_CLEAR_ON_MANAGER_START, __pyx_k_CLEAR_ON_MANAGER_START, sizeof(__pyx_k_CLEAR_ON_MANAGER_START), 0, 0, 1, 1}, - {&__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION, __pyx_k_CLEAR_ON_OFFROAD_TRANSITION, sizeof(__pyx_k_CLEAR_ON_OFFROAD_TRANSITION), 0, 0, 1, 1}, - {&__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION, __pyx_k_CLEAR_ON_ONROAD_TRANSITION, sizeof(__pyx_k_CLEAR_ON_ONROAD_TRANSITION), 0, 0, 1, 1}, - {&__pyx_n_s_DEVELOPMENT_ONLY, __pyx_k_DEVELOPMENT_ONLY, sizeof(__pyx_k_DEVELOPMENT_ONLY), 0, 0, 1, 1}, - {&__pyx_n_s_EnumBase, __pyx_k_EnumBase, sizeof(__pyx_k_EnumBase), 0, 0, 1, 1}, - {&__pyx_n_s_EnumType, __pyx_k_EnumType, sizeof(__pyx_k_EnumType), 0, 0, 1, 1}, - {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, - {&__pyx_n_s_IntEnum, __pyx_k_IntEnum, sizeof(__pyx_k_IntEnum), 0, 0, 1, 1}, - {&__pyx_n_s_IntFlag, __pyx_k_IntFlag, sizeof(__pyx_k_IntFlag), 0, 0, 1, 1}, - {&__pyx_n_s_KeyboardInterrupt, __pyx_k_KeyboardInterrupt, sizeof(__pyx_k_KeyboardInterrupt), 0, 0, 1, 1}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_n_s_OrderedDict, __pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 0, 1, 1}, - {&__pyx_n_s_PERSISTENT, __pyx_k_PERSISTENT, sizeof(__pyx_k_PERSISTENT), 0, 0, 1, 1}, - {&__pyx_n_s_ParamKeyType, __pyx_k_ParamKeyType, sizeof(__pyx_k_ParamKeyType), 0, 0, 1, 1}, - {&__pyx_n_s_Params, __pyx_k_Params, sizeof(__pyx_k_Params), 0, 0, 1, 1}, - {&__pyx_n_s_Params___reduce_cython, __pyx_k_Params___reduce_cython, sizeof(__pyx_k_Params___reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_Params___setstate_cython, __pyx_k_Params___setstate_cython, sizeof(__pyx_k_Params___setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_Params_all_keys, __pyx_k_Params_all_keys, sizeof(__pyx_k_Params_all_keys), 0, 0, 1, 1}, - {&__pyx_n_s_Params_check_key, __pyx_k_Params_check_key, sizeof(__pyx_k_Params_check_key), 0, 0, 1, 1}, - {&__pyx_n_s_Params_clear_all, __pyx_k_Params_clear_all, sizeof(__pyx_k_Params_clear_all), 0, 0, 1, 1}, - {&__pyx_n_s_Params_get, __pyx_k_Params_get, sizeof(__pyx_k_Params_get), 0, 0, 1, 1}, - {&__pyx_n_s_Params_get_bool, __pyx_k_Params_get_bool, sizeof(__pyx_k_Params_get_bool), 0, 0, 1, 1}, - {&__pyx_n_s_Params_get_float, __pyx_k_Params_get_float, sizeof(__pyx_k_Params_get_float), 0, 0, 1, 1}, - {&__pyx_n_s_Params_get_int, __pyx_k_Params_get_int, sizeof(__pyx_k_Params_get_int), 0, 0, 1, 1}, - {&__pyx_n_s_Params_get_param_path, __pyx_k_Params_get_param_path, sizeof(__pyx_k_Params_get_param_path), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put, __pyx_k_Params_put, sizeof(__pyx_k_Params_put), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_bool, __pyx_k_Params_put_bool, sizeof(__pyx_k_Params_put_bool), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_bool_nonblocking, __pyx_k_Params_put_bool_nonblocking, sizeof(__pyx_k_Params_put_bool_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_float, __pyx_k_Params_put_float, sizeof(__pyx_k_Params_put_float), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_float_nonblocking, __pyx_k_Params_put_float_nonblocking, sizeof(__pyx_k_Params_put_float_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_int, __pyx_k_Params_put_int, sizeof(__pyx_k_Params_put_int), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_int_nonblocking, __pyx_k_Params_put_int_nonblocking, sizeof(__pyx_k_Params_put_int_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_Params_put_nonblocking, __pyx_k_Params_put_nonblocking, sizeof(__pyx_k_Params_put_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_Params_remove, __pyx_k_Params_remove, sizeof(__pyx_k_Params_remove), 0, 0, 1, 1}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_EnumBase, __pyx_k_Pyx_EnumBase, sizeof(__pyx_k_Pyx_EnumBase), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_EnumBase___new, __pyx_k_Pyx_EnumBase___new, sizeof(__pyx_k_Pyx_EnumBase___new), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_EnumBase___repr, __pyx_k_Pyx_EnumBase___repr, sizeof(__pyx_k_Pyx_EnumBase___repr), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_EnumBase___str, __pyx_k_Pyx_EnumBase___str, sizeof(__pyx_k_Pyx_EnumBase___str), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_EnumMeta___reduce_cython, __pyx_k_Pyx_EnumMeta___reduce_cython, sizeof(__pyx_k_Pyx_EnumMeta___reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_EnumMeta___setstate_cython, __pyx_k_Pyx_EnumMeta___setstate_cython, sizeof(__pyx_k_Pyx_EnumMeta___setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_FlagBase, __pyx_k_Pyx_FlagBase, sizeof(__pyx_k_Pyx_FlagBase), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_FlagBase___new, __pyx_k_Pyx_FlagBase___new, sizeof(__pyx_k_Pyx_FlagBase___new), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_FlagBase___repr, __pyx_k_Pyx_FlagBase___repr, sizeof(__pyx_k_Pyx_FlagBase___repr), 0, 0, 1, 1}, - {&__pyx_n_s_Pyx_FlagBase___str, __pyx_k_Pyx_FlagBase___str, sizeof(__pyx_k_Pyx_FlagBase___str), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_UnknownKeyName, __pyx_k_UnknownKeyName, sizeof(__pyx_k_UnknownKeyName), 0, 0, 1, 1}, - {&__pyx_kp_s_Unknown_enum_value_s, __pyx_k_Unknown_enum_value_s, sizeof(__pyx_k_Unknown_enum_value_s), 0, 0, 1, 0}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_kp_u__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0, 0}, - {&__pyx_n_s__52, __pyx_k__52, sizeof(__pyx_k__52), 0, 0, 1, 1}, - {&__pyx_n_s_all_keys, __pyx_k_all_keys, sizeof(__pyx_k_all_keys), 0, 0, 1, 1}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_block, __pyx_k_block, sizeof(__pyx_k_block), 0, 0, 1, 1}, - {&__pyx_n_s_check_key, __pyx_k_check_key, sizeof(__pyx_k_check_key), 0, 0, 1, 1}, - {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, - {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1}, - {&__pyx_n_s_clear_all, __pyx_k_clear_all, sizeof(__pyx_k_clear_all), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_cls, __pyx_k_cls, sizeof(__pyx_k_cls), 0, 0, 1, 1}, - {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, - {&__pyx_kp_s_common_params_pyx, __pyx_k_common_params_pyx, sizeof(__pyx_k_common_params_pyx), 0, 0, 1, 0}, - {&__pyx_kp_s_common_params_pyx_pyx, __pyx_k_common_params_pyx_pyx, sizeof(__pyx_k_common_params_pyx_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, - {&__pyx_n_s_dat, __pyx_k_dat, sizeof(__pyx_k_dat), 0, 0, 1, 1}, - {&__pyx_n_s_dat_bytes, __pyx_k_dat_bytes, sizeof(__pyx_k_dat_bytes), 0, 0, 1, 1}, - {&__pyx_n_s_dct, __pyx_k_dct, sizeof(__pyx_k_dct), 0, 0, 1, 1}, - {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, - {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, - {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, - {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, - {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, - {&__pyx_n_s_encoding, __pyx_k_encoding, sizeof(__pyx_k_encoding), 0, 0, 1, 1}, - {&__pyx_n_s_ensure_bytes, __pyx_k_ensure_bytes, sizeof(__pyx_k_ensure_bytes), 0, 0, 1, 1}, - {&__pyx_n_s_enum, __pyx_k_enum, sizeof(__pyx_k_enum), 0, 0, 1, 1}, - {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, - {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, - {&__pyx_n_s_get_bool, __pyx_k_get_bool, sizeof(__pyx_k_get_bool), 0, 0, 1, 1}, - {&__pyx_n_s_get_float, __pyx_k_get_float, sizeof(__pyx_k_get_float), 0, 0, 1, 1}, - {&__pyx_n_s_get_int, __pyx_k_get_int, sizeof(__pyx_k_get_int), 0, 0, 1, 1}, - {&__pyx_n_s_get_param_path, __pyx_k_get_param_path, sizeof(__pyx_k_get_param_path), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, - {&__pyx_n_s_init_subclass, __pyx_k_init_subclass, sizeof(__pyx_k_init_subclass), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, - {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1}, - {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, - {&__pyx_n_s_key_bytes, __pyx_k_key_bytes, sizeof(__pyx_k_key_bytes), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_member_names, __pyx_k_member_names, sizeof(__pyx_k_member_names), 0, 0, 1, 1}, - {&__pyx_n_s_members, __pyx_k_members, sizeof(__pyx_k_members), 0, 0, 1, 1}, - {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, - {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, - {&__pyx_n_s_module_2, __pyx_k_module_2, sizeof(__pyx_k_module_2), 0, 0, 1, 1}, - {&__pyx_n_s_mro_entries, __pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, - {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_parents, __pyx_k_parents, sizeof(__pyx_k_parents), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, - {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, - {&__pyx_n_s_put_bool, __pyx_k_put_bool, sizeof(__pyx_k_put_bool), 0, 0, 1, 1}, - {&__pyx_n_s_put_bool_nonblocking, __pyx_k_put_bool_nonblocking, sizeof(__pyx_k_put_bool_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_put_float, __pyx_k_put_float, sizeof(__pyx_k_put_float), 0, 0, 1, 1}, - {&__pyx_n_s_put_float_nonblocking, __pyx_k_put_float_nonblocking, sizeof(__pyx_k_put_float_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_put_int, __pyx_k_put_int, sizeof(__pyx_k_put_int), 0, 0, 1, 1}, - {&__pyx_n_s_put_int_nonblocking, __pyx_k_put_int_nonblocking, sizeof(__pyx_k_put_int_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_put_nonblocking, __pyx_k_put_nonblocking, sizeof(__pyx_k_put_nonblocking), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle___Pyx_EnumMeta, __pyx_k_pyx_unpickle___Pyx_EnumMeta, sizeof(__pyx_k_pyx_unpickle___Pyx_EnumMeta), 0, 0, 1, 1}, - {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, - {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_remove, __pyx_k_remove, sizeof(__pyx_k_remove), 0, 0, 1, 1}, - {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1}, - {&__pyx_n_s_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1}, - {&__pyx_kp_s_s_s, __pyx_k_s_s, sizeof(__pyx_k_s_s), 0, 0, 1, 0}, - {&__pyx_kp_s_s_s_d, __pyx_k_s_s_d, sizeof(__pyx_k_s_s_d), 0, 0, 1, 0}, - {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, - {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, - {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_tx_type, __pyx_k_tx_type, sizeof(__pyx_k_tx_type), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1}, - {&__pyx_n_s_val, __pyx_k_val, sizeof(__pyx_k_val), 0, 0, 1, 1}, - {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, - {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_KeyboardInterrupt = __Pyx_GetBuiltinName(__pyx_n_s_KeyboardInterrupt); if (!__pyx_builtin_KeyboardInterrupt) __PYX_ERR(0, 73, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 68, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 76, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 33, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum - */ - __pyx_tuple__2 = PyTuple_Pack(3, __pyx_int_238750788, __pyx_int_228825662, __pyx_int_222419149); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - __pyx_tuple__5 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle___Pyx_EnumMeta__set_state(self, __pyx_state) - */ - __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(1, 16, __pyx_L1_error) - - /* "EnumBase":28 - * cdef object __Pyx_EnumBase - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - __pyx_tuple__9 = PyTuple_Pack(5, __pyx_n_s_cls, __pyx_n_s_value, __pyx_n_s_name, __pyx_n_s_v, __pyx_n_s_res); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_new, 28, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(1, 28, __pyx_L1_error) - __pyx_tuple__11 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - - /* "EnumBase":39 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_repr, 39, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 39, __pyx_L1_error) - - /* "EnumBase":41 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_str, 41, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(1, 41, __pyx_L1_error) - - /* "EnumBase":49 - * cdef object __Pyx_FlagBase - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_new, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 49, __pyx_L1_error) - - /* "EnumBase":62 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_repr, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(1, 62, __pyx_L1_error) - - /* "EnumBase":64 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_str, 64, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(1, 64, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __pyx_unpickle___Pyx_EnumMeta(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_tuple__18 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle___Pyx_EnumMeta, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "common/params_pyx.pyx":37 - * - * - * def ensure_bytes(v): # <<<<<<<<<<<<<< - * return v.encode() if isinstance(v, str) else v - * - */ - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_v); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_ensure_bytes, 37, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 37, __pyx_L1_error) - - /* "common/params_pyx.pyx":54 - * del self.p - * - * def clear_all(self, tx_type=ParamKeyType.ALL): # <<<<<<<<<<<<<< - * self.p.clearAll(tx_type) - * - */ - __pyx_tuple__22 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_tx_type); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); - __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_clear_all, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 54, __pyx_L1_error) - - /* "common/params_pyx.pyx":57 - * self.p.clearAll(tx_type) - * - * def check_key(self, key): # <<<<<<<<<<<<<< - * key = ensure_bytes(key) - * if not self.p.checkKey(key): - */ - __pyx_tuple__24 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_key); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); - __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_check_key, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 57, __pyx_L1_error) - - /* "common/params_pyx.pyx":63 - * return key - * - * def get(self, key, bool block=False, encoding=None): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string val - */ - __pyx_tuple__26 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_block, __pyx_n_s_encoding, __pyx_n_s_k, __pyx_n_s_val); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__26); - __Pyx_GIVEREF(__pyx_tuple__26); - __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_get, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 63, __pyx_L1_error) - __pyx_tuple__28 = PyTuple_Pack(2, Py_False, Py_None); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__28); - __Pyx_GIVEREF(__pyx_tuple__28); - - /* "common/params_pyx.pyx":79 - * return val if encoding is None else val.decode(encoding) - * - * def get_bool(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef bool r - */ - __pyx_tuple__29 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_block, __pyx_n_s_k, __pyx_n_s_r); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__29); - __Pyx_GIVEREF(__pyx_tuple__29); - __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_get_bool, 79, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 79, __pyx_L1_error) - __pyx_tuple__31 = PyTuple_Pack(1, Py_False); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__31); - __Pyx_GIVEREF(__pyx_tuple__31); - - /* "common/params_pyx.pyx":86 - * return r - * - * def get_int(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef int r - */ - __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_get_int, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 86, __pyx_L1_error) - - /* "common/params_pyx.pyx":93 - * return r - * - * def get_float(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef float r - */ - __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_get_float, 93, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 93, __pyx_L1_error) - - /* "common/params_pyx.pyx":100 - * return r - * - * def put(self, key, dat): # <<<<<<<<<<<<<< - * """ - * Warning: This function blocks until the param is written to disk! - */ - __pyx_tuple__34 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_dat, __pyx_n_s_k, __pyx_n_s_dat_bytes); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__34); - __Pyx_GIVEREF(__pyx_tuple__34); - __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put, 100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 100, __pyx_L1_error) - - /* "common/params_pyx.pyx":112 - * self.p.put(k, dat_bytes) - * - * def put_bool(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_tuple__36 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_val, __pyx_n_s_k); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__36); - __Pyx_GIVEREF(__pyx_tuple__36); - __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_bool, 112, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 112, __pyx_L1_error) - - /* "common/params_pyx.pyx":117 - * self.p.putBool(k, val) - * - * def put_int(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_int, 117, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 117, __pyx_L1_error) - - /* "common/params_pyx.pyx":122 - * self.p.putInt(k, val) - * - * def put_float(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_float, 122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 122, __pyx_L1_error) - - /* "common/params_pyx.pyx":127 - * self.p.putFloat(k, val) - * - * def put_nonblocking(self, key, dat): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - */ - __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_nonblocking, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 127, __pyx_L1_error) - - /* "common/params_pyx.pyx":133 - * self.p.putNonBlocking(k, dat_bytes) - * - * def put_bool_nonblocking(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_bool_nonblocking, 133, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 133, __pyx_L1_error) - - /* "common/params_pyx.pyx":138 - * self.p.putBoolNonBlocking(k, val) - * - * def put_int_nonblocking(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_int_nonblocking, 138, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 138, __pyx_L1_error) - - /* "common/params_pyx.pyx":143 - * self.p.putIntNonBlocking(k, val) - * - * def put_float_nonblocking(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_put_float_nonblocking, 143, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 143, __pyx_L1_error) - - /* "common/params_pyx.pyx":148 - * self.p.putFloatNonBlocking(k, val) - * - * def remove(self, key): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_tuple__44 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_k); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__44); - __Pyx_GIVEREF(__pyx_tuple__44); - __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_remove, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 148, __pyx_L1_error) - - /* "common/params_pyx.pyx":153 - * self.p.remove(k) - * - * def get_param_path(self, key=""): # <<<<<<<<<<<<<< - * cdef string key_bytes = ensure_bytes(key) - * return self.p.getParamPath(key_bytes).decode("utf-8") - */ - __pyx_tuple__46 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_key_bytes); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__46); - __Pyx_GIVEREF(__pyx_tuple__46); - __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_get_param_path, 153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 153, __pyx_L1_error) - __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__48); - __Pyx_GIVEREF(__pyx_tuple__48); - - /* "common/params_pyx.pyx":157 - * return self.p.getParamPath(key_bytes).decode("utf-8") - * - * def all_keys(self): # <<<<<<<<<<<<<< - * return self.p.allKeys() - */ - __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_params_pyx_pyx, __pyx_n_s_all_keys, 157, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 157, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - __pyx_umethod_PyDict_Type_get.type = (PyObject*)&PyDict_Type; - __pyx_umethod_PyDict_Type_get.method_name = &__pyx_n_s_get; - if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_222419149 = PyInt_FromLong(222419149L); if (unlikely(!__pyx_int_222419149)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_228825662 = PyInt_FromLong(228825662L); if (unlikely(!__pyx_int_228825662)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_238750788 = PyInt_FromLong(238750788L); if (unlikely(!__pyx_int_238750788)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - return 0; -} -/* #### Code section: init_module ### */ - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_OrderedDict = Py_None; Py_INCREF(Py_None); - __Pyx_EnumBase = Py_None; Py_INCREF(Py_None); - __Pyx_FlagBase = Py_None; Py_INCREF(Py_None); - __Pyx_globals = ((PyObject*)Py_None); Py_INCREF(Py_None); - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - 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_ptype_6common_10params_pyx_Params = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6common_10params_pyx_Params_spec, NULL); if (unlikely(!__pyx_ptype_6common_10params_pyx_Params)) __PYX_ERR(0, 43, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6common_10params_pyx_Params_spec, __pyx_ptype_6common_10params_pyx_Params) < 0) __PYX_ERR(0, 43, __pyx_L1_error) - #else - __pyx_ptype_6common_10params_pyx_Params = &__pyx_type_6common_10params_pyx_Params; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_ptype_6common_10params_pyx_Params) < 0) __PYX_ERR(0, 43, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_ptype_6common_10params_pyx_Params->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6common_10params_pyx_Params->tp_dictoffset && __pyx_ptype_6common_10params_pyx_Params->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_ptype_6common_10params_pyx_Params->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Params, (PyObject *) __pyx_ptype_6common_10params_pyx_Params) < 0) __PYX_ERR(0, 43, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6common_10params_pyx_Params) < 0) __PYX_ERR(0, 43, __pyx_L1_error) - #endif - #if CYTHON_USE_TYPE_SPECS - __pyx_t_1 = PyTuple_Pack(1, (PyObject *)(&PyType_Type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype___Pyx_EnumMeta = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__Pyx_EnumMeta_spec, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_ptype___Pyx_EnumMeta)) __PYX_ERR(1, 16, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__Pyx_EnumMeta_spec, __pyx_ptype___Pyx_EnumMeta) < 0) __PYX_ERR(1, 16, __pyx_L1_error) - #else - __pyx_ptype___Pyx_EnumMeta = &__Pyx_EnumMeta; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_ptype___Pyx_EnumMeta->tp_dealloc = (&PyType_Type)->tp_dealloc; - __pyx_ptype___Pyx_EnumMeta->tp_base = (&PyType_Type); - __pyx_ptype___Pyx_EnumMeta->tp_new = (&PyType_Type)->tp_new; - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_ptype___Pyx_EnumMeta) < 0) __PYX_ERR(1, 16, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_ptype___Pyx_EnumMeta->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype___Pyx_EnumMeta->tp_dictoffset && __pyx_ptype___Pyx_EnumMeta->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_ptype___Pyx_EnumMeta->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_ptype___Pyx_EnumMeta) < 0) __PYX_ERR(1, 16, __pyx_L1_error) - #endif - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_params_pyx(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_params_pyx}, - {0, NULL} -}; -#endif - -#ifdef __cplusplus -namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "params_pyx", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ - #else - -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 -#endif - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initparams_pyx(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initparams_pyx(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_params_pyx(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_params_pyx(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -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) -#endif -{ - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else - result = PyDict_SetItemString(moddict, to_name, value); -#endif - } - 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 (__Pyx_check_single_interpreter()) - return NULL; - 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; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; -#endif - 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_params_pyx(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - 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; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = 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 'params_pyx' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("params_pyx", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "params_pyx" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #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("__Pyx_PyMODINIT_FUNC PyInit_params_pyx(void)", 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_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #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 - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_common__params_pyx) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "common.params_pyx")) { - if (unlikely((PyDict_SetItemString(modules, "common.params_pyx", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_type_import_code(); - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "EnumBase":10 - * cdef object __Pyx_OrderedDict - * - * if PY_VERSION_HEX >= 0x03060000: # <<<<<<<<<<<<<< - * __Pyx_OrderedDict = dict - * else: - */ - __pyx_t_2 = (PY_VERSION_HEX >= 0x03060000); - if (__pyx_t_2) { - - /* "EnumBase":11 - * - * if PY_VERSION_HEX >= 0x03060000: - * __Pyx_OrderedDict = dict # <<<<<<<<<<<<<< - * else: - * from collections import OrderedDict as __Pyx_OrderedDict - */ - __Pyx_INCREF((PyObject *)(&PyDict_Type)); - __Pyx_XGOTREF(__Pyx_OrderedDict); - __Pyx_DECREF_SET(__Pyx_OrderedDict, ((PyObject *)(&PyDict_Type))); - __Pyx_GIVEREF((PyObject *)(&PyDict_Type)); - - /* "EnumBase":10 - * cdef object __Pyx_OrderedDict - * - * if PY_VERSION_HEX >= 0x03060000: # <<<<<<<<<<<<<< - * __Pyx_OrderedDict = dict - * else: - */ - goto __pyx_L2; - } - - /* "EnumBase":13 - * __Pyx_OrderedDict = dict - * else: - * from collections import OrderedDict as __Pyx_OrderedDict # <<<<<<<<<<<<<< - * - * @cython.internal - */ - /*else*/ { - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_OrderedDict); - __Pyx_GIVEREF(__pyx_n_s_OrderedDict); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_OrderedDict)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_4 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_3, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_3); - __Pyx_XGOTREF(__Pyx_OrderedDict); - __Pyx_DECREF_SET(__Pyx_OrderedDict, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __pyx_L2:; - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_EnumMeta_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pyx_EnumMeta___reduce_cython, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype___Pyx_EnumMeta, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - PyType_Modified(__pyx_ptype___Pyx_EnumMeta); - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle___Pyx_EnumMeta, (type(self), 0xe3b0c44, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle___Pyx_EnumMeta__set_state(self, __pyx_state) - */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_EnumMeta_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pyx_EnumMeta___setstate_cython, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype___Pyx_EnumMeta, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 16, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - PyType_Modified(__pyx_ptype___Pyx_EnumMeta); - - /* "EnumBase":27 - * - * cdef object __Pyx_EnumBase - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): # <<<<<<<<<<<<<< - * def __new__(cls, value, name=None): - * for v in cls: - */ - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF((PyObject *)(&PyInt_Type)); - __Pyx_GIVEREF((PyObject *)(&PyInt_Type)); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)(&PyInt_Type)))) __PYX_ERR(1, 27, __pyx_L1_error); - __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_Py3MetaclassPrepare(((PyObject *)__pyx_ptype___Pyx_EnumMeta), __pyx_t_3, __pyx_n_s_Pyx_EnumBase, __pyx_n_s_Pyx_EnumBase, __pyx_t_5, __pyx_n_s_EnumBase, (PyObject *) NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (__pyx_t_3 != __pyx_t_4) { - if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(1, 27, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "EnumBase":28 - * cdef object __Pyx_EnumBase - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_EnumBase_1__new__, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Pyx_EnumBase___new, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__11); - if (__Pyx_SetNewInClass(__pyx_t_6, __pyx_n_s_new, __pyx_t_4) < 0) __PYX_ERR(1, 28, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "EnumBase":39 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_EnumBase_3__repr__, 0, __pyx_n_s_Pyx_EnumBase___repr, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_n_s_repr, __pyx_t_4) < 0) __PYX_ERR(1, 39, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "EnumBase":41 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_EnumBase_5__str__, 0, __pyx_n_s_Pyx_EnumBase___str, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_n_s_str, __pyx_t_4) < 0) __PYX_ERR(1, 41, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "EnumBase":27 - * - * cdef object __Pyx_EnumBase - * class __Pyx_EnumBase(int, metaclass=__Pyx_EnumMeta): # <<<<<<<<<<<<<< - * def __new__(cls, value, name=None): - * for v in cls: - */ - __pyx_t_4 = __Pyx_Py3ClassCreate(((PyObject *)__pyx_ptype___Pyx_EnumMeta), __pyx_n_s_Pyx_EnumBase, __pyx_t_3, __pyx_t_6, __pyx_t_5, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XGOTREF(__Pyx_EnumBase); - __Pyx_DECREF_SET(__Pyx_EnumBase, __pyx_t_4); - __Pyx_GIVEREF(__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; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "EnumBase":44 - * return "%s.%s" % (self.__class__.__name__, self.name) - * - * if PY_VERSION_HEX >= 0x03040000: # <<<<<<<<<<<<<< - * from enum import IntEnum as __Pyx_EnumBase - * - */ - __pyx_t_2 = (PY_VERSION_HEX >= 0x03040000); - if (__pyx_t_2) { - - /* "EnumBase":45 - * - * if PY_VERSION_HEX >= 0x03040000: - * from enum import IntEnum as __Pyx_EnumBase # <<<<<<<<<<<<<< - * - * cdef object __Pyx_FlagBase - */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_IntEnum); - __Pyx_GIVEREF(__pyx_n_s_IntEnum); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_IntEnum)) __PYX_ERR(1, 45, __pyx_L1_error); - __pyx_t_5 = __Pyx_Import(__pyx_n_s_enum, __pyx_t_3, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_5, __pyx_n_s_IntEnum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_3); - __Pyx_XGOTREF(__Pyx_EnumBase); - __Pyx_DECREF_SET(__Pyx_EnumBase, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "EnumBase":44 - * return "%s.%s" % (self.__class__.__name__, self.name) - * - * if PY_VERSION_HEX >= 0x03040000: # <<<<<<<<<<<<<< - * from enum import IntEnum as __Pyx_EnumBase - * - */ - } - - /* "EnumBase":48 - * - * cdef object __Pyx_FlagBase - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): # <<<<<<<<<<<<<< - * def __new__(cls, value, name=None): - * for v in cls: - */ - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF((PyObject *)(&PyInt_Type)); - __Pyx_GIVEREF((PyObject *)(&PyInt_Type)); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)(&PyInt_Type)))) __PYX_ERR(1, 48, __pyx_L1_error); - __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __Pyx_Py3MetaclassPrepare(((PyObject *)__pyx_ptype___Pyx_EnumMeta), __pyx_t_3, __pyx_n_s_Pyx_FlagBase, __pyx_n_s_Pyx_FlagBase, __pyx_t_6, __pyx_n_s_EnumBase, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (__pyx_t_3 != __pyx_t_5) { - if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(1, 48, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "EnumBase":49 - * cdef object __Pyx_FlagBase - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): - * def __new__(cls, value, name=None): # <<<<<<<<<<<<<< - * for v in cls: - * if v == value: - */ - __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_FlagBase_1__new__, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Pyx_FlagBase___new, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_5, __pyx_tuple__11); - if (__Pyx_SetNewInClass(__pyx_t_4, __pyx_n_s_new, __pyx_t_5) < 0) __PYX_ERR(1, 49, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "EnumBase":62 - * cls.__members__[name] = res - * return res - * def __repr__(self): # <<<<<<<<<<<<<< - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): - */ - __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_FlagBase_3__repr__, 0, __pyx_n_s_Pyx_FlagBase___repr, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_repr, __pyx_t_5) < 0) __PYX_ERR(1, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "EnumBase":64 - * def __repr__(self): - * return "<%s.%s: %d>" % (self.__class__.__name__, self.name, self) - * def __str__(self): # <<<<<<<<<<<<<< - * return "%s.%s" % (self.__class__.__name__, self.name) - * - */ - __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_14__Pyx_FlagBase_5__str__, 0, __pyx_n_s_Pyx_FlagBase___str, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_n_s_str, __pyx_t_5) < 0) __PYX_ERR(1, 64, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "EnumBase":48 - * - * cdef object __Pyx_FlagBase - * class __Pyx_FlagBase(int, metaclass=__Pyx_EnumMeta): # <<<<<<<<<<<<<< - * def __new__(cls, value, name=None): - * for v in cls: - */ - __pyx_t_5 = __Pyx_Py3ClassCreate(((PyObject *)__pyx_ptype___Pyx_EnumMeta), __pyx_n_s_Pyx_FlagBase, __pyx_t_3, __pyx_t_4, __pyx_t_6, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XGOTREF(__Pyx_FlagBase); - __Pyx_DECREF_SET(__Pyx_FlagBase, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "EnumBase":67 - * return "%s.%s" % (self.__class__.__name__, self.name) - * - * if PY_VERSION_HEX >= 0x03060000: # <<<<<<<<<<<<<< - * from enum import IntFlag as __Pyx_FlagBase - * - */ - __pyx_t_2 = (PY_VERSION_HEX >= 0x03060000); - if (__pyx_t_2) { - - /* "EnumBase":68 - * - * if PY_VERSION_HEX >= 0x03060000: - * from enum import IntFlag as __Pyx_FlagBase # <<<<<<<<<<<<<< - * - */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_IntFlag); - __Pyx_GIVEREF(__pyx_n_s_IntFlag); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_IntFlag)) __PYX_ERR(1, 68, __pyx_L1_error); - __pyx_t_6 = __Pyx_Import(__pyx_n_s_enum, __pyx_t_3, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_IntFlag); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_3); - __Pyx_XGOTREF(__Pyx_FlagBase); - __Pyx_DECREF_SET(__Pyx_FlagBase, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "EnumBase":67 - * return "%s.%s" % (self.__class__.__name__, self.name) - * - * if PY_VERSION_HEX >= 0x03060000: # <<<<<<<<<<<<<< - * from enum import IntFlag as __Pyx_FlagBase - * - */ - } - - /* "(tree fragment)":1 - * def __pyx_unpickle___Pyx_EnumMeta(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_8EnumBase_1__pyx_unpickle___Pyx_EnumMeta, 0, __pyx_n_s_pyx_unpickle___Pyx_EnumMeta, NULL, __pyx_n_s_EnumBase, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle___Pyx_EnumMeta, __pyx_t_6) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "EnumType":76 - * object __Pyx_PyInt_From_enum__ParamKeyType(ParamKeyType value) - * - * cdef dict __Pyx_globals = globals() # <<<<<<<<<<<<<< - * if PY_VERSION_HEX >= 0x03060000: - * - */ - __pyx_t_6 = __Pyx_Globals(); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (!(likely(PyDict_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_6))) __PYX_ERR(1, 76, __pyx_L1_error) - __Pyx_XGOTREF(__Pyx_globals); - __Pyx_DECREF_SET(__Pyx_globals, ((PyObject*)__pyx_t_6)); - __Pyx_GIVEREF(__pyx_t_6); - __pyx_t_6 = 0; - - /* "EnumType":77 - * - * cdef dict __Pyx_globals = globals() - * if PY_VERSION_HEX >= 0x03060000: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (PY_VERSION_HEX >= 0x03060000); - if (__pyx_t_2) { - - /* "EnumType":81 - * - * ParamKeyType = __Pyx_FlagBase('ParamKeyType', [ - * ('PERSISTENT', __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT)), # <<<<<<<<<<<<<< - * ('CLEAR_ON_MANAGER_START', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START)), - * ('CLEAR_ON_ONROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION)), - */ - __pyx_t_6 = __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_n_s_PERSISTENT); - __Pyx_GIVEREF(__pyx_n_s_PERSISTENT); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_PERSISTENT)) __PYX_ERR(1, 81, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6)) __PYX_ERR(1, 81, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":82 - * ParamKeyType = __Pyx_FlagBase('ParamKeyType', [ - * ('PERSISTENT', __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT)), - * ('CLEAR_ON_MANAGER_START', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START)), # <<<<<<<<<<<<<< - * ('CLEAR_ON_ONROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION)), - * ('CLEAR_ON_OFFROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION)), - */ - __pyx_t_6 = __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_n_s_CLEAR_ON_MANAGER_START); - __Pyx_GIVEREF(__pyx_n_s_CLEAR_ON_MANAGER_START); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_n_s_CLEAR_ON_MANAGER_START)) __PYX_ERR(1, 82, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_6)) __PYX_ERR(1, 82, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":83 - * ('PERSISTENT', __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT)), - * ('CLEAR_ON_MANAGER_START', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START)), - * ('CLEAR_ON_ONROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION)), # <<<<<<<<<<<<<< - * ('CLEAR_ON_OFFROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION)), - * ('DEVELOPMENT_ONLY', __Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY)), - */ - __pyx_t_6 = __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); - __Pyx_GIVEREF(__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION)) __PYX_ERR(1, 83, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6)) __PYX_ERR(1, 83, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":84 - * ('CLEAR_ON_MANAGER_START', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START)), - * ('CLEAR_ON_ONROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION)), - * ('CLEAR_ON_OFFROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION)), # <<<<<<<<<<<<<< - * ('DEVELOPMENT_ONLY', __Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY)), - * ('ALL', __Pyx_PyInt_From_enum__ParamKeyType(ALL)), - */ - __pyx_t_6 = __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_INCREF(__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); - __Pyx_GIVEREF(__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION)) __PYX_ERR(1, 84, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6)) __PYX_ERR(1, 84, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":85 - * ('CLEAR_ON_ONROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION)), - * ('CLEAR_ON_OFFROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION)), - * ('DEVELOPMENT_ONLY', __Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY)), # <<<<<<<<<<<<<< - * ('ALL', __Pyx_PyInt_From_enum__ParamKeyType(ALL)), - * - */ - __pyx_t_6 = __Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_n_s_DEVELOPMENT_ONLY); - __Pyx_GIVEREF(__pyx_n_s_DEVELOPMENT_ONLY); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_n_s_DEVELOPMENT_ONLY)) __PYX_ERR(1, 85, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(1, 85, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":86 - * ('CLEAR_ON_OFFROAD_TRANSITION', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION)), - * ('DEVELOPMENT_ONLY', __Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY)), - * ('ALL', __Pyx_PyInt_From_enum__ParamKeyType(ALL)), # <<<<<<<<<<<<<< - * - * ], module=__Pyx_globals.get("__module__", 'common.params_pyx')) - */ - __pyx_t_6 = __Pyx_PyInt_From_enum__ParamKeyType(ALL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_INCREF(__pyx_n_s_ALL); - __Pyx_GIVEREF(__pyx_n_s_ALL); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_n_s_ALL)) __PYX_ERR(1, 86, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6)) __PYX_ERR(1, 86, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":80 - * - * - * ParamKeyType = __Pyx_FlagBase('ParamKeyType', [ # <<<<<<<<<<<<<< - * ('PERSISTENT', __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT)), - * ('CLEAR_ON_MANAGER_START', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START)), - */ - __pyx_t_6 = PyList_New(6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(1, 80, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(1, 80, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(1, 80, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 3, __pyx_t_7)) __PYX_ERR(1, 80, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 4, __pyx_t_8)) __PYX_ERR(1, 80, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_9); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 5, __pyx_t_9)) __PYX_ERR(1, 80, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_t_7 = 0; - __pyx_t_8 = 0; - __pyx_t_9 = 0; - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_INCREF(__pyx_n_s_ParamKeyType); - __Pyx_GIVEREF(__pyx_n_s_ParamKeyType); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_n_s_ParamKeyType)) __PYX_ERR(1, 80, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6)) __PYX_ERR(1, 80, __pyx_L1_error); - __pyx_t_6 = 0; - - /* "EnumType":88 - * ('ALL', __Pyx_PyInt_From_enum__ParamKeyType(ALL)), - * - * ], module=__Pyx_globals.get("__module__", 'common.params_pyx')) # <<<<<<<<<<<<<< - * - * if PY_VERSION_HEX >= 0x030B0000: - */ - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get"); - __PYX_ERR(1, 88, __pyx_L1_error) - } - __pyx_t_8 = __Pyx_PyDict_GetItemDefault(__Pyx_globals, __pyx_n_s_module, __pyx_kp_s_common_params_pyx); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_module_2, __pyx_t_8) < 0) __PYX_ERR(1, 88, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":80 - * - * - * ParamKeyType = __Pyx_FlagBase('ParamKeyType', [ # <<<<<<<<<<<<<< - * ('PERSISTENT', __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT)), - * ('CLEAR_ON_MANAGER_START', __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START)), - */ - __pyx_t_8 = __Pyx_PyObject_Call(__Pyx_FlagBase, __pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ParamKeyType, __pyx_t_8) < 0) __PYX_ERR(1, 80, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":90 - * ], module=__Pyx_globals.get("__module__", 'common.params_pyx')) - * - * if PY_VERSION_HEX >= 0x030B0000: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (PY_VERSION_HEX >= 0x030B0000); - if (__pyx_t_2) { - - /* "EnumType":95 - * - * - * ParamKeyType._member_names_ = list(ParamKeyType.__members__) # <<<<<<<<<<<<<< - * - * __Pyx_globals['PERSISTENT'] = ParamKeyType.PERSISTENT - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_members); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PySequence_ListKeepNew(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_PyObject_SetAttrStr(__pyx_t_6, __pyx_n_s_member_names, __pyx_t_8) < 0) __PYX_ERR(1, 95, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "EnumType":90 - * ], module=__Pyx_globals.get("__module__", 'common.params_pyx')) - * - * if PY_VERSION_HEX >= 0x030B0000: # <<<<<<<<<<<<<< - * - * - */ - } - - /* "EnumType":97 - * ParamKeyType._member_names_ = list(ParamKeyType.__members__) - * - * __Pyx_globals['PERSISTENT'] = ParamKeyType.PERSISTENT # <<<<<<<<<<<<<< - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType.CLEAR_ON_MANAGER_START - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_ONROAD_TRANSITION - */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_PERSISTENT); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 97, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_PERSISTENT, __pyx_t_8) < 0))) __PYX_ERR(1, 97, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":98 - * - * __Pyx_globals['PERSISTENT'] = ParamKeyType.PERSISTENT - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType.CLEAR_ON_MANAGER_START # <<<<<<<<<<<<<< - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_ONROAD_TRANSITION - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_CLEAR_ON_MANAGER_START); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 98, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_CLEAR_ON_MANAGER_START, __pyx_t_6) < 0))) __PYX_ERR(1, 98, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "EnumType":99 - * __Pyx_globals['PERSISTENT'] = ParamKeyType.PERSISTENT - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType.CLEAR_ON_MANAGER_START - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_ONROAD_TRANSITION # <<<<<<<<<<<<<< - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType.DEVELOPMENT_ONLY - */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 99, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION, __pyx_t_8) < 0))) __PYX_ERR(1, 99, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":100 - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType.CLEAR_ON_MANAGER_START - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_ONROAD_TRANSITION - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION # <<<<<<<<<<<<<< - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType.DEVELOPMENT_ONLY - * __Pyx_globals['ALL'] = ParamKeyType.ALL - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 100, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION, __pyx_t_6) < 0))) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "EnumType":101 - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_ONROAD_TRANSITION - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType.DEVELOPMENT_ONLY # <<<<<<<<<<<<<< - * __Pyx_globals['ALL'] = ParamKeyType.ALL - * else: - */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_DEVELOPMENT_ONLY); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 101, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_DEVELOPMENT_ONLY, __pyx_t_8) < 0))) __PYX_ERR(1, 101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":102 - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType.DEVELOPMENT_ONLY - * __Pyx_globals['ALL'] = ParamKeyType.ALL # <<<<<<<<<<<<<< - * else: - * class ParamKeyType(__Pyx_FlagBase): - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ALL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 102, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_ALL, __pyx_t_6) < 0))) __PYX_ERR(1, 102, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "EnumType":77 - * - * cdef dict __Pyx_globals = globals() - * if PY_VERSION_HEX >= 0x03060000: # <<<<<<<<<<<<<< - * - * - */ - goto __pyx_L5; - } - - /* "EnumType":104 - * __Pyx_globals['ALL'] = ParamKeyType.ALL - * else: - * class ParamKeyType(__Pyx_FlagBase): # <<<<<<<<<<<<<< - * pass - * __Pyx_globals['PERSISTENT'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT), 'PERSISTENT') - */ - /*else*/ { - __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__Pyx_FlagBase); - __Pyx_GIVEREF(__Pyx_FlagBase); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __Pyx_FlagBase)) __PYX_ERR(1, 104, __pyx_L1_error); - __pyx_t_8 = __Pyx_PEP560_update_bases(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_CalculateMetaclass(NULL, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __Pyx_Py3MetaclassPrepare(__pyx_t_9, __pyx_t_8, __pyx_n_s_ParamKeyType, __pyx_n_s_ParamKeyType, (PyObject *) NULL, __pyx_n_s_EnumType, (PyObject *) NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_8 != __pyx_t_6) { - if (unlikely((PyDict_SetItemString(__pyx_t_7, "__orig_bases__", __pyx_t_6) < 0))) __PYX_ERR(1, 104, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_Py3ClassCreate(__pyx_t_9, __pyx_n_s_ParamKeyType, __pyx_t_8, __pyx_t_7, NULL, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ParamKeyType, __pyx_t_6) < 0) __PYX_ERR(1, 104, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":106 - * class ParamKeyType(__Pyx_FlagBase): - * pass - * __Pyx_globals['PERSISTENT'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT), 'PERSISTENT') # <<<<<<<<<<<<<< - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START), 'CLEAR_ON_MANAGER_START') - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION), 'CLEAR_ON_ONROAD_TRANSITION') - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_9); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9)) __PYX_ERR(1, 106, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_PERSISTENT); - __Pyx_GIVEREF(__pyx_n_s_PERSISTENT); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_PERSISTENT)) __PYX_ERR(1, 106, __pyx_L1_error); - __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 106, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_PERSISTENT, __pyx_t_9) < 0))) __PYX_ERR(1, 106, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "EnumType":107 - * pass - * __Pyx_globals['PERSISTENT'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT), 'PERSISTENT') - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START), 'CLEAR_ON_MANAGER_START') # <<<<<<<<<<<<<< - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION), 'CLEAR_ON_ONROAD_TRANSITION') - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION), 'CLEAR_ON_OFFROAD_TRANSITION') - */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7)) __PYX_ERR(1, 107, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CLEAR_ON_MANAGER_START); - __Pyx_GIVEREF(__pyx_n_s_CLEAR_ON_MANAGER_START); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_n_s_CLEAR_ON_MANAGER_START)) __PYX_ERR(1, 107, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 107, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_CLEAR_ON_MANAGER_START, __pyx_t_7) < 0))) __PYX_ERR(1, 107, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "EnumType":108 - * __Pyx_globals['PERSISTENT'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(PERSISTENT), 'PERSISTENT') - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START), 'CLEAR_ON_MANAGER_START') - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION), 'CLEAR_ON_ONROAD_TRANSITION') # <<<<<<<<<<<<<< - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION), 'CLEAR_ON_OFFROAD_TRANSITION') - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY), 'DEVELOPMENT_ONLY') - */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8)) __PYX_ERR(1, 108, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); - __Pyx_GIVEREF(__pyx_n_s_CLEAR_ON_ONROAD_TRANSITION); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION)) __PYX_ERR(1, 108, __pyx_L1_error); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 108, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_CLEAR_ON_ONROAD_TRANSITION, __pyx_t_8) < 0))) __PYX_ERR(1, 108, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "EnumType":109 - * __Pyx_globals['CLEAR_ON_MANAGER_START'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_MANAGER_START), 'CLEAR_ON_MANAGER_START') - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION), 'CLEAR_ON_ONROAD_TRANSITION') - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION), 'CLEAR_ON_OFFROAD_TRANSITION') # <<<<<<<<<<<<<< - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY), 'DEVELOPMENT_ONLY') - * __Pyx_globals['ALL'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(ALL), 'ALL') - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_9); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9)) __PYX_ERR(1, 109, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); - __Pyx_GIVEREF(__pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION)) __PYX_ERR(1, 109, __pyx_L1_error); - __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 109, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 109, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_CLEAR_ON_OFFROAD_TRANSITION, __pyx_t_9) < 0))) __PYX_ERR(1, 109, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "EnumType":110 - * __Pyx_globals['CLEAR_ON_ONROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_ONROAD_TRANSITION), 'CLEAR_ON_ONROAD_TRANSITION') - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION), 'CLEAR_ON_OFFROAD_TRANSITION') - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY), 'DEVELOPMENT_ONLY') # <<<<<<<<<<<<<< - * __Pyx_globals['ALL'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(ALL), 'ALL') - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7)) __PYX_ERR(1, 110, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_DEVELOPMENT_ONLY); - __Pyx_GIVEREF(__pyx_n_s_DEVELOPMENT_ONLY); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_n_s_DEVELOPMENT_ONLY)) __PYX_ERR(1, 110, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 110, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_DEVELOPMENT_ONLY, __pyx_t_7) < 0))) __PYX_ERR(1, 110, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "EnumType":111 - * __Pyx_globals['CLEAR_ON_OFFROAD_TRANSITION'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(CLEAR_ON_OFFROAD_TRANSITION), 'CLEAR_ON_OFFROAD_TRANSITION') - * __Pyx_globals['DEVELOPMENT_ONLY'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(DEVELOPMENT_ONLY), 'DEVELOPMENT_ONLY') - * __Pyx_globals['ALL'] = ParamKeyType(__Pyx_PyInt_From_enum__ParamKeyType(ALL), 'ALL') # <<<<<<<<<<<<<< - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_ParamKeyType); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_From_enum__ParamKeyType(ALL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8)) __PYX_ERR(1, 111, __pyx_L1_error); - __Pyx_INCREF(__pyx_n_s_ALL); - __Pyx_GIVEREF(__pyx_n_s_ALL); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_n_s_ALL)) __PYX_ERR(1, 111, __pyx_L1_error); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(__Pyx_globals == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 111, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__Pyx_globals, __pyx_n_s_ALL, __pyx_t_8) < 0))) __PYX_ERR(1, 111, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } - __pyx_L5:; - - /* "common/params_pyx.pyx":37 - * - * - * def ensure_bytes(v): # <<<<<<<<<<<<<< - * return v.encode() if isinstance(v, str) else v - * - */ - __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_1ensure_bytes, 0, __pyx_n_s_ensure_bytes, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ensure_bytes, __pyx_t_8) < 0) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "common/params_pyx.pyx":40 - * return v.encode() if isinstance(v, str) else v - * - * class UnknownKeyName(Exception): # <<<<<<<<<<<<<< - * pass - * - */ - __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); - __Pyx_GIVEREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])))) __PYX_ERR(0, 40, __pyx_L1_error); - __pyx_t_9 = __Pyx_PEP560_update_bases(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __Pyx_CalculateMetaclass(NULL, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_Py3MetaclassPrepare(__pyx_t_7, __pyx_t_9, __pyx_n_s_UnknownKeyName, __pyx_n_s_UnknownKeyName, (PyObject *) NULL, __pyx_kp_s_common_params_pyx, (PyObject *) NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (__pyx_t_9 != __pyx_t_8) { - if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_t_8) < 0))) __PYX_ERR(0, 40, __pyx_L1_error) - } - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_Py3ClassCreate(__pyx_t_7, __pyx_n_s_UnknownKeyName, __pyx_t_9, __pyx_t_6, NULL, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnknownKeyName, __pyx_t_8) < 0) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "common/params_pyx.pyx":54 - * del self.p - * - * def clear_all(self, tx_type=ParamKeyType.ALL): # <<<<<<<<<<<<<< - * self.p.clearAll(tx_type) - * - */ - __pyx_t_9 = __Pyx_Enum_enum__space_ParamKeyType_to_py(ALL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_k__4 = __pyx_t_9; - __Pyx_GIVEREF(__pyx_t_9); - __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_Enum_enum__space_ParamKeyType_to_py(ALL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_9); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error); - __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_5clear_all, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_clear_all, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_clear_all, __pyx_t_9) < 0) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":57 - * self.p.clearAll(tx_type) - * - * def check_key(self, key): # <<<<<<<<<<<<<< - * key = ensure_bytes(key) - * if not self.p.checkKey(key): - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_7check_key, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_check_key, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_check_key, __pyx_t_9) < 0) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":63 - * return key - * - * def get(self, key, bool block=False, encoding=None): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string val - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_9get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_get, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_tuple__28); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_get, __pyx_t_9) < 0) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":79 - * return val if encoding is None else val.decode(encoding) - * - * def get_bool(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef bool r - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_11get_bool, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_get_bool, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_tuple__31); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_get_bool, __pyx_t_9) < 0) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":86 - * return r - * - * def get_int(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef int r - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_13get_int, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_get_int, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_tuple__31); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_get_int, __pyx_t_9) < 0) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":93 - * return r - * - * def get_float(self, key, bool block=False): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef float r - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_15get_float, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_get_float, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_tuple__31); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_get_float, __pyx_t_9) < 0) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":100 - * return r - * - * def put(self, key, dat): # <<<<<<<<<<<<<< - * """ - * Warning: This function blocks until the param is written to disk! - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_17put, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put, __pyx_t_9) < 0) __PYX_ERR(0, 100, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":112 - * self.p.put(k, dat_bytes) - * - * def put_bool(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_19put_bool, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_bool, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_bool, __pyx_t_9) < 0) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":117 - * self.p.putBool(k, val) - * - * def put_int(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_21put_int, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_int, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_int, __pyx_t_9) < 0) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":122 - * self.p.putInt(k, val) - * - * def put_float(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_23put_float, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_float, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_float, __pyx_t_9) < 0) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":127 - * self.p.putFloat(k, val) - * - * def put_nonblocking(self, key, dat): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * cdef string dat_bytes = ensure_bytes(dat) - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_25put_nonblocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_nonblocking, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_nonblocking, __pyx_t_9) < 0) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":133 - * self.p.putNonBlocking(k, dat_bytes) - * - * def put_bool_nonblocking(self, key, bool val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_27put_bool_nonblocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_bool_nonblocking, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_bool_nonblocking, __pyx_t_9) < 0) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":138 - * self.p.putBoolNonBlocking(k, val) - * - * def put_int_nonblocking(self, key, int val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_29put_int_nonblocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_int_nonblocking, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_int_nonblocking, __pyx_t_9) < 0) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":143 - * self.p.putIntNonBlocking(k, val) - * - * def put_float_nonblocking(self, key, float val): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_31put_float_nonblocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_put_float_nonblocking, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_put_float_nonblocking, __pyx_t_9) < 0) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":148 - * self.p.putFloatNonBlocking(k, val) - * - * def remove(self, key): # <<<<<<<<<<<<<< - * cdef string k = self.check_key(key) - * with nogil: - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_33remove, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_remove, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_remove, __pyx_t_9) < 0) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":153 - * self.p.remove(k) - * - * def get_param_path(self, key=""): # <<<<<<<<<<<<<< - * cdef string key_bytes = ensure_bytes(key) - * return self.p.getParamPath(key_bytes).decode("utf-8") - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_35get_param_path, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_get_param_path, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_tuple__48); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_get_param_path, __pyx_t_9) < 0) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "common/params_pyx.pyx":157 - * return self.p.getParamPath(key_bytes).decode("utf-8") - * - * def all_keys(self): # <<<<<<<<<<<<<< - * return self.p.allKeys() - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_37all_keys, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params_all_keys, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_10params_pyx_Params, __pyx_n_s_all_keys, __pyx_t_9) < 0) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - PyType_Modified(__pyx_ptype_6common_10params_pyx_Params); - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_39__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params___reduce_cython, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_9) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_6common_10params_pyx_6Params_41__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Params___setstate_cython, NULL, __pyx_kp_s_common_params_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_9) < 0) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "common/params_pyx.pyx":1 - * # distutils: language = c++ # <<<<<<<<<<<<<< - * # cython: language_level = 3 - * from libcpp cimport bool - */ - __pyx_t_9 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_9) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __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); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init common.params_pyx", __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 common.params_pyx"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} -/* #### 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); -#if PY_MAJOR_VERSION >= 3 - 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); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -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 >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); - return result; -#else -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - 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_b, name); - if (unlikely(!result) && !PyErr_Occurred()) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* 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_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#elif CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(!__pyx_m)) { - return NULL; - } - result = PyObject_GetAttr(__pyx_m, name); - if (likely(result)) { - return result; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **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; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - 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); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - 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 **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 -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **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 PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #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 - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); - #endif - if (f) { - return f(func, args, (size_t)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, (size_t)nargs, NULL); - } - #endif - } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __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 -} - -/* TupleAndListFromArray */ -#if 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) { - Py_INCREF(__pyx_empty_tuple); - return __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 - 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 - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - 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 PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); - } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - 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)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - 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_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - 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 = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; - } - for (i = 0; i < n; i++) - { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); - PyObject *dict; - dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; - } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; - } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - Py_XDECREF(key); - Py_XDECREF(value); - 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; -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - Py_XDECREF(key); - Py_XDECREF(value); - return -1; -} - -/* 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); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_setattr)) - return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); -#endif - return PyObject_SetAttr(obj, attr_name, value); -} -#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_AVOID_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, PyInt_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_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, PyInt_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_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))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - 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 = PyInt_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, PyInt_FromSsize_t(i)); -} - -/* 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); -} - -/* 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_GetName(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_n_s_class_getitem); - if (!meth) { - PyErr_Clear(); - } else { - PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); - Py_DECREF(meth); - return result; - } - } - obj_type_name = __Pyx_PyType_GetName(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 - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kw, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { - Py_ssize_t kwsize; -#if CYTHON_ASSUME_SAFE_MACROS - kwsize = PyTuple_GET_SIZE(kw); -#else - kwsize = PyTuple_Size(kw); - if (kwsize < 0) return 0; -#endif - if (unlikely(kwsize == 0)) - return 1; - if (!kw_allowed) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, 0); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - goto invalid_keyword; - } -#if PY_VERSION_HEX < 0x03090000 - for (pos = 0; pos < kwsize; pos++) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, pos); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } -#endif - return 1; - } - while (PyDict_Next(kw, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if (!kw_allowed && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 0; -} - -/* GetAttr3 */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; -} -#endif -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - int res = PyObject_GetOptionalAttr(o, n, &r); - return (res != 0) ? r : __Pyx_NewRef(d); -#else - #if CYTHON_USE_TYPE_SLOTS - if (likely(PyString_Check(n))) { - r = __Pyx_PyObject_GetAttrStrNoError(o, n); - if (unlikely(!r) && likely(!PyErr_Occurred())) { - r = __Pyx_NewRef(d); - } - return r; - } - #endif - r = PyObject_GetAttr(o, n); - return (likely(r)) ? r : __Pyx_GetAttr3Default(d); -#endif -} - -/* RaiseUnexpectedTypeError */ -static int -__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) -{ - __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, - expected, obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return 0; -} - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } - } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { - #if PY_VERSION_HEX >= 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; -} -#endif - -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *module = 0; - PyObject *empty_dict = 0; - PyObject *empty_list = 0; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (unlikely(!py_import)) - goto bad; - if (!from_list) { - empty_list = PyList_New(0); - if (unlikely(!empty_list)) - goto bad; - from_list = empty_list; - } - #endif - empty_dict = PyDict_New(); - if (unlikely(!empty_dict)) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); - if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (unlikely(!py_level)) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, level); - #endif - } - } -bad: - Py_XDECREF(empty_dict); - Py_XDECREF(empty_list); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - return module; -} - -/* 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_kp_u__3); - if (unlikely(!module_dot)) { goto modbad; } - full_name = PyUnicode_Concat(module_dot, name); - if (unlikely(!full_name)) { goto modbad; } - #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - { - 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, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif - } - return value; -} - -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) -#else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); -#endif - return PyObject_GetAttr(o, n); -} - -/* HasAttr */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { - PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { - PyErr_SetString(PyExc_TypeError, - "hasattr(): attribute name must be string"); - return -1; - } - r = __Pyx_GetAttr(o, n); - if (!r) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; - } -} -#endif - -/* decode_c_bytes */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( - const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - if (unlikely((start < 0) | (stop < 0))) { - if (start < 0) { - start += length; - if (start < 0) - start = 0; - } - if (stop < 0) - stop += length; - } - if (stop > length) - stop = length; - if (unlikely(stop <= start)) - return __Pyx_NewRef(__pyx_empty_unicode); - length = stop - start; - cstring += start; - if (decode_func) { - return decode_func(cstring, length, errors); - } else { - return PyUnicode_Decode(cstring, length, encoding, errors); - } -} - -/* FixUpExtensionType */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - CYTHON_UNUSED_VAR(spec); - CYTHON_UNUSED_VAR(type); -#else - const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; - if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) - const -#endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; - while (memb && memb->name) { - if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 - 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 -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON - 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; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); - return -1; - } - Py_DECREF(descr); - changed = 1; - } -#endif - } - memb++; - } - if (changed) - PyType_Modified(type); - } -#endif - return 0; -} -#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); -} - -/* 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)) -#elif PY_MAJOR_VERSION >= 3 - #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 -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #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_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif - __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; -} - -/* 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; -} - -/* 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_MACROS - n = PyTuple_GET_SIZE(bases); -#else - n = PyTuple_Size(bases); - if (n < 0) return -1; -#endif - for (i = 1; i < n; i++) - { -#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 - PyTypeObject *b; -#if PY_MAJOR_VERSION < 3 - if (PyClass_Check(b0)) - { - PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", - PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } -#endif - b = (PyTypeObject*) b0; - if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(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 || CYTHON_COMPILING_IN_PYPY - 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_GetName(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 || CYTHON_COMPILING_IN_PYPY) - 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 */ -static int __Pyx_PyType_Ready(PyTypeObject *t) { -#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || 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; - 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 PY_VERSION_HEX >= 0x03050000 && !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 PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) - gc = PyImport_GetModule(__pyx_kp_u_gc); - #endif - if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); - if (unlikely(!gc)) return -1; - py_status = __Pyx_PyObject_CallMethod0(gc, __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_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 PY_VERSION_HEX >= 0x03050000 && !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_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 -} - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, attr_name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(attr_name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* SetupReduce */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); -#else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); -#else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) { - __Pyx_TypeName type_obj_name = - __Pyx_PyType_GetName((PyTypeObject*)type_obj); - PyErr_Format(PyExc_RuntimeError, - "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); - __Pyx_DECREF_TypeName(type_obj_name); - } - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; -} -#endif - -/* FetchSharedCythonModule */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); -} - -/* FetchCommonType */ -static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { - if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); - return -1; - } - if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); - return -1; - } - return 0; -} -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(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; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; -done: - Py_DECREF(abi_module); - assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#endif - -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL -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; - Py_ssize_t nkw = PyDict_GET_SIZE(kw); - 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 &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(kwnames, i, key); - 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) -{ - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { - return vc(func, args, nargs, NULL); - } - return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); -} -#endif - -/* CythonFunctionShared */ -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - 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; -} -#else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - 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(__pyx_CyFunctionObject *op, void *closure) -{ - CYTHON_UNUSED_VAR(closure); - 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) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif - 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 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_Py_XDECREF_SET(op->func_doc, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_name == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#else - op->func_name = PyString_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 int -__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_name, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_qualname, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - 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 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_Py_XDECREF_SET(op->func_dict, value); - 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_Py_XDECREF_SET(op->defaults_tuple, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); - 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 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_Py_XDECREF_SET(op->defaults_kwdict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); - 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 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_Py_XDECREF_SET(op->func_annotations, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); - 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_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; - CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 - if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_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_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); - Py_DECREF(fromlist); - if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); - Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); - } -ignore: - PyErr_Clear(); - } -#endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); -} -#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[] = { - {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, - {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, - {(char *) "_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 - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, -#endif -#if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, -#if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, -#else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif -#endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, -#else - {(char *) "__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) -{ - CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 - Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif -} -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 || 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_pyobjects = 0; - op->defaults_size = 0; - 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); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[i]); - PyObject_Free(m->defaults); - m->defaults = NULL; - } - 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) -{ - 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); - Py_VISIT(m->func_name); - Py_VISIT(m->func_qualname); - Py_VISIT(m->func_doc); - Py_VISIT(m->func_globals); - Py_VISIT(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); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } - return 0; -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif -} -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; - PyObject *py_name = NULL; - 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*)meth)(self, arg, kw); - case METH_NOARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - 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); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - 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; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif - 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 - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); - if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS - 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_MACROS - 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); -#if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif - 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 -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)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - ret = 1; - } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - 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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - 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; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); -} -#endif -#if CYTHON_USE_TYPE_SPECS -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 (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 0, - 0, -#if PY_MAJOR_VERSION < 3 - 0, -#else - 0, -#endif - (reprfunc) __Pyx_CyFunction_repr, - 0, - 0, - 0, - 0, - __Pyx_CyFunction_CallAsMethod, - 0, - 0, - 0, - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, - 0, -#if PY_VERSION_HEX < 0x030500A0 - offsetof(__pyx_CyFunctionObject, func_weakreflist), -#else - offsetof(PyCFunctionObject, m_weakreflist), -#endif - 0, - 0, - __pyx_CyFunction_methods, - __pyx_CyFunction_members, - __pyx_CyFunction_getsets, - 0, - 0, - __Pyx_PyMethod_New, - 0, - offsetof(__pyx_CyFunctionObject, func_dict), - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if PY_VERSION_HEX >= 0x030400a1 - 0, -#endif -#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif -}; -#endif -static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - if (unlikely(__pyx_CyFunctionType == NULL)) { - return -1; - } - return 0; -} -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults = PyObject_Malloc(size); - if (unlikely(!m->defaults)) - return PyErr_NoMemory(); - memset(m->defaults, 0, size); - m->defaults_pyobjects = pyobjects; - m->defaults_size = size; - 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_CyFunctionType), - ml, flags, qualname, closure, module, globals, code - ); - if (likely(op)) { - PyObject_GC_Track(op); - } - return op; -} - -/* Py3UpdateBases */ -static PyObject* -__Pyx_PEP560_update_bases(PyObject *bases) -{ - Py_ssize_t i, j, size_bases; - PyObject *base, *meth, *new_base, *result, *new_bases = NULL; - size_bases = PyTuple_GET_SIZE(bases); - for (i = 0; i < size_bases; i++) { - base = PyTuple_GET_ITEM(bases, i); - if (PyType_Check(base)) { - if (new_bases) { - if (PyList_Append(new_bases, base) < 0) { - goto error; - } - } - continue; - } - meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_n_s_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++) { - base = PyTuple_GET_ITEM(bases, j); - PyList_SET_ITEM(new_bases, j, base); - Py_INCREF(base); - } - } - j = PyList_GET_SIZE(new_bases); - 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); - return result; -error: - Py_XDECREF(new_bases); - return NULL; -} - -/* SetNewInClass */ -static int __Pyx_SetNewInClass(PyObject *ns, PyObject *name, PyObject *value) { -#ifdef __Pyx_CyFunction_USED - int ret; - if (__Pyx_CyFunction_Check(value)) { - PyObject *staticnew = PyStaticMethod_New(value); - if (unlikely(!staticnew)) return -1; - ret = __Pyx_SetNameInClass(ns, name, staticnew); - Py_DECREF(staticnew); - return ret; - } -#endif - return __Pyx_SetNameInClass(ns, name, value); -} - -/* CalculateMetaclass */ -static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { - Py_ssize_t i, nbases; -#if CYTHON_ASSUME_SAFE_MACROS - 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 PY_MAJOR_VERSION < 3 - if (tmptype == &PyClass_Type) - continue; -#endif - 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) { -#if PY_MAJOR_VERSION < 3 - metaclass = &PyClass_Type; -#else - metaclass = &PyType_Type; -#endif - } - Py_INCREF((PyObject*) metaclass); - return (PyObject*) metaclass; -} - -/* 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); -} - -/* 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); -#if PY_MAJOR_VERSION < 3 - if (unlikely(PyInstance_Check(obj))) - return with_error ? __Pyx_PyObject_GetAttrStr(obj, attr_name) : __Pyx_PyObject_GetAttrStrNoError(obj, attr_name); -#endif - 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 - -/* 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_n_s_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_n_s_module, modname) < 0)) goto bad; -#if PY_VERSION_HEX >= 0x03030000 - if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; -#else - CYTHON_MAYBE_UNUSED_VAR(qualname); -#endif - if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; - return ns; -bad: - Py_DECREF(ns); - return NULL; -} -#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS -static int __Pyx_SetNamesPEP487(PyObject *type_obj) { - PyTypeObject *type = (PyTypeObject*) type_obj; - PyObject *names_to_set, *key, *value, *set_name, *tmp; - Py_ssize_t i = 0; -#if CYTHON_USE_TYPE_SLOTS - names_to_set = PyDict_Copy(type->tp_dict); -#else - { - PyObject *d = PyObject_GetAttr(type_obj, __pyx_n_s_dict); - names_to_set = NULL; - if (likely(d)) { - PyObject *names_to_set = PyDict_New(); - int ret = likely(names_to_set) ? PyDict_Update(names_to_set, d) : -1; - Py_DECREF(d); - if (unlikely(ret < 0)) - Py_CLEAR(names_to_set); - } - } -#endif - if (unlikely(names_to_set == NULL)) - goto bad; - while (PyDict_Next(names_to_set, &i, &key, &value)) { - set_name = __Pyx_PyObject_LookupSpecialNoError(value, __pyx_n_s_set_name); - if (unlikely(set_name != NULL)) { - tmp = __Pyx_PyObject_Call2Args(set_name, type_obj, key); - Py_DECREF(set_name); - if (unlikely(tmp == NULL)) { - __Pyx_TypeName value_type_name = - __Pyx_PyType_GetName(Py_TYPE(value)); - __Pyx_TypeName type_name = __Pyx_PyType_GetName(type); - PyErr_Format(PyExc_RuntimeError, -#if PY_MAJOR_VERSION >= 3 - "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %R " "in '" __Pyx_FMT_TYPENAME "'", - value_type_name, key, type_name); -#else - "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %.100s in '" __Pyx_FMT_TYPENAME "'", - value_type_name, - PyString_Check(key) ? PyString_AS_STRING(key) : "?", - type_name); -#endif - goto bad; - } else { - Py_DECREF(tmp); - } - } - else if (unlikely(PyErr_Occurred())) { - goto bad; - } - } - Py_DECREF(names_to_set); - return 0; -bad: - Py_XDECREF(names_to_set); - return -1; -} -static PyObject *__Pyx_InitSubclassPEP487(PyObject *type_obj, PyObject *mkw) { -#if CYTHON_USE_TYPE_SLOTS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - PyTypeObject *type = (PyTypeObject*) type_obj; - PyObject *mro = type->tp_mro; - Py_ssize_t i, nbases; - if (unlikely(!mro)) goto done; - (void) &__Pyx_GetBuiltinName; - Py_INCREF(mro); - nbases = PyTuple_GET_SIZE(mro); - assert(PyTuple_GET_ITEM(mro, 0) == type_obj); - for (i = 1; i < nbases-1; i++) { - PyObject *base, *dict, *meth; - base = PyTuple_GET_ITEM(mro, i); - dict = ((PyTypeObject *)base)->tp_dict; - meth = __Pyx_PyDict_GetItemStrWithError(dict, __pyx_n_s_init_subclass); - if (unlikely(meth)) { - descrgetfunc f = Py_TYPE(meth)->tp_descr_get; - PyObject *res; - Py_INCREF(meth); - if (likely(f)) { - res = f(meth, NULL, type_obj); - Py_DECREF(meth); - if (unlikely(!res)) goto bad; - meth = res; - } - res = __Pyx_PyObject_FastCallDict(meth, NULL, 0, mkw); - Py_DECREF(meth); - if (unlikely(!res)) goto bad; - Py_DECREF(res); - goto done; - } else if (unlikely(PyErr_Occurred())) { - goto bad; - } - } -done: - Py_XDECREF(mro); - return type_obj; -bad: - Py_XDECREF(mro); - Py_DECREF(type_obj); - return NULL; -#else - PyObject *super_type, *super, *func, *res; -#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) - super_type = __Pyx_GetBuiltinName(__pyx_n_s_super); -#else - super_type = (PyObject*) &PySuper_Type; - (void) &__Pyx_GetBuiltinName; -#endif - super = likely(super_type) ? __Pyx_PyObject_Call2Args(super_type, type_obj, type_obj) : NULL; -#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type) - Py_XDECREF(super_type); -#endif - if (unlikely(!super)) { - Py_CLEAR(type_obj); - goto done; - } - func = __Pyx_PyObject_GetAttrStrNoError(super, __pyx_n_s_init_subclass); - Py_DECREF(super); - if (likely(!func)) { - if (unlikely(PyErr_Occurred())) - Py_CLEAR(type_obj); - goto done; - } - res = __Pyx_PyObject_FastCallDict(func, NULL, 0, mkw); - Py_DECREF(func); - if (unlikely(!res)) - Py_CLEAR(type_obj); - Py_XDECREF(res); -done: - return type_obj; -#endif -} -#endif -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_n_s_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, -#if PY_VERSION_HEX < 0x030600A4 - (metaclass == (PyObject*)&PyType_Type) ? NULL : mkw -#else - mkw -#endif - ); - Py_XDECREF(owned_metaclass); -#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS - if (likely(result) && likely(PyType_Check(result))) { - if (unlikely(__Pyx_SetNamesPEP487(result) < 0)) { - Py_CLEAR(result); - } else { - result = __Pyx_InitSubclassPEP487(result, mkw); - } - } -#else - (void) &__Pyx_GetBuiltinName; -#endif - return result; -} - -/* Globals */ -static PyObject* __Pyx_Globals(void) { - return __Pyx_NewRef(__pyx_d); -} - -/* UnpackUnboundCMethod */ -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; -} -static PyMethodDef __Pyx_UnboundCMethod_Def = { - "CythonUnboundCMethod", - __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), - METH_VARARGS | METH_KEYWORDS, - NULL -}; -static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { - PyObject *method; - method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); - if (unlikely(!method)) - return -1; - target->method = method; -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION >= 3 - if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) - #else - if (likely(!__Pyx_CyOrPyCFunction_Check(method))) - #endif - { - 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); - target->method = unbound_method; - } - } - return 0; -} - -/* CallUnboundCMethod1 */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { - if (likely(cfunc->func)) { - int flag = cfunc->flag; - if (flag == METH_O) { - return (*(cfunc->func))(self, arg); - } else if ((PY_VERSION_HEX >= 0x030600B1) && flag == METH_FASTCALL) { - #if PY_VERSION_HEX >= 0x030700A0 - return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1); - #else - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); - #endif - } else if ((PY_VERSION_HEX >= 0x030700A0) && flag == (METH_FASTCALL | METH_KEYWORDS)) { - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); - } - } - return __Pyx__CallUnboundCMethod1(cfunc, self, arg); -} -#endif -static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ - PyObject *args, *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)) { - args = PyTuple_New(1); - if (unlikely(!args)) goto bad; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - if (cfunc->flag & METH_KEYWORDS) - result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); - else - result = (*cfunc->func)(self, args); - } else { - args = PyTuple_New(2); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 1, arg); - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); - } -#else - args = PyTuple_Pack(2, self, arg); - if (unlikely(!args)) goto bad; - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); -#endif -bad: - Py_XDECREF(args); - return result; -} - -/* CallUnboundCMethod2 */ -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 -static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { - if (likely(cfunc->func)) { - PyObject *args[2] = {arg1, arg2}; - if (cfunc->flag == METH_FASTCALL) { - #if PY_VERSION_HEX >= 0x030700A0 - return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2); - #else - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); - #endif - } - #if PY_VERSION_HEX >= 0x030700A0 - if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); - #endif - } - return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); -} -#endif -static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ - PyObject *args, *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)) { - args = PyTuple_New(2); - if (unlikely(!args)) goto bad; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - if (cfunc->flag & METH_KEYWORDS) - result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); - else - result = (*cfunc->func)(self, args); - } else { - args = PyTuple_New(3); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 1, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 2, arg2); - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); - } -#else - args = PyTuple_Pack(3, self, arg1, arg2); - if (unlikely(!args)) goto bad; - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); -#endif -bad: - Py_XDECREF(args); - return result; -} - -/* dict_getitem_default */ -static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { - PyObject* value; -#if PY_MAJOR_VERSION >= 3 && (!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 (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_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_umethod_PyDict_Type_get, d, key); - else - value = __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_get, d, key, default_value); - } - return value; -} - -/* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK -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_cython_runtime)) { - return c_line; - } - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { - c_line = 0; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - return c_line; -} -#endif - -/* CodeObjectCache */ -#if !CYTHON_COMPILING_IN_LIMITED_API -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 PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { - return NULL; - } - code_object = __pyx_code_cache.entries[pos].code_object; - Py_INCREF(code_object); - return code_object; -} -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { - int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; - if (unlikely(!code_line)) { - return; - } - if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); - if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_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(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; - entries[pos].code_object = code_object; - Py_DECREF(tmp); - return; - } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); - if (unlikely(!entries)) { - return; - } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; - } - for (i=__pyx_code_cache.count; i>pos; i--) { - entries[i] = entries[i-1]; - } - entries[pos].code_line = code_line; - entries[pos].code_object = code_object; - __pyx_code_cache.count++; - Py_INCREF(code_object); -} -#endif - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #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; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); - Py_DECREF(replace); - return result; - } - PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else - return NULL; - #endif -} -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 = 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; - 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 PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else - 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; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - #else - py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif - Py_XDECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif - 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_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 - -/* 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 int __Pyx_PyInt_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 PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - 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; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if 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 *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - 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; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - 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 - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - 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; -} - -/* CIntFromPy */ -static CYTHON_INLINE enum ParamKeyType __Pyx_PyInt_As_enum__ParamKeyType(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const enum ParamKeyType neg_one = (enum ParamKeyType) -1, const_zero = (enum ParamKeyType) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(enum ParamKeyType) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (enum ParamKeyType) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - 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(enum ParamKeyType, __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(enum ParamKeyType) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(enum ParamKeyType) >= 2 * PyLong_SHIFT)) { - return (enum ParamKeyType) (((((enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(enum ParamKeyType) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(enum ParamKeyType) >= 3 * PyLong_SHIFT)) { - return (enum ParamKeyType) (((((((enum ParamKeyType)digits[2]) << PyLong_SHIFT) | (enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(enum ParamKeyType) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, 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(enum ParamKeyType) >= 4 * PyLong_SHIFT)) { - return (enum ParamKeyType) (((((((((enum ParamKeyType)digits[3]) << PyLong_SHIFT) | (enum ParamKeyType)digits[2]) << PyLong_SHIFT) | (enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)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 (enum ParamKeyType) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(enum ParamKeyType) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(enum ParamKeyType, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(enum ParamKeyType) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(enum ParamKeyType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, __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(enum ParamKeyType) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(enum ParamKeyType) - 1 > 2 * PyLong_SHIFT)) { - return (enum ParamKeyType) (((enum ParamKeyType)-1)*(((((enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(enum ParamKeyType) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(enum ParamKeyType) - 1 > 2 * PyLong_SHIFT)) { - return (enum ParamKeyType) ((((((enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(enum ParamKeyType) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(enum ParamKeyType) - 1 > 3 * PyLong_SHIFT)) { - return (enum ParamKeyType) (((enum ParamKeyType)-1)*(((((((enum ParamKeyType)digits[2]) << PyLong_SHIFT) | (enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(enum ParamKeyType) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(enum ParamKeyType) - 1 > 3 * PyLong_SHIFT)) { - return (enum ParamKeyType) ((((((((enum ParamKeyType)digits[2]) << PyLong_SHIFT) | (enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(enum ParamKeyType) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, 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(enum ParamKeyType) - 1 > 4 * PyLong_SHIFT)) { - return (enum ParamKeyType) (((enum ParamKeyType)-1)*(((((((((enum ParamKeyType)digits[3]) << PyLong_SHIFT) | (enum ParamKeyType)digits[2]) << PyLong_SHIFT) | (enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(enum ParamKeyType) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(enum ParamKeyType, 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(enum ParamKeyType) - 1 > 4 * PyLong_SHIFT)) { - return (enum ParamKeyType) ((((((((((enum ParamKeyType)digits[3]) << PyLong_SHIFT) | (enum ParamKeyType)digits[2]) << PyLong_SHIFT) | (enum ParamKeyType)digits[1]) << PyLong_SHIFT) | (enum ParamKeyType)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(enum ParamKeyType) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(enum ParamKeyType, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(enum ParamKeyType) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(enum ParamKeyType, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available, cannot convert large enums"); - return (enum ParamKeyType) -1; - } else { - enum ParamKeyType val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (enum ParamKeyType) -1; - val = __Pyx_PyInt_As_enum__ParamKeyType(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to enum ParamKeyType"); - return (enum ParamKeyType) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to enum ParamKeyType"); - return (enum ParamKeyType) -1; -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { -#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 (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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(int)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__ParamKeyType(enum ParamKeyType value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const enum ParamKeyType neg_one = (enum ParamKeyType) -1, const_zero = (enum ParamKeyType) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(enum ParamKeyType) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(enum ParamKeyType) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(enum ParamKeyType) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(enum ParamKeyType) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(enum ParamKeyType) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(enum ParamKeyType), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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(enum ParamKeyType)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_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 PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - 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; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if 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 *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - 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; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - 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 - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - 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; -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_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 PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } 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 PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* FormatTypeName */ -#if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name_2); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__52); - } - return name; -} -#endif - -/* 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); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -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); - } -} -#endif -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); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - 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; - } - return version; -#endif -} -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); - } -} - -/* InitStrings */ -#if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, 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; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} -#endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); - #else - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif - ++t; - } - 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_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#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_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - 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_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 - 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; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - 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 PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - 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 = PyInt_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); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif - } else { - Py_ssize_t ival; - PyObject *x; - x = PyNumber_Index(o); - if (!x) return -1; - ival = PyInt_AsLong(x); - Py_DECREF(x); - return ival; - } -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -/* #### Code section: utility_code_pragmas_end ### */ -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - - - -/* #### Code section: end ### */ -#endif /* Py_PYTHON_H */ diff --git a/common/params_pyx.so b/common/params_pyx.so deleted file mode 100755 index d1486aff8c90de9620e9511d858753ce72a54d05..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4013384 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
w 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

VyvD~PV_Ngs5~Ulx`*e5thuP>OJA4X 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

`jnRR&BNza`R3uFD3{)we5Nyz zv$9KPqOWu&Y6_e)(U&?C&5o8#RHidg{TRtaUub>+ud{L2f2{Q%2hPLdBaI&g&NmMq zGOjaMMzwx5Bs2X;7wj6}9rKT>1ljZc=Bw5B)Gn3`P7w~``yyR|L%{}-%Ab|rg@i_tQs=3r90*(Us z6F_mdIG3`$2;gwMOI0FZZ-PrD5U?=OrF;Z5Om?Y81e{HAsg?w6^14)4rlh)5Ujmj^ zcd5Yy%&h5B;|QpghJiuAnc6P(5COgGyVMc_Mm2J&H2@|)kB`>kwTU}`46Uu(HgPYI z&gmNAYY20|a6$=Ga|K?m;nH9D6ps>vhpG88uBa#Jp#B?3Nt)yHQSwVswUj`2DCrFf zT|+FEI&gLzUafLqAo_{bO4f6oyZyTGGN700diT6{8kT15>xKH0pWO@qo{z&Y_Nc z6;Vd*9fP`+L5i;;d|(H!B2G(@R5!Yc=np2>Z2EJ2{4SWmb;+@oLUMEsTI*a<_6hJ@*4w@5ildFhN!Q-V~b<8YU>hV>?Op>|fD&nG;B-1f5$}L*M^@&mh;3Bfd$73@RPAKygIH1EBHsu5hRH5T6&4Sjp_wj4-^R$N z>sF5YER-68tDUP#I*VF91_rJo(yNmeb=VkTu*=V5G^~JD(B-F&RK9+#T2pU>1PlY(%t$0Qd@FuNdTLLRS$Ea3u)Q z)*xyN3?{}^4qO18w+0zm(vcGYP)D+zt5!R76|pU7hbx{g!IGPu66XwTgti_l^zCV_ zshB^iRS5L*OT8liaJ^Rm;Cg=sAXxA2VlPg5Gq%>Rh&LF8FQO@ugc(t%v{ z_JUv^@ii9JHTqzE_d=XyAE6O_0Hk4k0Q4dY=>wo`8s-C_mo?1m{Oua%eZh{n(7s@2 zTxeggi|Mkq|H@p_UyM_uGjG!|OkWAO?!f^f{@i`pX#RW*UtVbo{w{D{Y4?lc1E4BR zWTo9Njt_vI19g?xNtOMO&>0KojEl z07!vYu&9|VqbG4Q`2grNP4RmXv8saE0|TshP_AY9yi{sIfrG9D@<}RqC9qDo=JL5d zRC$r{H^lTJqh!3)D-9M3k~+$o_Mtd)O&h)kKWu>7x!1+H2PXgtEQJ*xfa3E28WE7w z9II0Tdbhyplz{I6^d(?%ORP=_aJ0helz<`t(*R6-2p^GBI;Yq&D&}AuPE=Z(Cn^9q z%`OEHjLv12M)LvCdoXE@@-M*7A=tTQ+G*WJ>^uY@Xva}UcM(Tjitt2`#=7sNGHu zfQkX|0nkMN!2_TX7K3yEv?;8H zO5gziTx?GORIFYiY!gl12%LrC^!i8YXK{l*8;OmWu2eWWh8KZ zx&ZB0tlCyCYkyx}yS-?0o4=9lW+ieW)Y;9Pna#;ROHk4iog}*r#_;FtwgLce7T*ED z+3h9(&Tfq$%qL630EAAK4$7EB9REE8#)-#3?JXdmEDbdgI$2s}A{5<^S&=d;a@9mA z=Pj1@^2yRV6QN{w!9@7(J426fWQ06qgGVVN^o_S<1dZs7pkbX6?qVUG5&CPGGr|B3 zb4D1bVa^Eo@u7@R5Fg42g-n->FfU#Xc^-|&C9za36E!r(PD3`>PZ{B+&Il*qT+RrB zM|YNtV8nAq=m(sy1dMpj2$z6!MliTip^Oj_Z^;N@%q&>cMKVG~Hdb&EIA;Wp<|lQP zj8KVdUvLdL|D=MOTUKyiH^~T*%-0#Ad3;9gxFpH zIK-|15Dc-Y;`(4D{{SW>#PYiTCD<7aJO7w=+TAI3<^u@YX@9Go-O&KJx-SC=7BlnKVt$4hsV-*(vNJK>6}SK`4$XD?NNAn_ zfJ5^S0D>7|v&A4~gxz3Ts$C{*4&2jF?UcUOz-_vmTQwi-USJ0Ux0TDGcaEv719v~^ zFb>=gL;F>$ww24;m&$8T5^WCLkHqV3iIr#x+~x%0z@3Ydp6n-qdk97;2kw;sIB=f; zz=2yqh68sN01n*40fYj#65k+1`$J&A5V%x8eV1z@6u3{A2nFt|Rs`P_jO2p1eu$H9 zA{4j}nh0$#PMZh??pO&2yp+!r1cCc?1nmzgaPR9{1gl0iA4%@(Ive(L{)`6WNY@u{ z0{(&ELtUelP33$Yf??uEsAu&BH;&(umRkjlWDgB7vZrX6OlR|J-C9OJ@RP=`Nb7eI zYVzyc`qyh~Xgc2{q;df{oFBXz=G%s34Re%D)G)tBo}l4psN8rBbDl}jHu=@>>I_Tj z*q0#5oDHg8sppRmMIP@&gq##YM@=$llrs(`*X;Y>diI z8W@6i?68|c`fGEivVt1DPI_gMi*nWv$X9;+Vx0RKP8<0rF|Igg3GVAJIcuZNS@#3y zoV8KstjYr9%^JOd?7?b2zg9dO>b?9^%M(R@i$J9L_A zS|Dj^yXG5(mA!)Ijs!_pwk-P6I^Mmt+a+E_ZRUIfj{n*2(oXQM37$r za0Kyz#Svrx0FEG!0^oynjeZZK?O}pXOCs+Pqiq1N(NX|x^f>@*^fLf# zv@*2VXvtw|4JY8g(E|P*i64Urxatwy$-}wshy?fGbRdBrM!S?Bz~I(|-3zQcfZ}fl zxl}&_97E961Z)E^o`B;+U1~Z3lZLs}JOb+8?NUn#SUl3D))5dp%B8jv@H~Ls1l%^( zr4AF&08`*JfQjevu}XS;;x|B+iZ=$m{}#RuM#c{Hi@Sb;XYe;57Du95zYx$Hz&`}6 z0#E_UYEaTq+)IcSXOzr@sKDYea19uNHvu#wU?6~w0E+(va0dYWByAaarD1|S@H#5W zd3g}+h~|kwPBJaA66SaCZQEDA=Ks`V3*S&pLsgM836Qtu80idBE4?0#ket+yVfv)UE>vuGGS_EKZ^$g4y6oSJRW?slsP36(_g?>oGC- zbiZDy<#a#IVuo&xzJrvuQqo*le7e60N>|{ZLK?ME+fm1fusIRb(CL16Ymt+{{@7%f z^b;0!N^z^n2tKgIM;TU*yA(>1;L2brnJ#MmpoY`^@Jg6ZyrW+w4EF2{IDP`Of(yfS zmeP0tZVcMwGWS~e?wQd3D8whhzwT1Ln0^A)Y7GT;1y8cpW-mtxJ}qRC3b_o3GAS^tX%fi$7ZqOYl)kw)Q;B@^g?)p z5XmIhL!V%nDVG<*|6m~;m?0S_eY#|v0sx$G9s|G`=Pdx7ajpX3g>YSHg%-jiB-nK3LMJRAnF#4zHW4Z(U9uwkrn!j_XQqje0W*23(W%*bU|vUO z8)JuKWjT*lms`8c1|fe5I*Wg4V`~>$uojHE56=N(osmz#D_!}bD?`fUIQ?dq3V}4J@$BMn_-`(3&Jnh*l>@H(Wnt9} z057acdW#IriX7gX*t=f-7*#A?huKpw7J~dcAkMDzJ0OF$6`=>MrG|B_Joq4ps${Xn zQo#x6v9$=^>EJ8%g-hY0;HJrq?Rr-Q5LC%li?XgpTT$FAoE%bYG!tth`T~rtyqhZ6 z58T-l_!gGtz;#*_(xBjescVJ6BM{QT@+o5rf}v?~*!bRdby%c_(S$HnvFUQ%WvF)e zb8q0UoRLkJMzZ-OaSiJOw~Z{M58R&BFmIxs(=czYp4TvMineH&58qx$r2UNEn7x=7 zI(&Oc(|JR+S;Mi&EAFif%RcJ6MA=#WlxS|K4zq1@Lv@s~(1z+He+Q1jc%_o?@2ri+ z>ne=ZFKE2p&hq)rS+W}vyc=-7)9IPWCwPwm=iN}xL_WcbdO&tVJy}0=g4aJ$pWv~} zdNZ?N7le6h)Q^o7RG%$dqXNzE1Dv-;`P|fk!a1@v8p!S`_yah*ZUFQ3*5={FW6~nM z^;sUmd8;!ov0pRYVtuExAaSYSrA0feCwLog1w{|ZR%bLfQ{U-OikW~flltyK zOg6gHX*Ace)tMu;ph-t}I`v?Jr=)%)O1Ly*>7kaJ;PO`I1OUC&DcRjr*OLZtL5)SS zftZnKp5Q(5K3?-c?c6I8-Gf&H2@FF8o&!+)0)SlvRG5boCjxo_I7z_!06r$5_k28w zLcloyzYx&%VXWr}*aV=$S$tJ^6?_!8Uw}0gfQj|+5iZW+xMO;n1IwO7PayFTGw#sR z=d3i6Gwp}?exsgXbEf6h+ZC$&UO4a-ka_iX0|2kyW&@zrn|`pzA&%fB#vAyGr`@O# zFVEU9v@9{gMT}}gON<+klI2;duy}d44@zy&6keXC?nEWtg3X6P4K2?ytwkOI`-;gf zX)Y|v=EZ#oWSS&^vqgBtxtLx8ks!7*JJygYjs-x4(+TEPX! zOiO9J;Mg0q$z`sxYQG2VpF@1IZuS>jzl3jz8i9cnv>qwFX|7BHPk}2n=3TKlSDK^N z?)gx6J|=6FQ;_7tI{RW-qhtf%HOgoJyhd3AfY&Hz0EE^k+hklI!Cx1U6Z}+Z3;!nB zMB$OY%W%+?s;;&{`#xA{OsM=j2m`h^z_1^|N7mm6?cEzWaqe<^BfJYqkh1@FKYm|p zrlE`h%!&2Gp1lVM>xnq9eMN|C;>r#-^&k8h9Z1qSpuJ6nWkEcQtnr7IbP!P&K^$dI z?`Tt{_%nw35g*0cED+8SaafS(;J0X9WutV!i-WE)HdN{Zwb9zX4|~*16mN7G7{IW8 z2`GJsmC=C;4G(|BM5*NPLFLd2?gbu2zg%W?%!6))*MQ!5&8dt|O;QY1v0q(>x-Lai zs4_a%i}(ZvhJYS9U;&=TvoLdw3Q-Zyf;$WhrIm9=>v}s#xpP{?L$DuIwlZ1yPH?rd zdtV)=THM{Pj4l-;1}yZbbHF1O0w@De=`wv>#fRtfIu356@G?DUEs}D0G0+2rsdZq91QL)D@5;GQ7ipYS(-6S!A zK4#zp-g@B?EQc-LYV~PYMBT+6wHx$^LI8&VsEViXxxgxRJ}lxfa6cxo!vMZ!u?)0( zv52Kn#l8%S_zT=D&?D+R=25KxRO*J0$d&VO+iDTbU1(H@D1gXXFd`NM*h0XY0A2+U z`O?E!(~CT%o!mk2>Yw1g0!GAbOHfk)s`3~JZ??(}G0+Va-vx88h1}|*En*RrJ|XQt z09*i2aXf~QDMe!^_q;74AIy6}k2nP2K^kKfX$T$^V=VSr)rj=RWe`=QnjS94wN;`@ z^1sL{fQqc#DYmGH+UVK8NhC5FejHk!?T9GCpr}rst_PqlfJ#ls-O62@;Z!p*a*VD< zrTYL!mjQ`+7?7t{U8mXxEV%(j=s;Ai9SHbWk#sIf2|T$(H`YpI8<1aVSNFfUSw3GJ= z#zQCqIy~RQO6o>PRmg_qUo1Gf_P+(wNiaDbLToZZoBS`5s`^y2RM}>P&3{l?3w&!7 z+MQYrIlmBpxu58|a69a~5a+JrFZWQ_Fi}!T4dH`#T7y_r!|_}yqGs-sHP?cz(l!7i z!Q5w6E#l;^^M+vvIEd!pay0oF3ptX_1N0y;Gm6VW^j>Rj91<;dLGc;ir;vDY zGr&n!8@~3x3VDWA(f1|FOMV~bi-9c|Bb;KDnCH3eHzHcD$Km&OAW2=O(_g|PB zQ=xdt7!vCGk6+{BcQI);HvDu~XgN1-mSn3k%tfk&KNujp>oT zE!RaX-75A3iPcW{M|jQcqOPaJ8k0W2erwrm-&g;JC=UIX09*F$gTUo2s6d$G77NPP z>89`^tvnJ_zV}RCU56eX>|gD;);LvXo2{&RFr~DM+Z=%?umo z(daQkS3aC>s+SML(WQ>3J)vRvLn_4a?G4eRe6cp0dI*2fGaQFQ5*d$y-ockH`M84UZ|caG}lIaXD9}Sbx|sX zoK}L%ycEhRHRI5Y^&GV>VWr^NY1DtK5DWUsSh%0DDO&@_(KSS0Z>zZxG*xpxR8`Hc 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

O-=VtHP2CKW@0Ao^$0)z>Z1JgG zQr{~ngQ!ui0m?ASBHOPRc3XJfD2pAO809|3rACS1rHrz~k%z`cIhw#{7$x9|QC5PN zF>$L=0y0LKF*@5QyRttqN|A3(%0Dgi7-f&Mol(|5-5RBjrD2rSp{Y@xhUPzCX(5JU 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

  • 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

    Y9Mi-f^ZeAE<^>U_tCveKFk!TWYq}!H; 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

    TovviJhN_@^@Uw_g;&0heg#G{4vR=o3Z+l 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

    eqp}Kj4-vEdoptAB1DBM(`x! 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

    >BN>K}ICaAQ974Y%{}!Ag574g#+Xm7mk@Y8X!L< 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

    6aN+95p>d2n(mjtBo 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%0D}P!g8Q;|! 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

    >%dj|{)n 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ℑ1Ufu2H5LpbzG&J}!++wdRgrXQ*63N%th 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�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 Q)qhDI`64sn%*U<&2Y&7|%K!iX diff --git a/common/prefix.h b/common/prefix.h new file mode 100644 index 0000000..f5abe14 --- /dev/null +++ b/common/prefix.h @@ -0,0 +1,34 @@ +#pragma once + +#include +#include + +#include "common/params.h" +#include "common/util.h" + +class OpenpilotPrefix { +public: + OpenpilotPrefix(std::string prefix = {}) { + if (prefix.empty()) { + prefix = util::random_string(15); + } + msgq_path = "/dev/shm/" + prefix; + bool ret = util::create_directories(msgq_path, 0777); + assert(ret); + setenv("OPENPILOT_PREFIX", prefix.c_str(), 1); + } + + ~OpenpilotPrefix() { + auto param_path = Params().getParamPath(); + if (util::file_exists(param_path)) { + std::string real_path = util::readlink(param_path); + system(util::string_format("rm %s -rf", real_path.c_str()).c_str()); + unlink(param_path.c_str()); + } + system(util::string_format("rm %s -rf", msgq_path.c_str()).c_str()); + unsetenv("OPENPILOT_PREFIX"); + } + +private: + std::string msgq_path; +}; diff --git a/common/prefix.py b/common/prefix.py index d027e3e..4059ac0 100644 --- a/common/prefix.py +++ b/common/prefix.py @@ -2,14 +2,13 @@ import os import shutil import uuid -from typing import Optional from openpilot.common.params import Params from openpilot.system.hardware.hw import Paths from openpilot.system.hardware.hw import DEFAULT_DOWNLOAD_CACHE_ROOT class OpenpilotPrefix: - def __init__(self, prefix: Optional[str] = None, clean_dirs_on_exit: bool = True, shared_download_cache: bool = False): + def __init__(self, prefix: str = None, clean_dirs_on_exit: bool = True, shared_download_cache: bool = False): self.prefix = prefix if prefix else str(uuid.uuid4().hex[0:15]) self.msgq_path = os.path.join('/dev/shm', self.prefix) self.clean_dirs_on_exit = clean_dirs_on_exit diff --git a/common/queue.h b/common/queue.h new file mode 100644 index 0000000..b3558b1 --- /dev/null +++ b/common/queue.h @@ -0,0 +1,52 @@ +#pragma once + +#include +#include +#include + +template +class SafeQueue { +public: + SafeQueue() = default; + + void push(const T& v) { + { + std::unique_lock lk(m); + q.push(v); + } + cv.notify_one(); + } + + T pop() { + std::unique_lock lk(m); + cv.wait(lk, [this] { return !q.empty(); }); + T v = q.front(); + q.pop(); + return v; + } + + bool try_pop(T& v, int timeout_ms = 0) { + std::unique_lock lk(m); + if (!cv.wait_for(lk, std::chrono::milliseconds(timeout_ms), [this] { return !q.empty(); })) { + return false; + } + v = q.front(); + q.pop(); + return true; + } + + bool empty() const { + std::scoped_lock lk(m); + return q.empty(); + } + + size_t size() const { + std::scoped_lock lk(m); + return q.size(); + } + +private: + mutable std::mutex m; + std::condition_variable cv; + std::queue q; +}; diff --git a/common/ratekeeper.cc b/common/ratekeeper.cc new file mode 100644 index 0000000..7e63815 --- /dev/null +++ b/common/ratekeeper.cc @@ -0,0 +1,40 @@ +#include "common/ratekeeper.h" + +#include + +#include "common/swaglog.h" +#include "common/timing.h" +#include "common/util.h" + +RateKeeper::RateKeeper(const std::string &name, float rate, float print_delay_threshold) + : name(name), + print_delay_threshold(std::max(0.f, print_delay_threshold)) { + interval = 1 / rate; + last_monitor_time = seconds_since_boot(); + next_frame_time = last_monitor_time + interval; +} + +bool RateKeeper::keepTime() { + bool lagged = monitorTime(); + if (remaining_ > 0) { + util::sleep_for(remaining_ * 1000); + } + return lagged; +} + +bool RateKeeper::monitorTime() { + ++frame_; + last_monitor_time = seconds_since_boot(); + remaining_ = next_frame_time - last_monitor_time; + + bool lagged = remaining_ < 0; + if (lagged) { + if (print_delay_threshold > 0 && remaining_ < -print_delay_threshold) { + LOGW("%s lagging by %.2f ms", name.c_str(), -remaining_ * 1000); + } + next_frame_time = last_monitor_time + interval; + } else { + next_frame_time += interval; + } + return lagged; +} diff --git a/common/ratekeeper.h b/common/ratekeeper.h new file mode 100644 index 0000000..b6e8ac6 --- /dev/null +++ b/common/ratekeeper.h @@ -0,0 +1,23 @@ +#pragma once + +#include +#include + +class RateKeeper { +public: + RateKeeper(const std::string &name, float rate, float print_delay_threshold = 0); + ~RateKeeper() {} + bool keepTime(); + bool monitorTime(); + inline double frame() const { return frame_; } + inline double remaining() const { return remaining_; } + +private: + double interval; + double next_frame_time; + double last_monitor_time; + double remaining_ = 0; + float print_delay_threshold = 0; + uint64_t frame_ = 0; + std::string name; +}; diff --git a/common/realtime.py b/common/realtime.py index a398146..6b8587f 100644 --- a/common/realtime.py +++ b/common/realtime.py @@ -3,7 +3,6 @@ import gc import os import time from collections import deque -from typing import Optional, List, Union from setproctitle import getproctitle @@ -33,12 +32,12 @@ def set_realtime_priority(level: int) -> None: os.sched_setscheduler(0, os.SCHED_FIFO, os.sched_param(level)) -def set_core_affinity(cores: List[int]) -> None: +def set_core_affinity(cores: list[int]) -> None: if not PC: os.sched_setaffinity(0, cores) -def config_realtime_process(cores: Union[int, List[int]], priority: int) -> None: +def config_realtime_process(cores: int | list[int], priority: int) -> None: gc.disable() set_realtime_priority(priority) c = cores if isinstance(cores, list) else [cores, ] @@ -46,7 +45,7 @@ def config_realtime_process(cores: Union[int, List[int]], priority: int) -> None class Ratekeeper: - def __init__(self, rate: float, print_delay_threshold: Optional[float] = 0.0) -> None: + def __init__(self, rate: float, print_delay_threshold: float | None = 0.0) -> None: """Rate in Hz for ratekeeping. print_delay_threshold must be nonnegative.""" self._interval = 1. / rate self._next_frame_time = time.monotonic() + self._interval diff --git a/common/swaglog.cc b/common/swaglog.cc new file mode 100644 index 0000000..7864a63 --- /dev/null +++ b/common/swaglog.cc @@ -0,0 +1,152 @@ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include "common/swaglog.h" + +#include +#include +#include +#include + +#include +#include +#include "third_party/json11/json11.hpp" +#include "common/version.h" +#include "system/hardware/hw.h" + +class SwaglogState { +public: + SwaglogState() { + zctx = zmq_ctx_new(); + sock = zmq_socket(zctx, ZMQ_PUSH); + + // Timeout on shutdown for messages to be received by the logging process + int timeout = 100; + zmq_setsockopt(sock, ZMQ_LINGER, &timeout, sizeof(timeout)); + zmq_connect(sock, Path::swaglog_ipc().c_str()); + + print_level = CLOUDLOG_WARNING; + if (const char* print_lvl = getenv("LOGPRINT")) { + if (strcmp(print_lvl, "debug") == 0) { + print_level = CLOUDLOG_DEBUG; + } else if (strcmp(print_lvl, "info") == 0) { + print_level = CLOUDLOG_INFO; + } else if (strcmp(print_lvl, "warning") == 0) { + print_level = CLOUDLOG_WARNING; + } + } + + ctx_j = json11::Json::object{}; + if (char* dongle_id = getenv("DONGLE_ID")) { + ctx_j["dongle_id"] = dongle_id; + } + if (char* git_origin = getenv("GIT_ORIGIN")) { + ctx_j["origin"] = git_origin; + } + if (char* git_branch = getenv("GIT_BRANCH")) { + ctx_j["branch"] = git_branch; + } + if (char* git_commit = getenv("GIT_COMMIT")) { + ctx_j["commit"] = git_commit; + } + if (char* daemon_name = getenv("MANAGER_DAEMON")) { + ctx_j["daemon"] = daemon_name; + } + ctx_j["version"] = COMMA_VERSION; + ctx_j["dirty"] = !getenv("CLEAN"); + ctx_j["device"] = Hardware::get_name(); + } + + ~SwaglogState() { + zmq_close(sock); + zmq_ctx_destroy(zctx); + } + + void log(int levelnum, const char* filename, int lineno, const char* func, const char* msg, const std::string& log_s) { + std::lock_guard lk(lock); + if (levelnum >= print_level) { + printf("%s: %s\n", filename, msg); + } + zmq_send(sock, log_s.data(), log_s.length(), ZMQ_NOBLOCK); + } + + std::mutex lock; + void* zctx = nullptr; + void* sock = nullptr; + int print_level; + json11::Json::object ctx_j; +}; + +bool LOG_TIMESTAMPS = getenv("LOG_TIMESTAMPS"); +uint32_t NO_FRAME_ID = std::numeric_limits::max(); + +static void cloudlog_common(int levelnum, const char* filename, int lineno, const char* func, + char* msg_buf, const json11::Json::object &msg_j={}) { + static SwaglogState s; + + json11::Json::object log_j = json11::Json::object { + {"ctx", s.ctx_j}, + {"levelnum", levelnum}, + {"filename", filename}, + {"lineno", lineno}, + {"funcname", func}, + {"created", seconds_since_epoch()} + }; + if (msg_j.empty()) { + log_j["msg"] = msg_buf; + } else { + log_j["msg"] = msg_j; + } + + std::string log_s; + log_s += (char)levelnum; + ((json11::Json)log_j).dump(log_s); + s.log(levelnum, filename, lineno, func, msg_buf, log_s); + + free(msg_buf); +} + +void cloudlog_e(int levelnum, const char* filename, int lineno, const char* func, + const char* fmt, ...) { + va_list args; + va_start(args, fmt); + char* msg_buf = nullptr; + int ret = vasprintf(&msg_buf, fmt, args); + va_end(args); + if (ret <= 0 || !msg_buf) return; + cloudlog_common(levelnum, filename, lineno, func, msg_buf); +} + +void cloudlog_t_common(int levelnum, const char* filename, int lineno, const char* func, + uint32_t frame_id, const char* fmt, va_list args) { + if (!LOG_TIMESTAMPS) return; + char* msg_buf = nullptr; + int ret = vasprintf(&msg_buf, fmt, args); + if (ret <= 0 || !msg_buf) return; + json11::Json::object tspt_j = json11::Json::object{ + {"event", msg_buf}, + {"time", std::to_string(nanos_since_boot())} + }; + if (frame_id < NO_FRAME_ID) { + tspt_j["frame_id"] = std::to_string(frame_id); + } + tspt_j = json11::Json::object{{"timestamp", tspt_j}}; + cloudlog_common(levelnum, filename, lineno, func, msg_buf, tspt_j); +} + + +void cloudlog_te(int levelnum, const char* filename, int lineno, const char* func, + const char* fmt, ...) { + va_list args; + va_start(args, fmt); + cloudlog_t_common(levelnum, filename, lineno, func, NO_FRAME_ID, fmt, args); + va_end(args); +} +void cloudlog_te(int levelnum, const char* filename, int lineno, const char* func, + uint32_t frame_id, const char* fmt, ...) { + va_list args; + va_start(args, fmt); + cloudlog_t_common(levelnum, filename, lineno, func, frame_id, fmt, args); + va_end(args); +} diff --git a/common/swaglog.h b/common/swaglog.h new file mode 100644 index 0000000..06d45b1 --- /dev/null +++ b/common/swaglog.h @@ -0,0 +1,76 @@ +#pragma once + +#include "common/timing.h" + +#define CLOUDLOG_DEBUG 10 +#define CLOUDLOG_INFO 20 +#define CLOUDLOG_WARNING 30 +#define CLOUDLOG_ERROR 40 +#define CLOUDLOG_CRITICAL 50 + + +#ifdef __GNUC__ +#define SWAG_LOG_CHECK_FMT(a, b) __attribute__ ((format (printf, a, b))) +#else +#define SWAG_LOG_CHECK_FMT(a, b) +#endif + +void cloudlog_e(int levelnum, const char* filename, int lineno, const char* func, + const char* fmt, ...) SWAG_LOG_CHECK_FMT(5, 6); + +void cloudlog_te(int levelnum, const char* filename, int lineno, const char* func, + const char* fmt, ...) SWAG_LOG_CHECK_FMT(5, 6); + +void cloudlog_te(int levelnum, const char* filename, int lineno, const char* func, + uint32_t frame_id, const char* fmt, ...) SWAG_LOG_CHECK_FMT(6, 7); + + +#define cloudlog(lvl, fmt, ...) cloudlog_e(lvl, __FILE__, __LINE__, \ + __func__, \ + fmt, ## __VA_ARGS__) + +#define cloudlog_t(lvl, ...) cloudlog_te(lvl, __FILE__, __LINE__, \ + __func__, \ + __VA_ARGS__) + + +#define cloudlog_rl(burst, millis, lvl, fmt, ...) \ +{ \ + static uint64_t __begin = 0; \ + static int __printed = 0; \ + static int __missed = 0; \ + \ + int __burst = (burst); \ + int __millis = (millis); \ + uint64_t __ts = nanos_since_boot(); \ + \ + if (!__begin) { __begin = __ts; } \ + \ + if (__begin + __millis*1000000ULL < __ts) { \ + if (__missed) { \ + cloudlog(CLOUDLOG_WARNING, "cloudlog: %d messages suppressed", __missed); \ + } \ + __begin = 0; \ + __printed = 0; \ + __missed = 0; \ + } \ + \ + if (__printed < __burst) { \ + cloudlog(lvl, fmt, ## __VA_ARGS__); \ + __printed++; \ + } else { \ + __missed++; \ + } \ +} + + +#define LOGT(...) cloudlog_t(CLOUDLOG_DEBUG, __VA_ARGS__) +#define LOGD(fmt, ...) cloudlog(CLOUDLOG_DEBUG, fmt, ## __VA_ARGS__) +#define LOG(fmt, ...) cloudlog(CLOUDLOG_INFO, fmt, ## __VA_ARGS__) +#define LOGW(fmt, ...) cloudlog(CLOUDLOG_WARNING, fmt, ## __VA_ARGS__) +#define LOGE(fmt, ...) cloudlog(CLOUDLOG_ERROR, fmt, ## __VA_ARGS__) + +#define LOGD_100(fmt, ...) cloudlog_rl(2, 100, CLOUDLOG_DEBUG, fmt, ## __VA_ARGS__) +#define LOG_100(fmt, ...) cloudlog_rl(2, 100, CLOUDLOG_INFO, fmt, ## __VA_ARGS__) +#define LOGW_100(fmt, ...) cloudlog_rl(2, 100, CLOUDLOG_WARNING, fmt, ## __VA_ARGS__) +#define LOGE_100(fmt, ...) cloudlog_rl(2, 100, CLOUDLOG_ERROR, fmt, ## __VA_ARGS__) diff --git a/common/tests/.gitignore b/common/tests/.gitignore new file mode 100644 index 0000000..6cddfc7 --- /dev/null +++ b/common/tests/.gitignore @@ -0,0 +1 @@ +test_common diff --git a/common/tests/__init__.py b/common/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/common/tests/test_file_helpers.py b/common/tests/test_file_helpers.py new file mode 100644 index 0000000..1817f77 --- /dev/null +++ b/common/tests/test_file_helpers.py @@ -0,0 +1,24 @@ +import os +import unittest +from uuid import uuid4 + +from openpilot.common.file_helpers import atomic_write_in_dir + + +class TestFileHelpers(unittest.TestCase): + def run_atomic_write_func(self, atomic_write_func): + path = f"/tmp/tmp{uuid4()}" + with atomic_write_func(path) as f: + f.write("test") + assert not os.path.exists(path) + + with open(path) as f: + self.assertEqual(f.read(), "test") + os.remove(path) + + def test_atomic_write_in_dir(self): + self.run_atomic_write_func(atomic_write_in_dir) + + +if __name__ == "__main__": + unittest.main() diff --git a/common/tests/test_numpy_fast.py b/common/tests/test_numpy_fast.py new file mode 100644 index 0000000..de7bb97 --- /dev/null +++ b/common/tests/test_numpy_fast.py @@ -0,0 +1,26 @@ +import numpy as np +import unittest + +from openpilot.common.numpy_fast import interp + + +class InterpTest(unittest.TestCase): + def test_correctness_controls(self): + _A_CRUISE_MIN_BP = np.asarray([0., 5., 10., 20., 40.]) + _A_CRUISE_MIN_V = np.asarray([-1.0, -.8, -.67, -.5, -.30]) + v_ego_arr = [-1, -1e-12, 0, 4, 5, 6, 7, 10, 11, 15.2, 20, 21, 39, + 39.999999, 40, 41] + + expected = np.interp(v_ego_arr, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V) + actual = interp(v_ego_arr, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V) + + np.testing.assert_equal(actual, expected) + + for v_ego in v_ego_arr: + expected = np.interp(v_ego, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V) + actual = interp(v_ego, _A_CRUISE_MIN_BP, _A_CRUISE_MIN_V) + np.testing.assert_equal(actual, expected) + + +if __name__ == "__main__": + unittest.main() diff --git a/common/tests/test_params.cc b/common/tests/test_params.cc new file mode 100644 index 0000000..f8d6c79 --- /dev/null +++ b/common/tests/test_params.cc @@ -0,0 +1,27 @@ +#include "catch2/catch.hpp" +#define private public +#include "common/params.h" +#include "common/util.h" + +TEST_CASE("params_nonblocking_put") { + char tmp_path[] = "/tmp/asyncWriter_XXXXXX"; + const std::string param_path = mkdtemp(tmp_path); + auto param_names = {"CarParams", "IsMetric"}; + { + Params params(param_path); + for (const auto &name : param_names) { + params.putNonBlocking(name, "1"); + // param is empty + REQUIRE(params.get(name).empty()); + } + + // check if thread is running + REQUIRE(params.future.valid()); + REQUIRE(params.future.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout); + } + // check results + Params p(param_path); + for (const auto &name : param_names) { + REQUIRE(p.get(name) == "1"); + } +} diff --git a/common/tests/test_params.py b/common/tests/test_params.py new file mode 100644 index 0000000..490ee12 --- /dev/null +++ b/common/tests/test_params.py @@ -0,0 +1,113 @@ +import os +import threading +import time +import uuid +import unittest + +from openpilot.common.params import Params, ParamKeyType, UnknownKeyName + +class TestParams(unittest.TestCase): + def setUp(self): + self.params = Params() + + def test_params_put_and_get(self): + self.params.put("DongleId", "cb38263377b873ee") + assert self.params.get("DongleId") == b"cb38263377b873ee" + + def test_params_non_ascii(self): + st = b"\xe1\x90\xff" + self.params.put("CarParams", st) + assert self.params.get("CarParams") == st + + def test_params_get_cleared_manager_start(self): + self.params.put("CarParams", "test") + self.params.put("DongleId", "cb38263377b873ee") + assert self.params.get("CarParams") == b"test" + + undefined_param = self.params.get_param_path(uuid.uuid4().hex) + with open(undefined_param, "w") as f: + f.write("test") + assert os.path.isfile(undefined_param) + + self.params.clear_all(ParamKeyType.CLEAR_ON_MANAGER_START) + assert self.params.get("CarParams") is None + assert self.params.get("DongleId") is not None + assert not os.path.isfile(undefined_param) + + def test_params_two_things(self): + self.params.put("DongleId", "bob") + self.params.put("AthenadPid", "123") + assert self.params.get("DongleId") == b"bob" + assert self.params.get("AthenadPid") == b"123" + + def test_params_get_block(self): + def _delayed_writer(): + time.sleep(0.1) + self.params.put("CarParams", "test") + threading.Thread(target=_delayed_writer).start() + assert self.params.get("CarParams") is None + assert self.params.get("CarParams", True) == b"test" + + def test_params_unknown_key_fails(self): + with self.assertRaises(UnknownKeyName): + self.params.get("swag") + + with self.assertRaises(UnknownKeyName): + self.params.get_bool("swag") + + with self.assertRaises(UnknownKeyName): + self.params.put("swag", "abc") + + with self.assertRaises(UnknownKeyName): + self.params.put_bool("swag", True) + + def test_remove_not_there(self): + assert self.params.get("CarParams") is None + self.params.remove("CarParams") + assert self.params.get("CarParams") is None + + def test_get_bool(self): + self.params.remove("IsMetric") + self.assertFalse(self.params.get_bool("IsMetric")) + + self.params.put_bool("IsMetric", True) + self.assertTrue(self.params.get_bool("IsMetric")) + + self.params.put_bool("IsMetric", False) + self.assertFalse(self.params.get_bool("IsMetric")) + + self.params.put("IsMetric", "1") + self.assertTrue(self.params.get_bool("IsMetric")) + + self.params.put("IsMetric", "0") + self.assertFalse(self.params.get_bool("IsMetric")) + + def test_put_non_blocking_with_get_block(self): + q = Params() + def _delayed_writer(): + time.sleep(0.1) + Params().put_nonblocking("CarParams", "test") + threading.Thread(target=_delayed_writer).start() + assert q.get("CarParams") is None + assert q.get("CarParams", True) == b"test" + + def test_put_bool_non_blocking_with_get_block(self): + q = Params() + def _delayed_writer(): + time.sleep(0.1) + Params().put_bool_nonblocking("CarParams", True) + threading.Thread(target=_delayed_writer).start() + assert q.get("CarParams") is None + assert q.get("CarParams", True) == b"1" + + def test_params_all_keys(self): + keys = Params().all_keys() + + # sanity checks + assert len(keys) > 20 + assert len(keys) == len(set(keys)) + assert b"CarParams" in keys + + +if __name__ == "__main__": + unittest.main() diff --git a/common/tests/test_runner.cc b/common/tests/test_runner.cc new file mode 100644 index 0000000..62bf747 --- /dev/null +++ b/common/tests/test_runner.cc @@ -0,0 +1,2 @@ +#define CATCH_CONFIG_MAIN +#include "catch2/catch.hpp" diff --git a/common/tests/test_simple_kalman.py b/common/tests/test_simple_kalman.py new file mode 100644 index 0000000..f641cd1 --- /dev/null +++ b/common/tests/test_simple_kalman.py @@ -0,0 +1,35 @@ +import unittest + +from openpilot.common.simple_kalman import KF1D + + +class TestSimpleKalman(unittest.TestCase): + def setUp(self): + dt = 0.01 + x0_0 = 0.0 + x1_0 = 0.0 + A0_0 = 1.0 + A0_1 = dt + A1_0 = 0.0 + A1_1 = 1.0 + C0_0 = 1.0 + C0_1 = 0.0 + K0_0 = 0.12287673 + K1_0 = 0.29666309 + + self.kf = KF1D(x0=[[x0_0], [x1_0]], + A=[[A0_0, A0_1], [A1_0, A1_1]], + C=[C0_0, C0_1], + K=[[K0_0], [K1_0]]) + + def test_getter_setter(self): + self.kf.set_x([[1.0], [1.0]]) + self.assertEqual(self.kf.x, [[1.0], [1.0]]) + + def update_returns_state(self): + x = self.kf.update(100) + self.assertEqual(x, self.kf.x) + + +if __name__ == "__main__": + unittest.main() diff --git a/common/tests/test_swaglog.cc b/common/tests/test_swaglog.cc new file mode 100644 index 0000000..09bc4c3 --- /dev/null +++ b/common/tests/test_swaglog.cc @@ -0,0 +1,88 @@ +#include + +#include + +#include "catch2/catch.hpp" +#include "common/swaglog.h" +#include "common/util.h" +#include "common/version.h" +#include "system/hardware/hw.h" +#include "third_party/json11/json11.hpp" + +std::string daemon_name = "testy"; +std::string dongle_id = "test_dongle_id"; +int LINE_NO = 0; + +void log_thread(int thread_id, int msg_cnt) { + for (int i = 0; i < msg_cnt; ++i) { + LOGD("%d", thread_id); + LINE_NO = __LINE__ - 1; + usleep(1); + } +} + +void recv_log(int thread_cnt, int thread_msg_cnt) { + void *zctx = zmq_ctx_new(); + void *sock = zmq_socket(zctx, ZMQ_PULL); + zmq_bind(sock, Path::swaglog_ipc().c_str()); + std::vector thread_msgs(thread_cnt); + int total_count = 0; + + for (auto start = std::chrono::steady_clock::now(), now = start; + now < start + std::chrono::seconds{1} && total_count < (thread_cnt * thread_msg_cnt); + now = std::chrono::steady_clock::now()) { + char buf[4096] = {}; + if (zmq_recv(sock, buf, sizeof(buf), ZMQ_DONTWAIT) <= 0) { + if (errno == EAGAIN || errno == EINTR || errno == EFSM) continue; + break; + } + + REQUIRE(buf[0] == CLOUDLOG_DEBUG); + std::string err; + auto msg = json11::Json::parse(buf + 1, err); + REQUIRE(!msg.is_null()); + + REQUIRE(msg["levelnum"].int_value() == CLOUDLOG_DEBUG); + REQUIRE_THAT(msg["filename"].string_value(), Catch::Contains("test_swaglog.cc")); + REQUIRE(msg["funcname"].string_value() == "log_thread"); + REQUIRE(msg["lineno"].int_value() == LINE_NO); + + auto ctx = msg["ctx"]; + + REQUIRE(ctx["daemon"].string_value() == daemon_name); + REQUIRE(ctx["dongle_id"].string_value() == dongle_id); + REQUIRE(ctx["dirty"].bool_value() == true); + + REQUIRE(ctx["version"].string_value() == COMMA_VERSION); + + std::string device = Hardware::get_name(); + REQUIRE(ctx["device"].string_value() == device); + + int thread_id = atoi(msg["msg"].string_value().c_str()); + REQUIRE((thread_id >= 0 && thread_id < thread_cnt)); + thread_msgs[thread_id]++; + total_count++; + } + for (int i = 0; i < thread_cnt; ++i) { + INFO("thread :" << i); + REQUIRE(thread_msgs[i] == thread_msg_cnt); + } + zmq_close(sock); + zmq_ctx_destroy(zctx); +} + +TEST_CASE("swaglog") { + setenv("MANAGER_DAEMON", daemon_name.c_str(), 1); + setenv("DONGLE_ID", dongle_id.c_str(), 1); + setenv("dirty", "1", 1); + const int thread_cnt = 5; + const int thread_msg_cnt = 100; + + std::vector log_threads; + for (int i = 0; i < thread_cnt; ++i) { + log_threads.push_back(std::thread(log_thread, i, thread_msg_cnt)); + } + for (auto &t : log_threads) t.join(); + + recv_log(thread_cnt, thread_msg_cnt); +} diff --git a/common/tests/test_util.cc b/common/tests/test_util.cc new file mode 100644 index 0000000..de87fa3 --- /dev/null +++ b/common/tests/test_util.cc @@ -0,0 +1,147 @@ + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "catch2/catch.hpp" +#include "common/util.h" + +std::string random_bytes(int size) { + std::random_device rd; + std::independent_bits_engine rbe(rd()); + std::string bytes(size + 1, '\0'); + std::generate(bytes.begin(), bytes.end(), std::ref(rbe)); + return bytes; +} + +TEST_CASE("util::read_file") { + SECTION("read /proc/version") { + std::string ret = util::read_file("/proc/version"); + REQUIRE(ret.find("Linux version") != std::string::npos); + } + SECTION("read from sysfs") { + std::string ret = util::read_file("/sys/power/wakeup_count"); + REQUIRE(!ret.empty()); + } + SECTION("read file") { + char filename[] = "/tmp/test_read_XXXXXX"; + int fd = mkstemp(filename); + + REQUIRE(util::read_file(filename).empty()); + + std::string content = random_bytes(64 * 1024); + write(fd, content.c_str(), content.size()); + std::string ret = util::read_file(filename); + bool equal = (ret == content); + REQUIRE(equal); + close(fd); + } + SECTION("read directory") { + REQUIRE(util::read_file(".").empty()); + } + SECTION("read non-existent file") { + std::string ret = util::read_file("does_not_exist"); + REQUIRE(ret.empty()); + } + SECTION("read non-permission") { + REQUIRE(util::read_file("/proc/kmsg").empty()); + } +} + +TEST_CASE("util::file_exists") { + char filename[] = "/tmp/test_file_exists_XXXXXX"; + int fd = mkstemp(filename); + REQUIRE(fd != -1); + close(fd); + + SECTION("existent file") { + REQUIRE(util::file_exists(filename)); + REQUIRE(util::file_exists("/tmp")); + } + SECTION("nonexistent file") { + std::string fn = filename; + REQUIRE(!util::file_exists(fn + "/nonexistent")); + } + SECTION("file has no access permissions") { + std::string fn = "/proc/kmsg"; + std::ifstream f(fn); + REQUIRE(f.good() == false); + REQUIRE(util::file_exists(fn)); + } + ::remove(filename); +} + +TEST_CASE("util::read_files_in_dir") { + char tmp_path[] = "/tmp/test_XXXXXX"; + const std::string test_path = mkdtemp(tmp_path); + const std::string files[] = {".test1", "'test2'", "test3"}; + for (auto fn : files) { + std::ofstream{test_path + "/" + fn} << fn; + } + mkdir((test_path + "/dir").c_str(), 0777); + + std::map result = util::read_files_in_dir(test_path); + REQUIRE(result.find("dir") == result.end()); + REQUIRE(result.size() == std::size(files)); + for (auto& [k, v] : result) { + REQUIRE(k == v); + } +} + + +TEST_CASE("util::safe_fwrite") { + char filename[] = "/tmp/XXXXXX"; + int fd = mkstemp(filename); + close(fd); + std::string dat = random_bytes(1024 * 1024); + + FILE *f = util::safe_fopen(filename, "wb"); + REQUIRE(f != nullptr); + size_t size = util::safe_fwrite(dat.data(), 1, dat.size(), f); + REQUIRE(size == dat.size()); + int ret = util::safe_fflush(f); + REQUIRE(ret == 0); + ret = fclose(f); + REQUIRE(ret == 0); + bool equal = (dat == util::read_file(filename)); + REQUIRE(equal); +} + +TEST_CASE("util::create_directories") { + system("rm /tmp/test_create_directories -rf"); + std::string dir = "/tmp/test_create_directories/a/b/c/d/e/f"; + + auto check_dir_permissions = [](const std::string &dir, mode_t mode) -> bool { + struct stat st = {}; + return stat(dir.c_str(), &st) == 0 && (st.st_mode & S_IFMT) == S_IFDIR && (st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) == mode; + }; + + SECTION("create_directories") { + REQUIRE(util::create_directories(dir, 0755)); + REQUIRE(check_dir_permissions(dir, 0755)); + } + SECTION("dir already exists") { + REQUIRE(util::create_directories(dir, 0755)); + REQUIRE(util::create_directories(dir, 0755)); + } + SECTION("a file exists with the same name") { + REQUIRE(util::create_directories(dir, 0755)); + int f = open((dir + "/file").c_str(), O_RDWR | O_CREAT); + REQUIRE(f != -1); + close(f); + REQUIRE(util::create_directories(dir + "/file", 0755) == false); + REQUIRE(util::create_directories(dir + "/file/1/2/3", 0755) == false); + } + SECTION("end with slashes") { + REQUIRE(util::create_directories(dir + "/", 0755)); + } + SECTION("empty") { + REQUIRE(util::create_directories("", 0755) == false); + } +} diff --git a/common/time.py b/common/time.py index f2e49eb..9078a14 100644 --- a/common/time.py +++ b/common/time.py @@ -1,6 +1,6 @@ import datetime -MIN_DATE = datetime.datetime(year=2024, month=1, day=28) +MIN_DATE = datetime.datetime(year=2024, month=3, day=1) def system_time_valid(): return datetime.datetime.now() > MIN_DATE diff --git a/common/timing.h b/common/timing.h new file mode 100644 index 0000000..83f55e0 --- /dev/null +++ b/common/timing.h @@ -0,0 +1,51 @@ +#pragma once + +#include +#include + +#ifdef __APPLE__ +#define CLOCK_BOOTTIME CLOCK_MONOTONIC +#endif + +static inline uint64_t nanos_since_boot() { + struct timespec t; + clock_gettime(CLOCK_BOOTTIME, &t); + return t.tv_sec * 1000000000ULL + t.tv_nsec; +} + +static inline double millis_since_boot() { + struct timespec t; + clock_gettime(CLOCK_BOOTTIME, &t); + return t.tv_sec * 1000.0 + t.tv_nsec * 1e-6; +} + +static inline double seconds_since_boot() { + struct timespec t; + clock_gettime(CLOCK_BOOTTIME, &t); + return (double)t.tv_sec + t.tv_nsec * 1e-9; +} + +static inline uint64_t nanos_since_epoch() { + struct timespec t; + clock_gettime(CLOCK_REALTIME, &t); + return t.tv_sec * 1000000000ULL + t.tv_nsec; +} + +static inline double seconds_since_epoch() { + struct timespec t; + clock_gettime(CLOCK_REALTIME, &t); + return (double)t.tv_sec + t.tv_nsec * 1e-9; +} + +// you probably should use nanos_since_boot instead +static inline uint64_t nanos_monotonic() { + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + return t.tv_sec * 1000000000ULL + t.tv_nsec; +} + +static inline uint64_t nanos_monotonic_raw() { + struct timespec t; + clock_gettime(CLOCK_MONOTONIC_RAW, &t); + return t.tv_sec * 1000000000ULL + t.tv_nsec; +} diff --git a/common/transformations/.gitignore b/common/transformations/.gitignore new file mode 100644 index 0000000..a67290f --- /dev/null +++ b/common/transformations/.gitignore @@ -0,0 +1,2 @@ +transformations +transformations.cpp diff --git a/common/transformations/README.md b/common/transformations/README.md new file mode 100644 index 0000000..42a060d --- /dev/null +++ b/common/transformations/README.md @@ -0,0 +1,70 @@ + +Reference Frames +------ +Many reference frames are used throughout. This +folder contains all helper functions needed to +transform between them. Generally this is done +by generating a rotation matrix and multiplying. + + +| Name | [x, y, z] | Units | Notes | +| :-------------: |:-------------:| :-----:| :----: | +| Geodetic | [Latitude, Longitude, Altitude] | geodetic coordinates | Sometimes used as [lon, lat, alt], avoid this frame. | +| ECEF | [x, y, z] | meters | We use **ITRF14 (IGS14)**, NOT NAD83.
    This is the global Mesh3D frame. | +| NED | [North, East, Down] | meters | Relative to earth's surface, useful for visualizing. | +| Device | [Forward, Right, Down] | meters | This is the Mesh3D local frame.
    Relative to camera, **not imu.**
    ![img](http://upload.wikimedia.org/wikipedia/commons/thumb/2/2f/RPY_angles_of_airplanes.png/440px-RPY_angles_of_airplanes.png)| +| Calibrated | [Forward, Right, Down] | meters | This is the frame the model outputs are in.
    More details below.
    | +| Car | [Forward, Right, Down] | meters | This is useful for estimating position of points on the road.
    More details below.
    | +| View | [Right, Down, Forward] | meters | Like device frame, but according to camera conventions. | +| Camera | [u, v, focal] | pixels | Like view frame, but 2d on the camera image.| +| Normalized Camera | [u / focal, v / focal, 1] | / | | +| Model | [u, v, focal] | pixels | The sampled rectangle of the full camera frame the model uses. | +| Normalized Model | [u / focal, v / focal, 1] | / | | + + + + +Orientation Conventions +------ +Quaternions, rotation matrices and euler angles are three +equivalent representations of orientation and all three are +used throughout the code base. + +For euler angles the preferred convention is [roll, pitch, yaw] +which corresponds to rotations around the [x, y, z] axes. All +euler angles should always be in radians or radians/s unless +for plotting or display purposes. For quaternions the hamilton +notations is preferred which is [qw, qx, qy, qz]. All quaternions +should always be normalized with a strictly positive qw. **These +quaternions are a unique representation of orientation whereas euler angles +or rotation matrices are not.** + +To rotate from one frame into another with euler angles the +convention is to rotate around roll, then pitch and then yaw, +while rotating around the rotated axes, not the original axes. + + +Car frame +------ +Device frame is aligned with the road-facing camera used by openpilot. However, when controlling the vehicle it is helpful to think in a reference frame aligned with the vehicle. These two reference frames can be different. + +The orientation of car frame is defined to be aligned with the car's direction of travel and the road plane when the vehicle is driving on a flat road and not turning. The origin of car frame is defined to be directly below device frame (in car frame), such that it is on the road plane. The position and orientation of this frame is not necessarily always aligned with the direction of travel or the road plane due to suspension movements and other effects. + + +Calibrated frame +------ +It is helpful for openpilot's driving model to take in images that look similar when mounted differently in different cars. To achieve this we "calibrate" the images by transforming it into calibrated frame. Calibrated frame is defined to be aligned with car frame in pitch and yaw, and aligned with device frame in roll. It also has the same origin as device frame. + + +Example +------ +To transform global Mesh3D positions and orientations (positions_ecef, quats_ecef) into the local frame described by the +first position and orientation from Mesh3D one would do: +``` +ecef_from_local = rot_from_quat(quats_ecef[0]) +local_from_ecef = ecef_from_local.T +positions_local = np.einsum('ij,kj->ki', local_from_ecef, postions_ecef - positions_ecef[0]) +rotations_global = rot_from_quat(quats_ecef) +rotations_local = np.einsum('ij,kjl->kil', local_from_ecef, rotations_global) +eulers_local = euler_from_rot(rotations_local) +``` diff --git a/common/transformations/SConscript b/common/transformations/SConscript new file mode 100644 index 0000000..4ac73a1 --- /dev/null +++ b/common/transformations/SConscript @@ -0,0 +1,5 @@ +Import('env', 'envCython') + +transformations = env.Library('transformations', ['orientation.cc', 'coordinates.cc']) +transformations_python = envCython.Program('transformations.so', 'transformations.pyx') +Export('transformations', 'transformations_python') diff --git a/common/transformations/camera.py b/common/transformations/camera.py index c643cb5..dc3ca5f 100644 --- a/common/transformations/camera.py +++ b/common/transformations/camera.py @@ -1,55 +1,74 @@ +import itertools import numpy as np +from dataclasses import dataclass import openpilot.common.transformations.orientation as orient ## -- hardcoded hardware params -- -eon_f_focal_length = 910.0 -eon_d_focal_length = 650.0 -tici_f_focal_length = 2648.0 -tici_e_focal_length = tici_d_focal_length = 567.0 # probably wrong? magnification is not consistent across frame +@dataclass(frozen=True) +class CameraConfig: + width: int + height: int + focal_length: float -eon_f_frame_size = (1164, 874) -eon_d_frame_size = (816, 612) -tici_f_frame_size = tici_e_frame_size = tici_d_frame_size = (1928, 1208) + @property + def size(self): + return (self.width, self.height) -# aka 'K' aka camera_frame_from_view_frame -eon_fcam_intrinsics = np.array([ - [eon_f_focal_length, 0.0, float(eon_f_frame_size[0])/2], - [0.0, eon_f_focal_length, float(eon_f_frame_size[1])/2], - [0.0, 0.0, 1.0]]) -eon_intrinsics = eon_fcam_intrinsics # xx + @property + def intrinsics(self): + # aka 'K' aka camera_frame_from_view_frame + return np.array([ + [self.focal_length, 0.0, float(self.width)/2], + [0.0, self.focal_length, float(self.height)/2], + [0.0, 0.0, 1.0] + ]) -eon_dcam_intrinsics = np.array([ - [eon_d_focal_length, 0.0, float(eon_d_frame_size[0])/2], - [0.0, eon_d_focal_length, float(eon_d_frame_size[1])/2], - [0.0, 0.0, 1.0]]) + @property + def intrinsics_inv(self): + # aka 'K_inv' aka view_frame_from_camera_frame + return np.linalg.inv(self.intrinsics) -tici_fcam_intrinsics = np.array([ - [tici_f_focal_length, 0.0, float(tici_f_frame_size[0])/2], - [0.0, tici_f_focal_length, float(tici_f_frame_size[1])/2], - [0.0, 0.0, 1.0]]) +@dataclass(frozen=True) +class _NoneCameraConfig(CameraConfig): + width: int = 0 + height: int = 0 + focal_length: float = 0 -tici_dcam_intrinsics = np.array([ - [tici_d_focal_length, 0.0, float(tici_d_frame_size[0])/2], - [0.0, tici_d_focal_length, float(tici_d_frame_size[1])/2], - [0.0, 0.0, 1.0]]) +@dataclass(frozen=True) +class DeviceCameraConfig: + fcam: CameraConfig + dcam: CameraConfig + ecam: CameraConfig -tici_ecam_intrinsics = tici_dcam_intrinsics + def all_cams(self): + for cam in ['fcam', 'dcam', 'ecam']: + if not isinstance(getattr(self, cam), _NoneCameraConfig): + yield cam, getattr(self, cam) -# aka 'K_inv' aka view_frame_from_camera_frame -eon_fcam_intrinsics_inv = np.linalg.inv(eon_fcam_intrinsics) -eon_intrinsics_inv = eon_fcam_intrinsics_inv # xx +_ar_ox_fisheye = CameraConfig(1928, 1208, 567.0) # focal length probably wrong? magnification is not consistent across frame +_os_fisheye = CameraConfig(2688, 1520, 567.0 / 2 * 3) +_ar_ox_config = DeviceCameraConfig(CameraConfig(1928, 1208, 2648.0), _ar_ox_fisheye, _ar_ox_fisheye) +_os_config = DeviceCameraConfig(CameraConfig(2688, 1520, 2648.0 * 2 / 3), _os_fisheye, _os_fisheye) +_neo_config = DeviceCameraConfig(CameraConfig(1164, 874, 910.0), CameraConfig(816, 612, 650.0), _NoneCameraConfig()) -tici_fcam_intrinsics_inv = np.linalg.inv(tici_fcam_intrinsics) -tici_ecam_intrinsics_inv = np.linalg.inv(tici_ecam_intrinsics) +DEVICE_CAMERAS = { + # A "device camera" is defined by a device type and sensor + # sensor type was never set on eon/neo/two + ("neo", "unknown"): _neo_config, + # unknown here is AR0231, field was added with OX03C10 support + ("tici", "unknown"): _ar_ox_config, -FULL_FRAME_SIZE = tici_f_frame_size -FOCAL = tici_f_focal_length -fcam_intrinsics = tici_fcam_intrinsics - -W, H = FULL_FRAME_SIZE[0], FULL_FRAME_SIZE[1] + # before deviceState.deviceType was set, assume tici AR config + ("unknown", "ar0231"): _ar_ox_config, + ("unknown", "ox03c10"): _ar_ox_config, + # simulator (emulates a tici) + ("pc", "unknown"): _ar_ox_config, +} +prods = itertools.product(('tici', 'tizi', 'mici'), (('ar0231', _ar_ox_config), ('ox03c10', _ar_ox_config), ('os04c10', _os_config))) +DEVICE_CAMERAS.update({(d, c[0]): c[1] for d, c in prods}) # device/mesh : x->forward, y-> right, z->down # view : x->right, y->down, z->forward @@ -93,7 +112,7 @@ def roll_from_ke(m): -(m[0, 0] - m[0, 1] * m[2, 0] / m[2, 1])) -def normalize(img_pts, intrinsics=fcam_intrinsics): +def normalize(img_pts, intrinsics): # normalizes image coordinates # accepts single pt or array of pts intrinsics_inv = np.linalg.inv(intrinsics) @@ -106,7 +125,7 @@ def normalize(img_pts, intrinsics=fcam_intrinsics): return img_pts_normalized[:, :2].reshape(input_shape) -def denormalize(img_pts, intrinsics=fcam_intrinsics, width=np.inf, height=np.inf): +def denormalize(img_pts, intrinsics, width=np.inf, height=np.inf): # denormalizes image coordinates # accepts single pt or array of pts img_pts = np.array(img_pts) @@ -123,7 +142,7 @@ def denormalize(img_pts, intrinsics=fcam_intrinsics, width=np.inf, height=np.inf return img_pts_denormalized[:, :2].reshape(input_shape) -def get_calib_from_vp(vp, intrinsics=fcam_intrinsics): +def get_calib_from_vp(vp, intrinsics): vp_norm = normalize(vp, intrinsics) yaw_calib = np.arctan(vp_norm[0]) pitch_calib = -np.arctan(vp_norm[1]*np.cos(yaw_calib)) diff --git a/common/transformations/coordinates.cc b/common/transformations/coordinates.cc new file mode 100644 index 0000000..5b00b53 --- /dev/null +++ b/common/transformations/coordinates.cc @@ -0,0 +1,100 @@ +#define _USE_MATH_DEFINES + +#include "common/transformations/coordinates.hpp" + +#include +#include +#include + +double a = 6378137; // lgtm [cpp/short-global-name] +double b = 6356752.3142; // lgtm [cpp/short-global-name] +double esq = 6.69437999014 * 0.001; // lgtm [cpp/short-global-name] +double e1sq = 6.73949674228 * 0.001; + + +static Geodetic to_degrees(Geodetic geodetic){ + geodetic.lat = RAD2DEG(geodetic.lat); + geodetic.lon = RAD2DEG(geodetic.lon); + return geodetic; +} + +static Geodetic to_radians(Geodetic geodetic){ + geodetic.lat = DEG2RAD(geodetic.lat); + geodetic.lon = DEG2RAD(geodetic.lon); + return geodetic; +} + + +ECEF geodetic2ecef(Geodetic g){ + g = to_radians(g); + double xi = sqrt(1.0 - esq * pow(sin(g.lat), 2)); + double x = (a / xi + g.alt) * cos(g.lat) * cos(g.lon); + double y = (a / xi + g.alt) * cos(g.lat) * sin(g.lon); + double z = (a / xi * (1.0 - esq) + g.alt) * sin(g.lat); + return {x, y, z}; +} + +Geodetic ecef2geodetic(ECEF e){ + // Convert from ECEF to geodetic using Ferrari's methods + // https://en.wikipedia.org/wiki/Geographic_coordinate_conversion#Ferrari.27s_solution + double x = e.x; + double y = e.y; + double z = e.z; + + double r = sqrt(x * x + y * y); + double Esq = a * a - b * b; + double F = 54 * b * b * z * z; + double G = r * r + (1 - esq) * z * z - esq * Esq; + double C = (esq * esq * F * r * r) / (pow(G, 3)); + double S = cbrt(1 + C + sqrt(C * C + 2 * C)); + double P = F / (3 * pow((S + 1 / S + 1), 2) * G * G); + double Q = sqrt(1 + 2 * esq * esq * P); + double r_0 = -(P * esq * r) / (1 + Q) + sqrt(0.5 * a * a*(1 + 1.0 / Q) - P * (1 - esq) * z * z / (Q * (1 + Q)) - 0.5 * P * r * r); + double U = sqrt(pow((r - esq * r_0), 2) + z * z); + double V = sqrt(pow((r - esq * r_0), 2) + (1 - esq) * z * z); + double Z_0 = b * b * z / (a * V); + double h = U * (1 - b * b / (a * V)); + + double lat = atan((z + e1sq * Z_0) / r); + double lon = atan2(y, x); + + return to_degrees({lat, lon, h}); +} + +LocalCoord::LocalCoord(Geodetic g, ECEF e){ + init_ecef << e.x, e.y, e.z; + + g = to_radians(g); + + ned2ecef_matrix << + -sin(g.lat)*cos(g.lon), -sin(g.lon), -cos(g.lat)*cos(g.lon), + -sin(g.lat)*sin(g.lon), cos(g.lon), -cos(g.lat)*sin(g.lon), + cos(g.lat), 0, -sin(g.lat); + ecef2ned_matrix = ned2ecef_matrix.transpose(); +} + +NED LocalCoord::ecef2ned(ECEF e) { + Eigen::Vector3d ecef; + ecef << e.x, e.y, e.z; + + Eigen::Vector3d ned = (ecef2ned_matrix * (ecef - init_ecef)); + return {ned[0], ned[1], ned[2]}; +} + +ECEF LocalCoord::ned2ecef(NED n) { + Eigen::Vector3d ned; + ned << n.n, n.e, n.d; + + Eigen::Vector3d ecef = (ned2ecef_matrix * ned) + init_ecef; + return {ecef[0], ecef[1], ecef[2]}; +} + +NED LocalCoord::geodetic2ned(Geodetic g) { + ECEF e = ::geodetic2ecef(g); + return ecef2ned(e); +} + +Geodetic LocalCoord::ned2geodetic(NED n){ + ECEF e = ned2ecef(n); + return ::ecef2geodetic(e); +} diff --git a/common/transformations/model.py b/common/transformations/model.py index 7e40767..aaa12d7 100644 --- a/common/transformations/model.py +++ b/common/transformations/model.py @@ -1,19 +1,11 @@ import numpy as np from openpilot.common.transformations.orientation import rot_from_euler -from openpilot.common.transformations.camera import ( - FULL_FRAME_SIZE, get_view_frame_from_calib_frame, view_frame_from_device_frame, - eon_fcam_intrinsics, tici_ecam_intrinsics, tici_fcam_intrinsics) +from openpilot.common.transformations.camera import get_view_frame_from_calib_frame, view_frame_from_device_frame # segnet SEGNET_SIZE = (512, 384) -def get_segnet_frame_from_camera_frame(segnet_size=SEGNET_SIZE, full_frame_size=FULL_FRAME_SIZE): - return np.array([[float(segnet_size[0]) / full_frame_size[0], 0.0], - [0.0, float(segnet_size[1]) / full_frame_size[1]]]) -segnet_frame_from_camera_frame = get_segnet_frame_from_camera_frame() # xx - - # MED model MEDMODEL_INPUT_SIZE = (512, 256) MEDMODEL_YUV_SIZE = (MEDMODEL_INPUT_SIZE[0], MEDMODEL_INPUT_SIZE[1] * 3 // 2) @@ -63,16 +55,9 @@ calib_from_medmodel = np.linalg.inv(medmodel_frame_from_calib_frame[:, :3]) calib_from_sbigmodel = np.linalg.inv(sbigmodel_frame_from_calib_frame[:, :3]) # This function is verified to give similar results to xx.uncommon.utils.transform_img -def get_warp_matrix(device_from_calib_euler: np.ndarray, wide_camera: bool = False, bigmodel_frame: bool = False, tici: bool = True) -> np.ndarray: - if tici and wide_camera: - cam_intrinsics = tici_ecam_intrinsics - elif tici: - cam_intrinsics = tici_fcam_intrinsics - else: - cam_intrinsics = eon_fcam_intrinsics - +def get_warp_matrix(device_from_calib_euler: np.ndarray, intrinsics: np.ndarray, bigmodel_frame: bool = False) -> np.ndarray: calib_from_model = calib_from_sbigmodel if bigmodel_frame else calib_from_medmodel device_from_calib = rot_from_euler(device_from_calib_euler) - camera_from_calib = cam_intrinsics @ view_frame_from_device_frame @ device_from_calib + camera_from_calib = intrinsics @ view_frame_from_device_frame @ device_from_calib warp_matrix: np.ndarray = camera_from_calib @ calib_from_model return warp_matrix diff --git a/common/transformations/orientation.cc b/common/transformations/orientation.cc new file mode 100644 index 0000000..00888c3 --- /dev/null +++ b/common/transformations/orientation.cc @@ -0,0 +1,144 @@ +#define _USE_MATH_DEFINES + +#include +#include +#include + +#include "common/transformations/orientation.hpp" +#include "common/transformations/coordinates.hpp" + +Eigen::Quaterniond ensure_unique(Eigen::Quaterniond quat){ + if (quat.w() > 0){ + return quat; + } else { + return Eigen::Quaterniond(-quat.w(), -quat.x(), -quat.y(), -quat.z()); + } +} + +Eigen::Quaterniond euler2quat(Eigen::Vector3d euler){ + Eigen::Quaterniond q; + + q = Eigen::AngleAxisd(euler(2), Eigen::Vector3d::UnitZ()) + * Eigen::AngleAxisd(euler(1), Eigen::Vector3d::UnitY()) + * Eigen::AngleAxisd(euler(0), Eigen::Vector3d::UnitX()); + return ensure_unique(q); +} + + +Eigen::Vector3d quat2euler(Eigen::Quaterniond quat){ + // TODO: switch to eigen implementation if the range of the Euler angles doesn't matter anymore + // Eigen::Vector3d euler = quat.toRotationMatrix().eulerAngles(2, 1, 0); + // return {euler(2), euler(1), euler(0)}; + double gamma = atan2(2 * (quat.w() * quat.x() + quat.y() * quat.z()), 1 - 2 * (quat.x()*quat.x() + quat.y()*quat.y())); + double asin_arg_clipped = std::clamp(2 * (quat.w() * quat.y() - quat.z() * quat.x()), -1.0, 1.0); + double theta = asin(asin_arg_clipped); + double psi = atan2(2 * (quat.w() * quat.z() + quat.x() * quat.y()), 1 - 2 * (quat.y()*quat.y() + quat.z()*quat.z())); + return {gamma, theta, psi}; +} + +Eigen::Matrix3d quat2rot(Eigen::Quaterniond quat){ + return quat.toRotationMatrix(); +} + +Eigen::Quaterniond rot2quat(const Eigen::Matrix3d &rot){ + return ensure_unique(Eigen::Quaterniond(rot)); +} + +Eigen::Matrix3d euler2rot(Eigen::Vector3d euler){ + return quat2rot(euler2quat(euler)); +} + +Eigen::Vector3d rot2euler(const Eigen::Matrix3d &rot){ + return quat2euler(rot2quat(rot)); +} + +Eigen::Matrix3d rot_matrix(double roll, double pitch, double yaw){ + return euler2rot({roll, pitch, yaw}); +} + +Eigen::Matrix3d rot(Eigen::Vector3d axis, double angle){ + Eigen::Quaterniond q; + q = Eigen::AngleAxisd(angle, axis); + return q.toRotationMatrix(); +} + + +Eigen::Vector3d ecef_euler_from_ned(ECEF ecef_init, Eigen::Vector3d ned_pose) { + /* + Using Rotations to Build Aerospace Coordinate Systems + Don Koks + https://apps.dtic.mil/dtic/tr/fulltext/u2/a484864.pdf + */ + LocalCoord converter = LocalCoord(ecef_init); + Eigen::Vector3d zero = ecef_init.to_vector(); + + Eigen::Vector3d x0 = converter.ned2ecef({1, 0, 0}).to_vector() - zero; + Eigen::Vector3d y0 = converter.ned2ecef({0, 1, 0}).to_vector() - zero; + Eigen::Vector3d z0 = converter.ned2ecef({0, 0, 1}).to_vector() - zero; + + Eigen::Vector3d x1 = rot(z0, ned_pose(2)) * x0; + Eigen::Vector3d y1 = rot(z0, ned_pose(2)) * y0; + Eigen::Vector3d z1 = rot(z0, ned_pose(2)) * z0; + + Eigen::Vector3d x2 = rot(y1, ned_pose(1)) * x1; + Eigen::Vector3d y2 = rot(y1, ned_pose(1)) * y1; + Eigen::Vector3d z2 = rot(y1, ned_pose(1)) * z1; + + Eigen::Vector3d x3 = rot(x2, ned_pose(0)) * x2; + Eigen::Vector3d y3 = rot(x2, ned_pose(0)) * y2; + + + x0 = Eigen::Vector3d(1, 0, 0); + y0 = Eigen::Vector3d(0, 1, 0); + z0 = Eigen::Vector3d(0, 0, 1); + + double psi = atan2(x3.dot(y0), x3.dot(x0)); + double theta = atan2(-x3.dot(z0), sqrt(pow(x3.dot(x0), 2) + pow(x3.dot(y0), 2))); + + y2 = rot(z0, psi) * y0; + z2 = rot(y2, theta) * z0; + + double phi = atan2(y3.dot(z2), y3.dot(y2)); + + return {phi, theta, psi}; +} + +Eigen::Vector3d ned_euler_from_ecef(ECEF ecef_init, Eigen::Vector3d ecef_pose){ + /* + Using Rotations to Build Aerospace Coordinate Systems + Don Koks + https://apps.dtic.mil/dtic/tr/fulltext/u2/a484864.pdf + */ + LocalCoord converter = LocalCoord(ecef_init); + + Eigen::Vector3d x0 = Eigen::Vector3d(1, 0, 0); + Eigen::Vector3d y0 = Eigen::Vector3d(0, 1, 0); + Eigen::Vector3d z0 = Eigen::Vector3d(0, 0, 1); + + Eigen::Vector3d x1 = rot(z0, ecef_pose(2)) * x0; + Eigen::Vector3d y1 = rot(z0, ecef_pose(2)) * y0; + Eigen::Vector3d z1 = rot(z0, ecef_pose(2)) * z0; + + Eigen::Vector3d x2 = rot(y1, ecef_pose(1)) * x1; + Eigen::Vector3d y2 = rot(y1, ecef_pose(1)) * y1; + Eigen::Vector3d z2 = rot(y1, ecef_pose(1)) * z1; + + Eigen::Vector3d x3 = rot(x2, ecef_pose(0)) * x2; + Eigen::Vector3d y3 = rot(x2, ecef_pose(0)) * y2; + + Eigen::Vector3d zero = ecef_init.to_vector(); + x0 = converter.ned2ecef({1, 0, 0}).to_vector() - zero; + y0 = converter.ned2ecef({0, 1, 0}).to_vector() - zero; + z0 = converter.ned2ecef({0, 0, 1}).to_vector() - zero; + + double psi = atan2(x3.dot(y0), x3.dot(x0)); + double theta = atan2(-x3.dot(z0), sqrt(pow(x3.dot(x0), 2) + pow(x3.dot(y0), 2))); + + y2 = rot(z0, psi) * y0; + z2 = rot(y2, theta) * z0; + + double phi = atan2(y3.dot(z2), y3.dot(y2)); + + return {phi, theta, psi}; +} + diff --git a/common/transformations/orientation.py b/common/transformations/orientation.py index ce43787..86e6a6c 100644 --- a/common/transformations/orientation.py +++ b/common/transformations/orientation.py @@ -1,5 +1,5 @@ import numpy as np -from typing import Callable +from collections.abc import Callable from openpilot.common.transformations.transformations import (ecef_euler_from_ned_single, euler2quat_single, diff --git a/common/transformations/tests/__init__.py b/common/transformations/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/common/transformations/tests/test_coordinates.py b/common/transformations/tests/test_coordinates.py new file mode 100644 index 0000000..7ae7940 --- /dev/null +++ b/common/transformations/tests/test_coordinates.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 + +import numpy as np +import unittest + +import openpilot.common.transformations.coordinates as coord + +geodetic_positions = np.array([[37.7610403, -122.4778699, 115], + [27.4840915, -68.5867592, 2380], + [32.4916858, -113.652821, -6], + [15.1392514, 103.6976037, 24], + [24.2302229, 44.2835412, 1650]]) + +ecef_positions = np.array([[-2711076.55270557, -4259167.14692758, 3884579.87669935], + [ 2068042.69652729, -5273435.40316622, 2927004.89190746], + [-2160412.60461669, -4932588.89873832, 3406542.29652851], + [-1458247.92550567, 5983060.87496612, 1654984.6099885 ], + [ 4167239.10867871, 4064301.90363223, 2602234.6065749 ]]) + +ecef_positions_offset = np.array([[-2711004.46961115, -4259099.33540613, 3884605.16002147], + [ 2068074.30639499, -5273413.78835412, 2927012.48741131], + [-2160344.53748176, -4932586.20092211, 3406636.2962545 ], + [-1458211.98517094, 5983151.11161276, 1655077.02698447], + [ 4167271.20055269, 4064398.22619263, 2602238.95265847]]) + + +ned_offsets = np.array([[78.722153649976391, 24.396208657446344, 60.343017506838436], + [10.699003365155221, 37.319278617604269, 4.1084100025050407], + [95.282646251726959, 61.266689955574428, -25.376506058505054], + [68.535769283630003, -56.285970011848889, -100.54840137956515], + [-33.066609321880179, 46.549821994306861, -84.062540548335591]]) + +ecef_init_batch = np.array([2068042.69652729, -5273435.40316622, 2927004.89190746]) +ecef_positions_offset_batch = np.array([[ 2068089.41454771, -5273434.46829148, 2927074.04783672], + [ 2068103.31628647, -5273393.92275431, 2927102.08725987], + [ 2068108.49939636, -5273359.27047121, 2927045.07091581], + [ 2068075.12395611, -5273381.69432566, 2927041.08207992], + [ 2068060.72033399, -5273430.6061505, 2927094.54928305]]) + +ned_offsets_batch = np.array([[ 53.88103168, 43.83445935, -46.27488057], + [ 93.83378995, 71.57943024, -30.23113187], + [ 57.26725796, 89.05602684, 23.02265814], + [ 49.71775195, 49.79767572, 17.15351015], + [ 78.56272609, 18.53100158, -43.25290759]]) + + +class TestNED(unittest.TestCase): + def test_small_distances(self): + start_geodetic = np.array([33.8042184, -117.888593, 0.0]) + local_coord = coord.LocalCoord.from_geodetic(start_geodetic) + + start_ned = local_coord.geodetic2ned(start_geodetic) + np.testing.assert_array_equal(start_ned, np.zeros(3,)) + + west_geodetic = start_geodetic + [0, -0.0005, 0] + west_ned = local_coord.geodetic2ned(west_geodetic) + self.assertLess(np.abs(west_ned[0]), 1e-3) + self.assertLess(west_ned[1], 0) + + southwest_geodetic = start_geodetic + [-0.0005, -0.002, 0] + southwest_ned = local_coord.geodetic2ned(southwest_geodetic) + self.assertLess(southwest_ned[0], 0) + self.assertLess(southwest_ned[1], 0) + + def test_ecef_geodetic(self): + # testing single + np.testing.assert_allclose(ecef_positions[0], coord.geodetic2ecef(geodetic_positions[0]), rtol=1e-9) + np.testing.assert_allclose(geodetic_positions[0, :2], coord.ecef2geodetic(ecef_positions[0])[:2], rtol=1e-9) + np.testing.assert_allclose(geodetic_positions[0, 2], coord.ecef2geodetic(ecef_positions[0])[2], rtol=1e-9, atol=1e-4) + + np.testing.assert_allclose(geodetic_positions[:, :2], coord.ecef2geodetic(ecef_positions)[:, :2], rtol=1e-9) + np.testing.assert_allclose(geodetic_positions[:, 2], coord.ecef2geodetic(ecef_positions)[:, 2], rtol=1e-9, atol=1e-4) + np.testing.assert_allclose(ecef_positions, coord.geodetic2ecef(geodetic_positions), rtol=1e-9) + + + def test_ned(self): + for ecef_pos in ecef_positions: + converter = coord.LocalCoord.from_ecef(ecef_pos) + ecef_pos_moved = ecef_pos + [25, -25, 25] + ecef_pos_moved_double_converted = converter.ned2ecef(converter.ecef2ned(ecef_pos_moved)) + np.testing.assert_allclose(ecef_pos_moved, ecef_pos_moved_double_converted, rtol=1e-9) + + for geo_pos in geodetic_positions: + converter = coord.LocalCoord.from_geodetic(geo_pos) + geo_pos_moved = geo_pos + np.array([0, 0, 10]) + geo_pos_double_converted_moved = converter.ned2geodetic(converter.geodetic2ned(geo_pos) + np.array([0, 0, -10])) + np.testing.assert_allclose(geo_pos_moved[:2], geo_pos_double_converted_moved[:2], rtol=1e-9, atol=1e-6) + np.testing.assert_allclose(geo_pos_moved[2], geo_pos_double_converted_moved[2], rtol=1e-9, atol=1e-4) + + def test_ned_saved_results(self): + for i, ecef_pos in enumerate(ecef_positions): + converter = coord.LocalCoord.from_ecef(ecef_pos) + np.testing.assert_allclose(converter.ned2ecef(ned_offsets[i]), + ecef_positions_offset[i], + rtol=1e-9, atol=1e-4) + np.testing.assert_allclose(converter.ecef2ned(ecef_positions_offset[i]), + ned_offsets[i], + rtol=1e-9, atol=1e-4) + + def test_ned_batch(self): + converter = coord.LocalCoord.from_ecef(ecef_init_batch) + np.testing.assert_allclose(converter.ecef2ned(ecef_positions_offset_batch), + ned_offsets_batch, + rtol=1e-9, atol=1e-7) + np.testing.assert_allclose(converter.ned2ecef(ned_offsets_batch), + ecef_positions_offset_batch, + rtol=1e-9, atol=1e-7) +if __name__ == "__main__": + unittest.main() diff --git a/common/transformations/tests/test_orientation.py b/common/transformations/tests/test_orientation.py new file mode 100644 index 0000000..f77827d --- /dev/null +++ b/common/transformations/tests/test_orientation.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 + +import numpy as np +import unittest + +from openpilot.common.transformations.orientation import euler2quat, quat2euler, euler2rot, rot2euler, \ + rot2quat, quat2rot, \ + ned_euler_from_ecef + +eulers = np.array([[ 1.46520501, 2.78688383, 2.92780854], + [ 4.86909526, 3.60618161, 4.30648981], + [ 3.72175965, 2.68763705, 5.43895988], + [ 5.92306687, 5.69573614, 0.81100357], + [ 0.67838374, 5.02402037, 2.47106426]]) + +quats = np.array([[ 0.66855182, -0.71500939, 0.19539353, 0.06017818], + [ 0.43163717, 0.70013301, 0.28209145, 0.49389021], + [ 0.44121991, -0.08252646, 0.34257534, 0.82532207], + [ 0.88578382, -0.04515356, -0.32936046, 0.32383617], + [ 0.06578165, 0.61282835, 0.07126891, 0.78424163]]) + +ecef_positions = np.array([[-2711076.55270557, -4259167.14692758, 3884579.87669935], + [ 2068042.69652729, -5273435.40316622, 2927004.89190746], + [-2160412.60461669, -4932588.89873832, 3406542.29652851], + [-1458247.92550567, 5983060.87496612, 1654984.6099885 ], + [ 4167239.10867871, 4064301.90363223, 2602234.6065749 ]]) + +ned_eulers = np.array([[ 0.46806039, -0.4881889 , 1.65697808], + [-2.14525969, -0.36533066, 0.73813479], + [-1.39523364, -0.58540761, -1.77376356], + [-1.84220435, 0.61828016, -1.03310421], + [ 2.50450101, 0.36304151, 0.33136365]]) + + +class TestOrientation(unittest.TestCase): + def test_quat_euler(self): + for i, eul in enumerate(eulers): + np.testing.assert_allclose(quats[i], euler2quat(eul), rtol=1e-7) + np.testing.assert_allclose(quats[i], euler2quat(quat2euler(quats[i])), rtol=1e-6) + for i, eul in enumerate(eulers): + np.testing.assert_allclose(quats[i], euler2quat(list(eul)), rtol=1e-7) + np.testing.assert_allclose(quats[i], euler2quat(quat2euler(list(quats[i]))), rtol=1e-6) + np.testing.assert_allclose(quats, euler2quat(eulers), rtol=1e-7) + np.testing.assert_allclose(quats, euler2quat(quat2euler(quats)), rtol=1e-6) + + def test_rot_euler(self): + for eul in eulers: + np.testing.assert_allclose(euler2quat(eul), euler2quat(rot2euler(euler2rot(eul))), rtol=1e-7) + for eul in eulers: + np.testing.assert_allclose(euler2quat(eul), euler2quat(rot2euler(euler2rot(list(eul)))), rtol=1e-7) + np.testing.assert_allclose(euler2quat(eulers), euler2quat(rot2euler(euler2rot(eulers))), rtol=1e-7) + + def test_rot_quat(self): + for quat in quats: + np.testing.assert_allclose(quat, rot2quat(quat2rot(quat)), rtol=1e-7) + for quat in quats: + np.testing.assert_allclose(quat, rot2quat(quat2rot(list(quat))), rtol=1e-7) + np.testing.assert_allclose(quats, rot2quat(quat2rot(quats)), rtol=1e-7) + + def test_euler_ned(self): + for i in range(len(eulers)): + np.testing.assert_allclose(ned_eulers[i], ned_euler_from_ecef(ecef_positions[i], eulers[i]), rtol=1e-7) + #np.testing.assert_allclose(eulers[i], ecef_euler_from_ned(ecef_positions[i], ned_eulers[i]), rtol=1e-7) + # np.testing.assert_allclose(ned_eulers, ned_euler_from_ecef(ecef_positions, eulers), rtol=1e-7) + + +if __name__ == "__main__": + unittest.main() diff --git a/common/transformations/transformations.cpp b/common/transformations/transformations.cpp deleted file mode 100644 index 0eea8b0..0000000 --- a/common/transformations/transformations.cpp +++ /dev/null @@ -1,16660 +0,0 @@ -/* Generated by Cython 3.0.8 */ - -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [ - "common/transformations/coordinates.cc", - "common/transformations/coordinates.hpp", - "common/transformations/orientation.cc", - "common/transformations/orientation.hpp", - "openpilot/common/transformations/coordinates.cc", - "openpilot/common/transformations/coordinates.hpp", - "openpilot/common/transformations/orientation.cc", - "openpilot/common/transformations/orientation.hpp" - ], - "include_dirs": [ - "common/transformations", - "openpilot/common/transformations" - ], - "language": "c++", - "name": "common.transformations.transformations", - "sources": [ - "/data/openpilot/common/transformations/transformations.pyx" - ] - }, - "module_name": "common.transformations.transformations" -} -END: Cython Metadata */ - -#ifndef PY_SSIZE_T_CLEAN -#define PY_SSIZE_T_CLEAN -#endif /* PY_SSIZE_T_CLEAN */ -#if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif -#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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. -#else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x030008F0 -#define CYTHON_FUTURE_DIVISION 1 -#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_NOGIL 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 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #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_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 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 (PY_MAJOR_VERSION >= 3) - #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_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 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 0 - #endif -#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_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #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_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 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 (PY_MAJOR_VERSION >= 3) - #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_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #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 -#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_NOGIL 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_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 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 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 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 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #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 -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #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_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #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 -#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 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef 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 - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || 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 - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #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 - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #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) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(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 -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #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 -# 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 -#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)) - -#ifndef __cplusplus - #error "Cython files generated with the C++ option must be compiled with a C++ compiler." -#endif -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #else - #define CYTHON_INLINE inline - #endif -#endif -template -void __Pyx_call_destructor(T& x) { - x.~T(); -} -template -class __Pyx_FakeReference { - public: - __Pyx_FakeReference() : ptr(NULL) { } - __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } - T *operator->() { return ptr; } - T *operator&() { return ptr; } - operator T&() { return *ptr; } - template bool operator ==(const U& other) const { return *ptr == other; } - template bool operator !=(const U& other) const { return *ptr != other; } - template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } - template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } - private: - T *ptr; -}; - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #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) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE 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, "iiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOiOO", 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, "iiiiiiOOOOOOOiOO", 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; - } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE 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; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - 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, empty_bytes); - Py_DECREF(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 -#endif -#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 CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#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 -#if PY_VERSION_HEX <= 0x030700A3 || !defined(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 - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords -#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_MAJOR_VERSION >= 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) { -#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 < 0x030900B1 - #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_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_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() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -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; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && 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 PY_MAJOR_VERSION >= 3 && (!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) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#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 CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #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)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #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_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #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 -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#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) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef 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_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#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 PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#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_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_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #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) -#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_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #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) -#endif -#if PY_VERSION_HEX >= 0x030d00A1 - #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 PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_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 - -#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; } -#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 - #define __PYX_EXTERN_C extern "C++" -#endif - -#define __PYX_HAVE__common__transformations__transformations -#define __PYX_HAVE_API__common__transformations__transformations -/* Early includes */ -#include "orientation.cc" -#include "orientation.hpp" -#include "coordinates.cc" -#include "coordinates.hpp" -#include -#include - - /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ - -#include "numpy/arrayobject.h" -#include "numpy/ndarrayobject.h" -#include "numpy/ndarraytypes.h" -#include "numpy/arrayscalars.h" -#include "numpy/ufuncobject.h" -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#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 PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#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_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_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) -{ - const wchar_t *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#else -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#endif -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -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_IntOrLong(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_PyInt_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)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#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 PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#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__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* Header.proto */ -#if !defined(CYTHON_CCOMPLEX) - #if defined(__cplusplus) - #define CYTHON_CCOMPLEX 1 - #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) - #define CYTHON_CCOMPLEX 1 - #else - #define CYTHON_CCOMPLEX 0 - #endif -#endif -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - #include - #else - #include - #endif -#endif -#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) - #undef _Complex_I - #define _Complex_I 1.0fj -#endif - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "common/transformations/transformations.pyx", - "", - "__init__.cython-30.pxd", - "type.pxd", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - -/* BufferFormatStructs.proto */ -struct __Pyx_StructField_; -#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) -typedef struct { - const char* name; - struct __Pyx_StructField_* fields; - size_t size; - size_t arraysize[8]; - int ndim; - char typegroup; - char is_unsigned; - int flags; -} __Pyx_TypeInfo; -typedef struct __Pyx_StructField_ { - __Pyx_TypeInfo* type; - const char* name; - size_t offset; -} __Pyx_StructField; -typedef struct { - __Pyx_StructField* field; - size_t parent_offset; -} __Pyx_BufFmt_StackElem; -typedef struct { - __Pyx_StructField root; - __Pyx_BufFmt_StackElem* head; - size_t fmt_offset; - size_t new_count, enc_count; - size_t struct_alignment; - int is_complex; - char enc_type; - char new_packmode; - char enc_packmode; - char is_valid_array; -} __Pyx_BufFmt_Context; - -/* #### Code section: numeric_typedefs ### */ - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":730 - * # in Cython to enable them only on the right systems. - * - * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t - */ -typedef npy_int8 __pyx_t_5numpy_int8_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":731 - * - * ctypedef npy_int8 int8_t - * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< - * ctypedef npy_int32 int32_t - * ctypedef npy_int64 int64_t - */ -typedef npy_int16 __pyx_t_5numpy_int16_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":732 - * ctypedef npy_int8 int8_t - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< - * ctypedef npy_int64 int64_t - * #ctypedef npy_int96 int96_t - */ -typedef npy_int32 __pyx_t_5numpy_int32_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":733 - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t - * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< - * #ctypedef npy_int96 int96_t - * #ctypedef npy_int128 int128_t - */ -typedef npy_int64 __pyx_t_5numpy_int64_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":737 - * #ctypedef npy_int128 int128_t - * - * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t - */ -typedef npy_uint8 __pyx_t_5numpy_uint8_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":738 - * - * ctypedef npy_uint8 uint8_t - * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< - * ctypedef npy_uint32 uint32_t - * ctypedef npy_uint64 uint64_t - */ -typedef npy_uint16 __pyx_t_5numpy_uint16_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":739 - * ctypedef npy_uint8 uint8_t - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< - * ctypedef npy_uint64 uint64_t - * #ctypedef npy_uint96 uint96_t - */ -typedef npy_uint32 __pyx_t_5numpy_uint32_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":740 - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t - * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< - * #ctypedef npy_uint96 uint96_t - * #ctypedef npy_uint128 uint128_t - */ -typedef npy_uint64 __pyx_t_5numpy_uint64_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":744 - * #ctypedef npy_uint128 uint128_t - * - * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< - * ctypedef npy_float64 float64_t - * #ctypedef npy_float80 float80_t - */ -typedef npy_float32 __pyx_t_5numpy_float32_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":745 - * - * ctypedef npy_float32 float32_t - * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< - * #ctypedef npy_float80 float80_t - * #ctypedef npy_float128 float128_t - */ -typedef npy_float64 __pyx_t_5numpy_float64_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":754 - * # The int types are mapped a bit surprising -- - * # numpy.int corresponds to 'l' and numpy.long to 'q' - * ctypedef npy_long int_t # <<<<<<<<<<<<<< - * ctypedef npy_longlong longlong_t - * - */ -typedef npy_long __pyx_t_5numpy_int_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":755 - * # numpy.int corresponds to 'l' and numpy.long to 'q' - * ctypedef npy_long int_t - * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< - * - * ctypedef npy_ulong uint_t - */ -typedef npy_longlong __pyx_t_5numpy_longlong_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":757 - * ctypedef npy_longlong longlong_t - * - * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< - * ctypedef npy_ulonglong ulonglong_t - * - */ -typedef npy_ulong __pyx_t_5numpy_uint_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":758 - * - * ctypedef npy_ulong uint_t - * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< - * - * ctypedef npy_intp intp_t - */ -typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":760 - * ctypedef npy_ulonglong ulonglong_t - * - * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< - * ctypedef npy_uintp uintp_t - * - */ -typedef npy_intp __pyx_t_5numpy_intp_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":761 - * - * ctypedef npy_intp intp_t - * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< - * - * ctypedef npy_double float_t - */ -typedef npy_uintp __pyx_t_5numpy_uintp_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":763 - * ctypedef npy_uintp uintp_t - * - * ctypedef npy_double float_t # <<<<<<<<<<<<<< - * ctypedef npy_double double_t - * ctypedef npy_longdouble longdouble_t - */ -typedef npy_double __pyx_t_5numpy_float_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":764 - * - * ctypedef npy_double float_t - * ctypedef npy_double double_t # <<<<<<<<<<<<<< - * ctypedef npy_longdouble longdouble_t - * - */ -typedef npy_double __pyx_t_5numpy_double_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":765 - * ctypedef npy_double float_t - * ctypedef npy_double double_t - * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< - * - * ctypedef npy_cfloat cfloat_t - */ -typedef npy_longdouble __pyx_t_5numpy_longdouble_t; -/* #### Code section: complex_type_declarations ### */ -/* Declarations.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - typedef ::std::complex< float > __pyx_t_float_complex; - #else - typedef float _Complex __pyx_t_float_complex; - #endif -#else - typedef struct { float real, imag; } __pyx_t_float_complex; -#endif -static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); - -/* Declarations.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - typedef ::std::complex< double > __pyx_t_double_complex; - #else - typedef double _Complex __pyx_t_double_complex; - #endif -#else - typedef struct { double real, imag; } __pyx_t_double_complex; -#endif -static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); - -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_obj_6common_15transformations_15transformations_LocalCoord; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":767 - * ctypedef npy_longdouble longdouble_t - * - * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< - * ctypedef npy_cdouble cdouble_t - * ctypedef npy_clongdouble clongdouble_t - */ -typedef npy_cfloat __pyx_t_5numpy_cfloat_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":768 - * - * ctypedef npy_cfloat cfloat_t - * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< - * ctypedef npy_clongdouble clongdouble_t - * - */ -typedef npy_cdouble __pyx_t_5numpy_cdouble_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":769 - * ctypedef npy_cfloat cfloat_t - * ctypedef npy_cdouble cdouble_t - * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< - * - * ctypedef npy_cdouble complex_t - */ -typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":771 - * ctypedef npy_clongdouble clongdouble_t - * - * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew1(a): - */ -typedef npy_cdouble __pyx_t_5numpy_complex_t; - -/* "common/transformations/transformations.pyx":114 - * - * - * cdef class LocalCoord: # <<<<<<<<<<<<<< - * cdef LocalCoord_c * lc - * - */ -struct __pyx_obj_6common_15transformations_15transformations_LocalCoord { - PyObject_HEAD - LocalCoord *lc; -}; - -/* #### 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; -#ifdef WITH_THREAD - #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);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #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); - -/* 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 - -/* 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 - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* 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_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 - -/* 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 **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" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #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 - -/* 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 **args, size_t nargs, PyObject *kwargs); - -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - -/* IsLittleEndian.proto */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); - -/* BufferFormatCheck.proto */ -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type); - -/* BufferGetAndValidate.proto */ -#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ - ((obj == Py_None || obj == NULL) ?\ - (__Pyx_ZeroBuffer(buf), 0) :\ - __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) -static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, - __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); -static void __Pyx_ZeroBuffer(Py_buffer* buf); -static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); -static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; -static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; - -/* AssertionsEnabled.proto */ -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define __Pyx_init_assertions_enabled() (0) - #define __pyx_assertions_enabled() (1) -#elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) - static int __pyx_assertions_enabled_flag; - #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) - static int __Pyx_init_assertions_enabled(void) { - PyObject *builtins, *debug, *debug_str; - int flag; - builtins = PyEval_GetBuiltins(); - if (!builtins) goto bad; - debug_str = PyUnicode_FromStringAndSize("__debug__", 9); - if (!debug_str) goto bad; - debug = PyObject_GetItem(builtins, debug_str); - Py_DECREF(debug_str); - if (!debug) goto bad; - flag = PyObject_IsTrue(debug); - Py_DECREF(debug); - if (flag == -1) goto bad; - __pyx_assertions_enabled_flag = flag; - return 0; - bad: - __pyx_assertions_enabled_flag = 1; - return -1; - } -#else - #define __Pyx_init_assertions_enabled() (0) - #define __pyx_assertions_enabled() (!Py_OptimizeFlag) -#endif - -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__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)\ - (__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)\ - (__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); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -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_Arg_VARARGS(args, i) PySequence_GetItem(args, i) -#elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) -#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_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_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 - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#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 int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* 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); - -/* MoveIfSupported.proto */ -#if CYTHON_USE_CPP_STD_MOVE - #include - #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) -#else - #define __PYX_STD_MOVE_IF_SUPPORTED(x) x -#endif - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* 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); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_8 -#define __PYX_HAVE_RT_ImportType_proto_3_0_8 -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L -#include -#endif -#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L -#define __PYX_GET_STRUCT_ALIGNMENT_3_0_8(s) alignof(s) -#else -#define __PYX_GET_STRUCT_ALIGNMENT_3_0_8(s) sizeof(void*) -#endif -enum __Pyx_ImportType_CheckSize_3_0_8 { - __Pyx_ImportType_CheckSize_Error_3_0_8 = 0, - __Pyx_ImportType_CheckSize_Warn_3_0_8 = 1, - __Pyx_ImportType_CheckSize_Ignore_3_0_8 = 2 -}; -static PyTypeObject *__Pyx_ImportType_3_0_8(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_8 check_size); -#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); -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); -#endif - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -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); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -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 - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 || 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 - void *defaults; - int defaults_pyobjects; - size_t defaults_size; - 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_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); -#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 void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); -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 -#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); - -/* ClassMethod.proto */ -#include "descrobject.h" -CYTHON_UNUSED static PyObject* __Pyx_Method_ClassMethod(PyObject *method); - -/* GetNameInClass.proto */ -#define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) -static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -/* BufferStructDeclare.proto */ -typedef struct { - Py_ssize_t shape, strides, suboffsets; -} __Pyx_Buf_DimInfo; -typedef struct { - size_t refcount; - Py_buffer pybuffer; -} __Pyx_Buffer; -typedef struct { - __Pyx_Buffer *rcbuffer; - char *data; - __Pyx_Buf_DimInfo diminfo[8]; -} __Pyx_LocalBuf_ND; - -#if PY_MAJOR_VERSION < 3 - static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); - static void __Pyx_ReleaseBuffer(Py_buffer *view); -#else - #define __Pyx_GetBuffer PyObject_GetBuffer - #define __Pyx_ReleaseBuffer PyBuffer_Release -#endif - - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* RealImag.proto */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - #define __Pyx_CREAL(z) ((z).real()) - #define __Pyx_CIMAG(z) ((z).imag()) - #else - #define __Pyx_CREAL(z) (__real__(z)) - #define __Pyx_CIMAG(z) (__imag__(z)) - #endif -#else - #define __Pyx_CREAL(z) ((z).real) - #define __Pyx_CIMAG(z) ((z).imag) -#endif -#if defined(__cplusplus) && CYTHON_CCOMPLEX\ - && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) - #define __Pyx_SET_CREAL(z,x) ((z).real(x)) - #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) -#else - #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) - #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) -#endif - -/* Arithmetic.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #define __Pyx_c_eq_float(a, b) ((a)==(b)) - #define __Pyx_c_sum_float(a, b) ((a)+(b)) - #define __Pyx_c_diff_float(a, b) ((a)-(b)) - #define __Pyx_c_prod_float(a, b) ((a)*(b)) - #define __Pyx_c_quot_float(a, b) ((a)/(b)) - #define __Pyx_c_neg_float(a) (-(a)) - #ifdef __cplusplus - #define __Pyx_c_is_zero_float(z) ((z)==(float)0) - #define __Pyx_c_conj_float(z) (::std::conj(z)) - #if 1 - #define __Pyx_c_abs_float(z) (::std::abs(z)) - #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) - #endif - #else - #define __Pyx_c_is_zero_float(z) ((z)==0) - #define __Pyx_c_conj_float(z) (conjf(z)) - #if 1 - #define __Pyx_c_abs_float(z) (cabsf(z)) - #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) - #endif - #endif -#else - static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); - static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); - #if 1 - static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); - #endif -#endif - -/* Arithmetic.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #define __Pyx_c_eq_double(a, b) ((a)==(b)) - #define __Pyx_c_sum_double(a, b) ((a)+(b)) - #define __Pyx_c_diff_double(a, b) ((a)-(b)) - #define __Pyx_c_prod_double(a, b) ((a)*(b)) - #define __Pyx_c_quot_double(a, b) ((a)/(b)) - #define __Pyx_c_neg_double(a) (-(a)) - #ifdef __cplusplus - #define __Pyx_c_is_zero_double(z) ((z)==(double)0) - #define __Pyx_c_conj_double(z) (::std::conj(z)) - #if 1 - #define __Pyx_c_abs_double(z) (::std::abs(z)) - #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) - #endif - #else - #define __Pyx_c_is_zero_double(z) ((z)==0) - #define __Pyx_c_conj_double(z) (conj(z)) - #if 1 - #define __Pyx_c_abs_double(z) (cabs(z)) - #define __Pyx_c_pow_double(a, b) (cpow(a, b)) - #endif - #endif -#else - static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); - static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); - #if 1 - static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); - #endif -#endif - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_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) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (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) - -/* CheckBinaryVersion.proto */ -static unsigned long __Pyx_get_runtime_version(void); -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ - -/* Module declarations from "libcpp" */ - -/* Module declarations from "openpilot.common.transformations.transformations" */ - -/* Module declarations from "libc.string" */ - -/* Module declarations from "libc.stdio" */ - -/* Module declarations from "__builtin__" */ - -/* Module declarations from "cpython.type" */ - -/* Module declarations from "cpython" */ - -/* Module declarations from "cpython.object" */ - -/* Module declarations from "cpython.ref" */ - -/* Module declarations from "numpy" */ - -/* Module declarations from "numpy" */ - -/* Module declarations from "common.transformations.transformations" */ -static PyArrayObject *__pyx_f_6common_15transformations_15transformations_matrix2numpy(Eigen::Matrix3d); /*proto*/ -static Eigen::Matrix3d __pyx_f_6common_15transformations_15transformations_numpy2matrix(PyArrayObject *); /*proto*/ -static struct ECEF __pyx_f_6common_15transformations_15transformations_list2ecef(PyObject *); /*proto*/ -static struct NED __pyx_f_6common_15transformations_15transformations_list2ned(PyObject *); /*proto*/ -static struct Geodetic __pyx_f_6common_15transformations_15transformations_list2geodetic(PyObject *); /*proto*/ -/* #### Code section: typeinfo ### */ -static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "common.transformations.transformations" -extern int __pyx_module_is_main_common__transformations__transformations; -int __pyx_module_is_main_common__transformations__transformations = 0; - -/* Implementation of "common.transformations.transformations" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_AssertionError; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_ImportError; -/* #### Code section: string_decls ### */ -static const char __pyx_k_e[] = "e"; -static const char __pyx_k_g[] = "g"; -static const char __pyx_k_n[] = "n"; -static const char __pyx_k_q[] = "q"; -static const char __pyx_k_r[] = "r"; -static const char __pyx_k__3[] = "*"; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_np[] = "np"; -static const char __pyx_k__42[] = "?"; -static const char __pyx_k_cls[] = "cls"; -static const char __pyx_k_ned[] = "ned"; -static const char __pyx_k_rot[] = "rot"; -static const char __pyx_k_yaw[] = "yaw"; -static const char __pyx_k_dict[] = "__dict__"; -static const char __pyx_k_ecef[] = "ecef"; -static const char __pyx_k_init[] = "init"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "__name__"; -static const char __pyx_k_pose[] = "pose"; -static const char __pyx_k_quat[] = "quat"; -static const char __pyx_k_roll[] = "roll"; -static const char __pyx_k_self[] = "self"; -static const char __pyx_k_spec[] = "__spec__"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_array[] = "array"; -static const char __pyx_k_dtype[] = "dtype"; -static const char __pyx_k_euler[] = "euler"; -static const char __pyx_k_numpy[] = "numpy"; -static const char __pyx_k_pitch[] = "pitch"; -static const char __pyx_k_double[] = "double"; -static const char __pyx_k_enable[] = "enable"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_geodetic[] = "geodetic"; -static const char __pyx_k_getstate[] = "__getstate__"; -static const char __pyx_k_ned_pose[] = "ned_pose"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_ecef_init[] = "ecef_init"; -static const char __pyx_k_ecef_pose[] = "ecef_pose"; -static const char __pyx_k_from_ecef[] = "from_ecef"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_LocalCoord[] = "LocalCoord"; -static const char __pyx_k_rot_matrix[] = "rot_matrix"; -static const char __pyx_k_ImportError[] = "ImportError"; -static const char __pyx_k_initializing[] = "_initializing"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_stringsource[] = ""; -static const char __pyx_k_from_geodetic[] = "from_geodetic"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_AssertionError[] = "AssertionError"; -static const char __pyx_k_asfortranarray[] = "asfortranarray"; -static const char __pyx_k_ecef2ned_matrix[] = "ecef2ned_matrix"; -static const char __pyx_k_ecef2ned_single[] = "ecef2ned_single"; -static const char __pyx_k_ned2ecef_matrix[] = "ned2ecef_matrix"; -static const char __pyx_k_ned2ecef_single[] = "ned2ecef_single"; -static const char __pyx_k_quat2rot_single[] = "quat2rot_single"; -static const char __pyx_k_rot2quat_single[] = "rot2quat_single"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; -static const char __pyx_k_euler2rot_single[] = "euler2rot_single"; -static const char __pyx_k_rot2euler_single[] = "rot2euler_single"; -static const char __pyx_k_euler2quat_single[] = "euler2quat_single"; -static const char __pyx_k_quat2euler_single[] = "quat2euler_single"; -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_geodetic2ned_single[] = "geodetic2ned_single"; -static const char __pyx_k_ned2geodetic_single[] = "ned2geodetic_single"; -static const char __pyx_k_LocalCoord_from_ecef[] = "LocalCoord.from_ecef"; -static const char __pyx_k_ecef2geodetic_single[] = "ecef2geodetic_single"; -static const char __pyx_k_geodetic2ecef_single[] = "geodetic2ecef_single"; -static const char __pyx_k_LocalCoord_from_geodetic[] = "LocalCoord.from_geodetic"; -static const char __pyx_k_LocalCoord___reduce_cython[] = "LocalCoord.__reduce_cython__"; -static const char __pyx_k_LocalCoord_ecef2ned_single[] = "LocalCoord.ecef2ned_single"; -static const char __pyx_k_LocalCoord_ned2ecef_single[] = "LocalCoord.ned2ecef_single"; -static const char __pyx_k_ecef_euler_from_ned_single[] = "ecef_euler_from_ned_single"; -static const char __pyx_k_ned_euler_from_ecef_single[] = "ned_euler_from_ecef_single"; -static const char __pyx_k_LocalCoord___setstate_cython[] = "LocalCoord.__setstate_cython__"; -static const char __pyx_k_LocalCoord_geodetic2ned_single[] = "LocalCoord.geodetic2ned_single"; -static const char __pyx_k_LocalCoord_ned2geodetic_single[] = "LocalCoord.ned2geodetic_single"; -static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; -static const char __pyx_k_common_transformations_transform[] = "common/transformations/transformations.pyx"; -static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; -static const char __pyx_k_self_lc_cannot_be_converted_to_a[] = "self.lc cannot be converted to a Python object for pickling"; -static const char __pyx_k_common_transformations_transform_2[] = "common.transformations.transformations"; -/* #### Code section: decls ### */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_euler2quat_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_euler); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_2quat2euler_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_quat); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_4quat2rot_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_quat); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_6rot2quat_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rot); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_8euler2rot_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_euler); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10rot2euler_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rot); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_12rot_matrix(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_roll, PyObject *__pyx_v_pitch, PyObject *__pyx_v_yaw); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_14ecef_euler_from_ned_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ecef_init, PyObject *__pyx_v_ned_pose); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_16ned_euler_from_ecef_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ecef_init, PyObject *__pyx_v_ecef_pose); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_18geodetic2ecef_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_geodetic); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_20ecef2geodetic_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ecef); /* proto */ -static int __pyx_pf_6common_15transformations_15transformations_10LocalCoord___init__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_geodetic, PyObject *__pyx_v_ecef); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_15ned2ecef_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_15ecef2ned_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_20ned_from_ecef_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_20ecef_from_ned_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_2from_geodetic(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_geodetic); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_4from_ecef(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_ecef); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_6ecef2ned_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_ecef); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_8ned2ecef_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_ned); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_10geodetic2ned_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_geodetic); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_12ned2geodetic_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_ned); /* proto */ -static void __pyx_pf_6common_15transformations_15transformations_10LocalCoord_14__dealloc__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_tp_new_6common_15transformations_15transformations_LocalCoord(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -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 - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - PyTypeObject *__pyx_ptype_7cpython_4type_type; - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - PyTypeObject *__pyx_ptype_5numpy_dtype; - PyTypeObject *__pyx_ptype_5numpy_flatiter; - PyTypeObject *__pyx_ptype_5numpy_broadcast; - PyTypeObject *__pyx_ptype_5numpy_ndarray; - PyTypeObject *__pyx_ptype_5numpy_generic; - PyTypeObject *__pyx_ptype_5numpy_number; - PyTypeObject *__pyx_ptype_5numpy_integer; - PyTypeObject *__pyx_ptype_5numpy_signedinteger; - PyTypeObject *__pyx_ptype_5numpy_unsignedinteger; - PyTypeObject *__pyx_ptype_5numpy_inexact; - PyTypeObject *__pyx_ptype_5numpy_floating; - PyTypeObject *__pyx_ptype_5numpy_complexfloating; - PyTypeObject *__pyx_ptype_5numpy_flexible; - PyTypeObject *__pyx_ptype_5numpy_character; - PyTypeObject *__pyx_ptype_5numpy_ufunc; - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type_6common_15transformations_15transformations_LocalCoord; - #endif - PyTypeObject *__pyx_ptype_6common_15transformations_15transformations_LocalCoord; - PyObject *__pyx_n_s_AssertionError; - PyObject *__pyx_n_s_ImportError; - PyObject *__pyx_n_s_LocalCoord; - PyObject *__pyx_n_s_LocalCoord___reduce_cython; - PyObject *__pyx_n_s_LocalCoord___setstate_cython; - PyObject *__pyx_n_s_LocalCoord_ecef2ned_single; - PyObject *__pyx_n_s_LocalCoord_from_ecef; - PyObject *__pyx_n_s_LocalCoord_from_geodetic; - PyObject *__pyx_n_s_LocalCoord_geodetic2ned_single; - PyObject *__pyx_n_s_LocalCoord_ned2ecef_single; - PyObject *__pyx_n_s_LocalCoord_ned2geodetic_single; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_n_s__3; - PyObject *__pyx_n_s__42; - PyObject *__pyx_n_s_array; - PyObject *__pyx_n_s_asfortranarray; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_cls; - PyObject *__pyx_kp_s_common_transformations_transform; - PyObject *__pyx_n_s_common_transformations_transform_2; - PyObject *__pyx_n_s_dict; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_n_s_double; - PyObject *__pyx_n_s_dtype; - PyObject *__pyx_n_s_e; - PyObject *__pyx_n_s_ecef; - PyObject *__pyx_n_s_ecef2geodetic_single; - PyObject *__pyx_n_s_ecef2ned_matrix; - PyObject *__pyx_n_s_ecef2ned_single; - PyObject *__pyx_n_s_ecef_euler_from_ned_single; - PyObject *__pyx_n_s_ecef_init; - PyObject *__pyx_n_s_ecef_pose; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_n_s_euler; - PyObject *__pyx_n_s_euler2quat_single; - PyObject *__pyx_n_s_euler2rot_single; - PyObject *__pyx_n_s_from_ecef; - PyObject *__pyx_n_s_from_geodetic; - PyObject *__pyx_n_s_g; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_geodetic; - PyObject *__pyx_n_s_geodetic2ecef_single; - PyObject *__pyx_n_s_geodetic2ned_single; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_init; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_n; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_ned; - PyObject *__pyx_n_s_ned2ecef_matrix; - PyObject *__pyx_n_s_ned2ecef_single; - PyObject *__pyx_n_s_ned2geodetic_single; - PyObject *__pyx_n_s_ned_euler_from_ecef_single; - PyObject *__pyx_n_s_ned_pose; - PyObject *__pyx_n_s_np; - PyObject *__pyx_n_s_numpy; - PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; - PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; - PyObject *__pyx_n_s_pitch; - PyObject *__pyx_n_s_pose; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_q; - PyObject *__pyx_n_s_quat; - PyObject *__pyx_n_s_quat2euler_single; - PyObject *__pyx_n_s_quat2rot_single; - PyObject *__pyx_n_s_r; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_roll; - PyObject *__pyx_n_s_rot; - PyObject *__pyx_n_s_rot2euler_single; - PyObject *__pyx_n_s_rot2quat_single; - PyObject *__pyx_n_s_rot_matrix; - PyObject *__pyx_n_s_self; - PyObject *__pyx_kp_s_self_lc_cannot_be_converted_to_a; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_test; - PyObject *__pyx_n_s_yaw; - PyObject *__pyx_tuple_; - PyObject *__pyx_tuple__2; - PyObject *__pyx_tuple__4; - PyObject *__pyx_tuple__6; - PyObject *__pyx_tuple__8; - PyObject *__pyx_tuple__10; - PyObject *__pyx_tuple__12; - PyObject *__pyx_tuple__14; - PyObject *__pyx_tuple__16; - PyObject *__pyx_tuple__18; - PyObject *__pyx_tuple__20; - PyObject *__pyx_tuple__22; - PyObject *__pyx_tuple__24; - PyObject *__pyx_tuple__26; - PyObject *__pyx_tuple__28; - PyObject *__pyx_tuple__30; - PyObject *__pyx_tuple__32; - PyObject *__pyx_tuple__34; - PyObject *__pyx_tuple__36; - PyObject *__pyx_tuple__38; - PyObject *__pyx_tuple__40; - PyObject *__pyx_codeobj__5; - PyObject *__pyx_codeobj__7; - PyObject *__pyx_codeobj__9; - PyObject *__pyx_codeobj__11; - PyObject *__pyx_codeobj__13; - PyObject *__pyx_codeobj__15; - PyObject *__pyx_codeobj__17; - PyObject *__pyx_codeobj__19; - PyObject *__pyx_codeobj__21; - PyObject *__pyx_codeobj__23; - PyObject *__pyx_codeobj__25; - PyObject *__pyx_codeobj__27; - PyObject *__pyx_codeobj__29; - PyObject *__pyx_codeobj__31; - PyObject *__pyx_codeobj__33; - PyObject *__pyx_codeobj__35; - PyObject *__pyx_codeobj__37; - PyObject *__pyx_codeobj__39; - PyObject *__pyx_codeobj__41; -} __pyx_mstate; - -#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(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(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 - Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); - Py_CLEAR(clear_module_state->__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - Py_CLEAR(clear_module_state->__pyx_type_6common_15transformations_15transformations_LocalCoord); - Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); - Py_CLEAR(clear_module_state->__pyx_n_s_ImportError); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord___reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord___setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord_ecef2ned_single); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord_from_ecef); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord_from_geodetic); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord_geodetic2ned_single); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord_ned2ecef_single); - Py_CLEAR(clear_module_state->__pyx_n_s_LocalCoord_ned2geodetic_single); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_n_s__3); - Py_CLEAR(clear_module_state->__pyx_n_s__42); - Py_CLEAR(clear_module_state->__pyx_n_s_array); - Py_CLEAR(clear_module_state->__pyx_n_s_asfortranarray); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_cls); - Py_CLEAR(clear_module_state->__pyx_kp_s_common_transformations_transform); - Py_CLEAR(clear_module_state->__pyx_n_s_common_transformations_transform_2); - Py_CLEAR(clear_module_state->__pyx_n_s_dict); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_n_s_double); - Py_CLEAR(clear_module_state->__pyx_n_s_dtype); - Py_CLEAR(clear_module_state->__pyx_n_s_e); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef2geodetic_single); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef2ned_matrix); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef2ned_single); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef_euler_from_ned_single); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef_init); - Py_CLEAR(clear_module_state->__pyx_n_s_ecef_pose); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_n_s_euler); - Py_CLEAR(clear_module_state->__pyx_n_s_euler2quat_single); - Py_CLEAR(clear_module_state->__pyx_n_s_euler2rot_single); - Py_CLEAR(clear_module_state->__pyx_n_s_from_ecef); - Py_CLEAR(clear_module_state->__pyx_n_s_from_geodetic); - Py_CLEAR(clear_module_state->__pyx_n_s_g); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_geodetic); - Py_CLEAR(clear_module_state->__pyx_n_s_geodetic2ecef_single); - Py_CLEAR(clear_module_state->__pyx_n_s_geodetic2ned_single); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_init); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_n); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_ned); - Py_CLEAR(clear_module_state->__pyx_n_s_ned2ecef_matrix); - Py_CLEAR(clear_module_state->__pyx_n_s_ned2ecef_single); - Py_CLEAR(clear_module_state->__pyx_n_s_ned2geodetic_single); - Py_CLEAR(clear_module_state->__pyx_n_s_ned_euler_from_ecef_single); - Py_CLEAR(clear_module_state->__pyx_n_s_ned_pose); - Py_CLEAR(clear_module_state->__pyx_n_s_np); - Py_CLEAR(clear_module_state->__pyx_n_s_numpy); - Py_CLEAR(clear_module_state->__pyx_kp_u_numpy_core_multiarray_failed_to); - Py_CLEAR(clear_module_state->__pyx_kp_u_numpy_core_umath_failed_to_impor); - Py_CLEAR(clear_module_state->__pyx_n_s_pitch); - Py_CLEAR(clear_module_state->__pyx_n_s_pose); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_q); - Py_CLEAR(clear_module_state->__pyx_n_s_quat); - Py_CLEAR(clear_module_state->__pyx_n_s_quat2euler_single); - Py_CLEAR(clear_module_state->__pyx_n_s_quat2rot_single); - Py_CLEAR(clear_module_state->__pyx_n_s_r); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_roll); - Py_CLEAR(clear_module_state->__pyx_n_s_rot); - Py_CLEAR(clear_module_state->__pyx_n_s_rot2euler_single); - Py_CLEAR(clear_module_state->__pyx_n_s_rot2quat_single); - Py_CLEAR(clear_module_state->__pyx_n_s_rot_matrix); - Py_CLEAR(clear_module_state->__pyx_n_s_self); - Py_CLEAR(clear_module_state->__pyx_kp_s_self_lc_cannot_be_converted_to_a); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_n_s_yaw); - Py_CLEAR(clear_module_state->__pyx_tuple_); - Py_CLEAR(clear_module_state->__pyx_tuple__2); - Py_CLEAR(clear_module_state->__pyx_tuple__4); - Py_CLEAR(clear_module_state->__pyx_tuple__6); - Py_CLEAR(clear_module_state->__pyx_tuple__8); - Py_CLEAR(clear_module_state->__pyx_tuple__10); - Py_CLEAR(clear_module_state->__pyx_tuple__12); - Py_CLEAR(clear_module_state->__pyx_tuple__14); - Py_CLEAR(clear_module_state->__pyx_tuple__16); - Py_CLEAR(clear_module_state->__pyx_tuple__18); - Py_CLEAR(clear_module_state->__pyx_tuple__20); - Py_CLEAR(clear_module_state->__pyx_tuple__22); - Py_CLEAR(clear_module_state->__pyx_tuple__24); - Py_CLEAR(clear_module_state->__pyx_tuple__26); - Py_CLEAR(clear_module_state->__pyx_tuple__28); - Py_CLEAR(clear_module_state->__pyx_tuple__30); - Py_CLEAR(clear_module_state->__pyx_tuple__32); - Py_CLEAR(clear_module_state->__pyx_tuple__34); - Py_CLEAR(clear_module_state->__pyx_tuple__36); - Py_CLEAR(clear_module_state->__pyx_tuple__38); - Py_CLEAR(clear_module_state->__pyx_tuple__40); - Py_CLEAR(clear_module_state->__pyx_codeobj__5); - Py_CLEAR(clear_module_state->__pyx_codeobj__7); - Py_CLEAR(clear_module_state->__pyx_codeobj__9); - Py_CLEAR(clear_module_state->__pyx_codeobj__11); - Py_CLEAR(clear_module_state->__pyx_codeobj__13); - Py_CLEAR(clear_module_state->__pyx_codeobj__15); - Py_CLEAR(clear_module_state->__pyx_codeobj__17); - Py_CLEAR(clear_module_state->__pyx_codeobj__19); - Py_CLEAR(clear_module_state->__pyx_codeobj__21); - Py_CLEAR(clear_module_state->__pyx_codeobj__23); - Py_CLEAR(clear_module_state->__pyx_codeobj__25); - Py_CLEAR(clear_module_state->__pyx_codeobj__27); - Py_CLEAR(clear_module_state->__pyx_codeobj__29); - Py_CLEAR(clear_module_state->__pyx_codeobj__31); - Py_CLEAR(clear_module_state->__pyx_codeobj__33); - Py_CLEAR(clear_module_state->__pyx_codeobj__35); - Py_CLEAR(clear_module_state->__pyx_codeobj__37); - Py_CLEAR(clear_module_state->__pyx_codeobj__39); - Py_CLEAR(clear_module_state->__pyx_codeobj__41); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(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); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(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_7cpython_4type_type); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); - Py_VISIT(traverse_module_state->__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - Py_VISIT(traverse_module_state->__pyx_type_6common_15transformations_15transformations_LocalCoord); - Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); - Py_VISIT(traverse_module_state->__pyx_n_s_ImportError); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord___reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord___setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord_ecef2ned_single); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord_from_ecef); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord_from_geodetic); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord_geodetic2ned_single); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord_ned2ecef_single); - Py_VISIT(traverse_module_state->__pyx_n_s_LocalCoord_ned2geodetic_single); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_n_s__3); - Py_VISIT(traverse_module_state->__pyx_n_s__42); - Py_VISIT(traverse_module_state->__pyx_n_s_array); - Py_VISIT(traverse_module_state->__pyx_n_s_asfortranarray); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_cls); - Py_VISIT(traverse_module_state->__pyx_kp_s_common_transformations_transform); - Py_VISIT(traverse_module_state->__pyx_n_s_common_transformations_transform_2); - Py_VISIT(traverse_module_state->__pyx_n_s_dict); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_n_s_double); - Py_VISIT(traverse_module_state->__pyx_n_s_dtype); - Py_VISIT(traverse_module_state->__pyx_n_s_e); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef2geodetic_single); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef2ned_matrix); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef2ned_single); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef_euler_from_ned_single); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef_init); - Py_VISIT(traverse_module_state->__pyx_n_s_ecef_pose); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_n_s_euler); - Py_VISIT(traverse_module_state->__pyx_n_s_euler2quat_single); - Py_VISIT(traverse_module_state->__pyx_n_s_euler2rot_single); - Py_VISIT(traverse_module_state->__pyx_n_s_from_ecef); - Py_VISIT(traverse_module_state->__pyx_n_s_from_geodetic); - Py_VISIT(traverse_module_state->__pyx_n_s_g); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_geodetic); - Py_VISIT(traverse_module_state->__pyx_n_s_geodetic2ecef_single); - Py_VISIT(traverse_module_state->__pyx_n_s_geodetic2ned_single); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_init); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_n); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_ned); - Py_VISIT(traverse_module_state->__pyx_n_s_ned2ecef_matrix); - Py_VISIT(traverse_module_state->__pyx_n_s_ned2ecef_single); - Py_VISIT(traverse_module_state->__pyx_n_s_ned2geodetic_single); - Py_VISIT(traverse_module_state->__pyx_n_s_ned_euler_from_ecef_single); - Py_VISIT(traverse_module_state->__pyx_n_s_ned_pose); - Py_VISIT(traverse_module_state->__pyx_n_s_np); - Py_VISIT(traverse_module_state->__pyx_n_s_numpy); - Py_VISIT(traverse_module_state->__pyx_kp_u_numpy_core_multiarray_failed_to); - Py_VISIT(traverse_module_state->__pyx_kp_u_numpy_core_umath_failed_to_impor); - Py_VISIT(traverse_module_state->__pyx_n_s_pitch); - Py_VISIT(traverse_module_state->__pyx_n_s_pose); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_q); - Py_VISIT(traverse_module_state->__pyx_n_s_quat); - Py_VISIT(traverse_module_state->__pyx_n_s_quat2euler_single); - Py_VISIT(traverse_module_state->__pyx_n_s_quat2rot_single); - Py_VISIT(traverse_module_state->__pyx_n_s_r); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_roll); - Py_VISIT(traverse_module_state->__pyx_n_s_rot); - Py_VISIT(traverse_module_state->__pyx_n_s_rot2euler_single); - Py_VISIT(traverse_module_state->__pyx_n_s_rot2quat_single); - Py_VISIT(traverse_module_state->__pyx_n_s_rot_matrix); - Py_VISIT(traverse_module_state->__pyx_n_s_self); - Py_VISIT(traverse_module_state->__pyx_kp_s_self_lc_cannot_be_converted_to_a); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_n_s_yaw); - Py_VISIT(traverse_module_state->__pyx_tuple_); - Py_VISIT(traverse_module_state->__pyx_tuple__2); - Py_VISIT(traverse_module_state->__pyx_tuple__4); - Py_VISIT(traverse_module_state->__pyx_tuple__6); - Py_VISIT(traverse_module_state->__pyx_tuple__8); - Py_VISIT(traverse_module_state->__pyx_tuple__10); - Py_VISIT(traverse_module_state->__pyx_tuple__12); - Py_VISIT(traverse_module_state->__pyx_tuple__14); - Py_VISIT(traverse_module_state->__pyx_tuple__16); - Py_VISIT(traverse_module_state->__pyx_tuple__18); - Py_VISIT(traverse_module_state->__pyx_tuple__20); - Py_VISIT(traverse_module_state->__pyx_tuple__22); - Py_VISIT(traverse_module_state->__pyx_tuple__24); - Py_VISIT(traverse_module_state->__pyx_tuple__26); - Py_VISIT(traverse_module_state->__pyx_tuple__28); - Py_VISIT(traverse_module_state->__pyx_tuple__30); - Py_VISIT(traverse_module_state->__pyx_tuple__32); - Py_VISIT(traverse_module_state->__pyx_tuple__34); - Py_VISIT(traverse_module_state->__pyx_tuple__36); - Py_VISIT(traverse_module_state->__pyx_tuple__38); - Py_VISIT(traverse_module_state->__pyx_tuple__40); - Py_VISIT(traverse_module_state->__pyx_codeobj__5); - Py_VISIT(traverse_module_state->__pyx_codeobj__7); - Py_VISIT(traverse_module_state->__pyx_codeobj__9); - Py_VISIT(traverse_module_state->__pyx_codeobj__11); - Py_VISIT(traverse_module_state->__pyx_codeobj__13); - Py_VISIT(traverse_module_state->__pyx_codeobj__15); - Py_VISIT(traverse_module_state->__pyx_codeobj__17); - Py_VISIT(traverse_module_state->__pyx_codeobj__19); - Py_VISIT(traverse_module_state->__pyx_codeobj__21); - Py_VISIT(traverse_module_state->__pyx_codeobj__23); - Py_VISIT(traverse_module_state->__pyx_codeobj__25); - Py_VISIT(traverse_module_state->__pyx_codeobj__27); - Py_VISIT(traverse_module_state->__pyx_codeobj__29); - Py_VISIT(traverse_module_state->__pyx_codeobj__31); - Py_VISIT(traverse_module_state->__pyx_codeobj__33); - Py_VISIT(traverse_module_state->__pyx_codeobj__35); - Py_VISIT(traverse_module_state->__pyx_codeobj__37); - Py_VISIT(traverse_module_state->__pyx_codeobj__39); - Py_VISIT(traverse_module_state->__pyx_codeobj__41); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_ptype_5numpy_dtype __pyx_mstate_global->__pyx_ptype_5numpy_dtype -#define __pyx_ptype_5numpy_flatiter __pyx_mstate_global->__pyx_ptype_5numpy_flatiter -#define __pyx_ptype_5numpy_broadcast __pyx_mstate_global->__pyx_ptype_5numpy_broadcast -#define __pyx_ptype_5numpy_ndarray __pyx_mstate_global->__pyx_ptype_5numpy_ndarray -#define __pyx_ptype_5numpy_generic __pyx_mstate_global->__pyx_ptype_5numpy_generic -#define __pyx_ptype_5numpy_number __pyx_mstate_global->__pyx_ptype_5numpy_number -#define __pyx_ptype_5numpy_integer __pyx_mstate_global->__pyx_ptype_5numpy_integer -#define __pyx_ptype_5numpy_signedinteger __pyx_mstate_global->__pyx_ptype_5numpy_signedinteger -#define __pyx_ptype_5numpy_unsignedinteger __pyx_mstate_global->__pyx_ptype_5numpy_unsignedinteger -#define __pyx_ptype_5numpy_inexact __pyx_mstate_global->__pyx_ptype_5numpy_inexact -#define __pyx_ptype_5numpy_floating __pyx_mstate_global->__pyx_ptype_5numpy_floating -#define __pyx_ptype_5numpy_complexfloating __pyx_mstate_global->__pyx_ptype_5numpy_complexfloating -#define __pyx_ptype_5numpy_flexible __pyx_mstate_global->__pyx_ptype_5numpy_flexible -#define __pyx_ptype_5numpy_character __pyx_mstate_global->__pyx_ptype_5numpy_character -#define __pyx_ptype_5numpy_ufunc __pyx_mstate_global->__pyx_ptype_5numpy_ufunc -#if CYTHON_USE_MODULE_STATE -#define __pyx_type_6common_15transformations_15transformations_LocalCoord __pyx_mstate_global->__pyx_type_6common_15transformations_15transformations_LocalCoord -#endif -#define __pyx_ptype_6common_15transformations_15transformations_LocalCoord __pyx_mstate_global->__pyx_ptype_6common_15transformations_15transformations_LocalCoord -#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError -#define __pyx_n_s_ImportError __pyx_mstate_global->__pyx_n_s_ImportError -#define __pyx_n_s_LocalCoord __pyx_mstate_global->__pyx_n_s_LocalCoord -#define __pyx_n_s_LocalCoord___reduce_cython __pyx_mstate_global->__pyx_n_s_LocalCoord___reduce_cython -#define __pyx_n_s_LocalCoord___setstate_cython __pyx_mstate_global->__pyx_n_s_LocalCoord___setstate_cython -#define __pyx_n_s_LocalCoord_ecef2ned_single __pyx_mstate_global->__pyx_n_s_LocalCoord_ecef2ned_single -#define __pyx_n_s_LocalCoord_from_ecef __pyx_mstate_global->__pyx_n_s_LocalCoord_from_ecef -#define __pyx_n_s_LocalCoord_from_geodetic __pyx_mstate_global->__pyx_n_s_LocalCoord_from_geodetic -#define __pyx_n_s_LocalCoord_geodetic2ned_single __pyx_mstate_global->__pyx_n_s_LocalCoord_geodetic2ned_single -#define __pyx_n_s_LocalCoord_ned2ecef_single __pyx_mstate_global->__pyx_n_s_LocalCoord_ned2ecef_single -#define __pyx_n_s_LocalCoord_ned2geodetic_single __pyx_mstate_global->__pyx_n_s_LocalCoord_ned2geodetic_single -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3 -#define __pyx_n_s__42 __pyx_mstate_global->__pyx_n_s__42 -#define __pyx_n_s_array __pyx_mstate_global->__pyx_n_s_array -#define __pyx_n_s_asfortranarray __pyx_mstate_global->__pyx_n_s_asfortranarray -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_cls __pyx_mstate_global->__pyx_n_s_cls -#define __pyx_kp_s_common_transformations_transform __pyx_mstate_global->__pyx_kp_s_common_transformations_transform -#define __pyx_n_s_common_transformations_transform_2 __pyx_mstate_global->__pyx_n_s_common_transformations_transform_2 -#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_n_s_double __pyx_mstate_global->__pyx_n_s_double -#define __pyx_n_s_dtype __pyx_mstate_global->__pyx_n_s_dtype -#define __pyx_n_s_e __pyx_mstate_global->__pyx_n_s_e -#define __pyx_n_s_ecef __pyx_mstate_global->__pyx_n_s_ecef -#define __pyx_n_s_ecef2geodetic_single __pyx_mstate_global->__pyx_n_s_ecef2geodetic_single -#define __pyx_n_s_ecef2ned_matrix __pyx_mstate_global->__pyx_n_s_ecef2ned_matrix -#define __pyx_n_s_ecef2ned_single __pyx_mstate_global->__pyx_n_s_ecef2ned_single -#define __pyx_n_s_ecef_euler_from_ned_single __pyx_mstate_global->__pyx_n_s_ecef_euler_from_ned_single -#define __pyx_n_s_ecef_init __pyx_mstate_global->__pyx_n_s_ecef_init -#define __pyx_n_s_ecef_pose __pyx_mstate_global->__pyx_n_s_ecef_pose -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_n_s_euler __pyx_mstate_global->__pyx_n_s_euler -#define __pyx_n_s_euler2quat_single __pyx_mstate_global->__pyx_n_s_euler2quat_single -#define __pyx_n_s_euler2rot_single __pyx_mstate_global->__pyx_n_s_euler2rot_single -#define __pyx_n_s_from_ecef __pyx_mstate_global->__pyx_n_s_from_ecef -#define __pyx_n_s_from_geodetic __pyx_mstate_global->__pyx_n_s_from_geodetic -#define __pyx_n_s_g __pyx_mstate_global->__pyx_n_s_g -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_geodetic __pyx_mstate_global->__pyx_n_s_geodetic -#define __pyx_n_s_geodetic2ecef_single __pyx_mstate_global->__pyx_n_s_geodetic2ecef_single -#define __pyx_n_s_geodetic2ned_single __pyx_mstate_global->__pyx_n_s_geodetic2ned_single -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init -#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_n __pyx_mstate_global->__pyx_n_s_n -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_ned __pyx_mstate_global->__pyx_n_s_ned -#define __pyx_n_s_ned2ecef_matrix __pyx_mstate_global->__pyx_n_s_ned2ecef_matrix -#define __pyx_n_s_ned2ecef_single __pyx_mstate_global->__pyx_n_s_ned2ecef_single -#define __pyx_n_s_ned2geodetic_single __pyx_mstate_global->__pyx_n_s_ned2geodetic_single -#define __pyx_n_s_ned_euler_from_ecef_single __pyx_mstate_global->__pyx_n_s_ned_euler_from_ecef_single -#define __pyx_n_s_ned_pose __pyx_mstate_global->__pyx_n_s_ned_pose -#define __pyx_n_s_np __pyx_mstate_global->__pyx_n_s_np -#define __pyx_n_s_numpy __pyx_mstate_global->__pyx_n_s_numpy -#define __pyx_kp_u_numpy_core_multiarray_failed_to __pyx_mstate_global->__pyx_kp_u_numpy_core_multiarray_failed_to -#define __pyx_kp_u_numpy_core_umath_failed_to_impor __pyx_mstate_global->__pyx_kp_u_numpy_core_umath_failed_to_impor -#define __pyx_n_s_pitch __pyx_mstate_global->__pyx_n_s_pitch -#define __pyx_n_s_pose __pyx_mstate_global->__pyx_n_s_pose -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_q __pyx_mstate_global->__pyx_n_s_q -#define __pyx_n_s_quat __pyx_mstate_global->__pyx_n_s_quat -#define __pyx_n_s_quat2euler_single __pyx_mstate_global->__pyx_n_s_quat2euler_single -#define __pyx_n_s_quat2rot_single __pyx_mstate_global->__pyx_n_s_quat2rot_single -#define __pyx_n_s_r __pyx_mstate_global->__pyx_n_s_r -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_roll __pyx_mstate_global->__pyx_n_s_roll -#define __pyx_n_s_rot __pyx_mstate_global->__pyx_n_s_rot -#define __pyx_n_s_rot2euler_single __pyx_mstate_global->__pyx_n_s_rot2euler_single -#define __pyx_n_s_rot2quat_single __pyx_mstate_global->__pyx_n_s_rot2quat_single -#define __pyx_n_s_rot_matrix __pyx_mstate_global->__pyx_n_s_rot_matrix -#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self -#define __pyx_kp_s_self_lc_cannot_be_converted_to_a __pyx_mstate_global->__pyx_kp_s_self_lc_cannot_be_converted_to_a -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_n_s_yaw __pyx_mstate_global->__pyx_n_s_yaw -#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ -#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 -#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 -#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 -#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 -#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 -#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 -#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 -#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 -#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 -#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 -#define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22 -#define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24 -#define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26 -#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 -#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30 -#define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 -#define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 -#define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 -#define __pyx_tuple__38 __pyx_mstate_global->__pyx_tuple__38 -#define __pyx_tuple__40 __pyx_mstate_global->__pyx_tuple__40 -#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 -#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 -#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 -#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 -#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 -#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 -#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 -#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 -#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 -#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 -#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 -#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 -#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 -#define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 -#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 -#define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 -#define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 -#define __pyx_codeobj__39 __pyx_mstate_global->__pyx_codeobj__39 -#define __pyx_codeobj__41 __pyx_mstate_global->__pyx_codeobj__41 -/* #### Code section: module_code ### */ - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":245 - * - * @property - * cdef inline PyObject* base(self) nogil: # <<<<<<<<<<<<<< - * """Returns a borrowed reference to the object owning the data/memory. - * """ - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) { - PyObject *__pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":248 - * """Returns a borrowed reference to the object owning the data/memory. - * """ - * return PyArray_BASE(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_BASE(__pyx_v_self); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":245 - * - * @property - * cdef inline PyObject* base(self) nogil: # <<<<<<<<<<<<<< - * """Returns a borrowed reference to the object owning the data/memory. - * """ - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":251 - * - * @property - * cdef inline dtype descr(self): # <<<<<<<<<<<<<< - * """Returns an owned reference to the dtype of the array. - * """ - */ - -static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) { - PyArray_Descr *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyArray_Descr *__pyx_t_1; - __Pyx_RefNannySetupContext("descr", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":254 - * """Returns an owned reference to the dtype of the array. - * """ - * return PyArray_DESCR(self) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - __pyx_t_1 = PyArray_DESCR(__pyx_v_self); - __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1)); - __pyx_r = ((PyArray_Descr *)__pyx_t_1); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":251 - * - * @property - * cdef inline dtype descr(self): # <<<<<<<<<<<<<< - * """Returns an owned reference to the dtype of the array. - * """ - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":257 - * - * @property - * cdef inline int ndim(self) nogil: # <<<<<<<<<<<<<< - * """Returns the number of dimensions in the array. - * """ - */ - -static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) { - int __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":260 - * """Returns the number of dimensions in the array. - * """ - * return PyArray_NDIM(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_NDIM(__pyx_v_self); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":257 - * - * @property - * cdef inline int ndim(self) nogil: # <<<<<<<<<<<<<< - * """Returns the number of dimensions in the array. - * """ - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":263 - * - * @property - * cdef inline npy_intp *shape(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the dimensions/shape of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) { - npy_intp *__pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":268 - * Can return NULL for 0-dimensional arrays. - * """ - * return PyArray_DIMS(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_DIMS(__pyx_v_self); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":263 - * - * @property - * cdef inline npy_intp *shape(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the dimensions/shape of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":271 - * - * @property - * cdef inline npy_intp *strides(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the strides of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) { - npy_intp *__pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":275 - * The number of elements matches the number of dimensions of the array (ndim). - * """ - * return PyArray_STRIDES(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_STRIDES(__pyx_v_self); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":271 - * - * @property - * cdef inline npy_intp *strides(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the strides of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":278 - * - * @property - * cdef inline npy_intp size(self) nogil: # <<<<<<<<<<<<<< - * """Returns the total size (in number of elements) of the array. - * """ - */ - -static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) { - npy_intp __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":281 - * """Returns the total size (in number of elements) of the array. - * """ - * return PyArray_SIZE(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_SIZE(__pyx_v_self); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":278 - * - * @property - * cdef inline npy_intp size(self) nogil: # <<<<<<<<<<<<<< - * """Returns the total size (in number of elements) of the array. - * """ - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":284 - * - * @property - * cdef inline char* data(self) nogil: # <<<<<<<<<<<<<< - * """The pointer to the data buffer as a char*. - * This is provided for legacy reasons to avoid direct struct field access. - */ - -static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) { - char *__pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":290 - * of `PyArray_DATA()` instead, which returns a 'void*'. - * """ - * return PyArray_BYTES(self) # <<<<<<<<<<<<<< - * - * ctypedef unsigned char npy_bool - */ - __pyx_r = PyArray_BYTES(__pyx_v_self); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":284 - * - * @property - * cdef inline char* data(self) nogil: # <<<<<<<<<<<<<< - * """The pointer to the data buffer as a char*. - * This is provided for legacy reasons to avoid direct struct field access. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":773 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - 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("PyArray_MultiIterNew1", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":774 - * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew2(a, b): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 774, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":773 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":776 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { - 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("PyArray_MultiIterNew2", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":777 - * - * cdef inline object PyArray_MultiIterNew2(a, b): - * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 777, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":776 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":779 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { - 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("PyArray_MultiIterNew3", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":780 - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 780, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":779 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":782 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { - 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("PyArray_MultiIterNew4", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":783 - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 783, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":782 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":785 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - 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("PyArray_MultiIterNew5", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":786 - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 786, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":785 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":788 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":789 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d); - if (__pyx_t_1) { - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":790 - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape # <<<<<<<<<<<<<< - * else: - * return () - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":789 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - } - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":792 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< - * - * - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; - } - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":788 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":968 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":969 - * - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< - * PyArray_SetBaseObject(arr, base) - * - */ - Py_INCREF(__pyx_v_base); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":970 - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< - * - * cdef inline object get_array_base(ndarray arr): - */ - __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 970, __pyx_L1_error) - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":968 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_L0:; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":972 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { - PyObject *__pyx_v_base; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("get_array_base", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":973 - * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None - */ - __pyx_v_base = PyArray_BASE(__pyx_v_arr); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":974 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - __pyx_t_1 = (__pyx_v_base == NULL); - if (__pyx_t_1) { - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":975 - * base = PyArray_BASE(arr) - * if base is NULL: - * return None # <<<<<<<<<<<<<< - * return base - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":974 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - } - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":976 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< - * - * # Versions of the import_* functions which are more suitable for - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":972 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":980 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - 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_RefNannySetupContext("import_array", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":981 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - { - __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:*/ { - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":982 - * cdef inline int import_array() except -1: - * try: - * __pyx_import_array() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") - */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 982, __pyx_L3_error) - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":981 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - } - __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:; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":983 - * try: - * __pyx_import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") - * - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 983, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":984 - * __pyx_import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 984, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(2, 984, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":981 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - __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_L8_try_end:; - } - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":980 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":986 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - 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_RefNannySetupContext("import_umath", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":987 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __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:*/ { - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":988 - * cdef inline int import_umath() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 988, __pyx_L3_error) - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":987 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - } - __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:; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":989 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - * - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 989, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":990 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 990, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(2, 990, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":987 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __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_L8_try_end:; - } - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":986 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":992 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - 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_RefNannySetupContext("import_ufunc", 1); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":993 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __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:*/ { - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":994 - * cdef inline int import_ufunc() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 994, __pyx_L3_error) - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":993 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - } - __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:; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":995 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - * - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 995, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":996 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 996, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(2, 996, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":993 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __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_L8_try_end:; - } - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":992 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":999 - * - * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` - */ - -static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { - int __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1011 - * bool - * """ - * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":999 - * - * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1014 - * - * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` - */ - -static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { - int __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1026 - * bool - * """ - * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1014 - * - * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1029 - * - * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object - */ - -static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { - npy_datetime __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1036 - * also needed. That can be found using `get_datetime64_unit`. - * """ - * return (obj).obval # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1029 - * - * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1039 - * - * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object - */ - -static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { - npy_timedelta __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1043 - * returns the int64 value underlying scalar numpy timedelta64 object - * """ - * return (obj).obval # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1039 - * - * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1046 - * - * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. - */ - -static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { - NPY_DATETIMEUNIT __pyx_r; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1050 - * returns the unit part of the dtype for a numpy datetime64 object. - * """ - * return (obj).obmeta.base # <<<<<<<<<<<<<< - */ - __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); - goto __pyx_L0; - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1046 - * - * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":23 - * cimport numpy as np - * - * cdef np.ndarray[double, ndim=2] matrix2numpy(Matrix3 m): # <<<<<<<<<<<<<< - * return np.array([ - * [m(0, 0), m(0, 1), m(0, 2)], - */ - -static PyArrayObject *__pyx_f_6common_15transformations_15transformations_matrix2numpy(Eigen::Matrix3d __pyx_v_m) { - PyArrayObject *__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; - int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("matrix2numpy", 1); - - /* "common/transformations/transformations.pyx":24 - * - * cdef np.ndarray[double, ndim=2] matrix2numpy(Matrix3 m): - * return np.array([ # <<<<<<<<<<<<<< - * [m(0, 0), m(0, 1), m(0, 2)], - * [m(1, 0), m(1, 1), m(1, 2)], - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":25 - * cdef np.ndarray[double, ndim=2] matrix2numpy(Matrix3 m): - * return np.array([ - * [m(0, 0), m(0, 1), m(0, 2)], # <<<<<<<<<<<<<< - * [m(1, 0), m(1, 1), m(1, 2)], - * [m(2, 0), m(2, 1), m(2, 2)], - */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_m(0, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_m(0, 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_m(0, 2)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyList_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 25, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - - /* "common/transformations/transformations.pyx":26 - * return np.array([ - * [m(0, 0), m(0, 1), m(0, 2)], - * [m(1, 0), m(1, 1), m(1, 2)], # <<<<<<<<<<<<<< - * [m(2, 0), m(2, 1), m(2, 2)], - * ]) - */ - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_m(1, 0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_m(1, 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_m(1, 2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyList_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error); - __pyx_t_5 = 0; - __pyx_t_4 = 0; - __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":27 - * [m(0, 0), m(0, 1), m(0, 2)], - * [m(1, 0), m(1, 1), m(1, 2)], - * [m(2, 0), m(2, 1), m(2, 2)], # <<<<<<<<<<<<<< - * ]) - * - */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_m(2, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_m(2, 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_m(2, 2)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_4)) __PYX_ERR(0, 27, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_5)) __PYX_ERR(0, 27, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - - /* "common/transformations/transformations.pyx":24 - * - * cdef np.ndarray[double, ndim=2] matrix2numpy(Matrix3 m): - * return np.array([ # <<<<<<<<<<<<<< - * [m(0, 0), m(0, 1), m(0, 2)], - * [m(1, 0), m(1, 1), m(1, 2)], - */ - __pyx_t_5 = PyList_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_6)) __PYX_ERR(0, 24, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_7)) __PYX_ERR(0, 24, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_8); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_8)) __PYX_ERR(0, 24, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_8 = 0; - __pyx_t_8 = NULL; - __pyx_t_9 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_9 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 24, __pyx_L1_error) - __pyx_r = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":23 - * cimport numpy as np - * - * cdef np.ndarray[double, ndim=2] matrix2numpy(Matrix3 m): # <<<<<<<<<<<<<< - * return np.array([ - * [m(0, 0), m(0, 1), m(0, 2)], - */ - - /* 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_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("common.transformations.transformations.matrix2numpy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":30 - * ]) - * - * cdef Matrix3 numpy2matrix(np.ndarray[double, ndim=2, mode="fortran"] m): # <<<<<<<<<<<<<< - * assert m.shape[0] == 3 - * assert m.shape[1] == 3 - */ - -static Eigen::Matrix3d __pyx_f_6common_15transformations_15transformations_numpy2matrix(PyArrayObject *__pyx_v_m) { - __Pyx_LocalBuf_ND __pyx_pybuffernd_m; - __Pyx_Buffer __pyx_pybuffer_m; - Eigen::Matrix3d __pyx_r; - npy_intp *__pyx_t_1; - int __pyx_t_2; - char *__pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __pyx_pybuffer_m.pybuffer.buf = NULL; - __pyx_pybuffer_m.refcount = 0; - __pyx_pybuffernd_m.data = NULL; - __pyx_pybuffernd_m.rcbuffer = &__pyx_pybuffer_m; - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_m.rcbuffer->pybuffer, (PyObject*)__pyx_v_m, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 30, __pyx_L1_error) - } - __pyx_pybuffernd_m.diminfo[0].strides = __pyx_pybuffernd_m.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_m.diminfo[0].shape = __pyx_pybuffernd_m.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_m.diminfo[1].strides = __pyx_pybuffernd_m.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_m.diminfo[1].shape = __pyx_pybuffernd_m.rcbuffer->pybuffer.shape[1]; - - /* "common/transformations/transformations.pyx":31 - * - * cdef Matrix3 numpy2matrix(np.ndarray[double, ndim=2, mode="fortran"] m): - * assert m.shape[0] == 3 # <<<<<<<<<<<<<< - * assert m.shape[1] == 3 - * return Matrix3(m.data) - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_m)); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L1_error) - __pyx_t_2 = ((__pyx_t_1[0]) == 3); - if (unlikely(!__pyx_t_2)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 31, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 31, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":32 - * cdef Matrix3 numpy2matrix(np.ndarray[double, ndim=2, mode="fortran"] m): - * assert m.shape[0] == 3 - * assert m.shape[1] == 3 # <<<<<<<<<<<<<< - * return Matrix3(m.data) - * - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = __pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_m)); if (unlikely(__pyx_t_1 == ((npy_intp *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L1_error) - __pyx_t_2 = ((__pyx_t_1[1]) == 3); - if (unlikely(!__pyx_t_2)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 32, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 32, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":33 - * assert m.shape[0] == 3 - * assert m.shape[1] == 3 - * return Matrix3(m.data) # <<<<<<<<<<<<<< - * - * cdef ECEF list2ecef(ecef): - */ - __pyx_t_3 = __pyx_f_5numpy_7ndarray_4data_data(((PyArrayObject *)__pyx_v_m)); if (unlikely(__pyx_t_3 == ((char *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 33, __pyx_L1_error) - __pyx_r = Eigen::Matrix3d(((double *)__pyx_t_3)); - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":30 - * ]) - * - * cdef Matrix3 numpy2matrix(np.ndarray[double, ndim=2, mode="fortran"] m): # <<<<<<<<<<<<<< - * assert m.shape[0] == 3 - * assert m.shape[1] == 3 - */ - - /* function exit code */ - __pyx_L1_error:; - { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer); - __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} - __Pyx_AddTraceback("common.transformations.transformations.numpy2matrix", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - goto __pyx_L2; - __pyx_L0:; - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer); - __pyx_L2:; - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":35 - * return Matrix3(m.data) - * - * cdef ECEF list2ecef(ecef): # <<<<<<<<<<<<<< - * cdef ECEF e - * e.x = ecef[0] - */ - -static struct ECEF __pyx_f_6common_15transformations_15transformations_list2ecef(PyObject *__pyx_v_ecef) { - struct ECEF __pyx_v_e; - struct ECEF __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("list2ecef", 1); - - /* "common/transformations/transformations.pyx":37 - * cdef ECEF list2ecef(ecef): - * cdef ECEF e - * e.x = ecef[0] # <<<<<<<<<<<<<< - * e.y = ecef[1] - * e.z = ecef[2] - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ecef, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_e.x = __pyx_t_2; - - /* "common/transformations/transformations.pyx":38 - * cdef ECEF e - * e.x = ecef[0] - * e.y = ecef[1] # <<<<<<<<<<<<<< - * e.z = ecef[2] - * return e - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ecef, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_e.y = __pyx_t_2; - - /* "common/transformations/transformations.pyx":39 - * e.x = ecef[0] - * e.y = ecef[1] - * e.z = ecef[2] # <<<<<<<<<<<<<< - * return e - * - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ecef, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_e.z = __pyx_t_2; - - /* "common/transformations/transformations.pyx":40 - * e.y = ecef[1] - * e.z = ecef[2] - * return e # <<<<<<<<<<<<<< - * - * cdef NED list2ned(ned): - */ - __pyx_r = __pyx_v_e; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":35 - * return Matrix3(m.data) - * - * cdef ECEF list2ecef(ecef): # <<<<<<<<<<<<<< - * cdef ECEF e - * e.x = ecef[0] - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.list2ecef", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":42 - * return e - * - * cdef NED list2ned(ned): # <<<<<<<<<<<<<< - * cdef NED n - * n.n = ned[0] - */ - -static struct NED __pyx_f_6common_15transformations_15transformations_list2ned(PyObject *__pyx_v_ned) { - struct NED __pyx_v_n; - struct NED __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("list2ned", 1); - - /* "common/transformations/transformations.pyx":44 - * cdef NED list2ned(ned): - * cdef NED n - * n.n = ned[0] # <<<<<<<<<<<<<< - * n.e = ned[1] - * n.d = ned[2] - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ned, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_n.n = __pyx_t_2; - - /* "common/transformations/transformations.pyx":45 - * cdef NED n - * n.n = ned[0] - * n.e = ned[1] # <<<<<<<<<<<<<< - * n.d = ned[2] - * return n - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ned, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_n.e = __pyx_t_2; - - /* "common/transformations/transformations.pyx":46 - * n.n = ned[0] - * n.e = ned[1] - * n.d = ned[2] # <<<<<<<<<<<<<< - * return n - * - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_ned, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_n.d = __pyx_t_2; - - /* "common/transformations/transformations.pyx":47 - * n.e = ned[1] - * n.d = ned[2] - * return n # <<<<<<<<<<<<<< - * - * cdef Geodetic list2geodetic(geodetic): - */ - __pyx_r = __pyx_v_n; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":42 - * return e - * - * cdef NED list2ned(ned): # <<<<<<<<<<<<<< - * cdef NED n - * n.n = ned[0] - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.list2ned", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":49 - * return n - * - * cdef Geodetic list2geodetic(geodetic): # <<<<<<<<<<<<<< - * cdef Geodetic g - * g.lat = geodetic[0] - */ - -static struct Geodetic __pyx_f_6common_15transformations_15transformations_list2geodetic(PyObject *__pyx_v_geodetic) { - struct Geodetic __pyx_v_g; - struct Geodetic __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("list2geodetic", 1); - - /* "common/transformations/transformations.pyx":51 - * cdef Geodetic list2geodetic(geodetic): - * cdef Geodetic g - * g.lat = geodetic[0] # <<<<<<<<<<<<<< - * g.lon = geodetic[1] - * g.alt = geodetic[2] - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_geodetic, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_g.lat = __pyx_t_2; - - /* "common/transformations/transformations.pyx":52 - * cdef Geodetic g - * g.lat = geodetic[0] - * g.lon = geodetic[1] # <<<<<<<<<<<<<< - * g.alt = geodetic[2] - * return g - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_geodetic, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_g.lon = __pyx_t_2; - - /* "common/transformations/transformations.pyx":53 - * g.lat = geodetic[0] - * g.lon = geodetic[1] - * g.alt = geodetic[2] # <<<<<<<<<<<<<< - * return g - * - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_geodetic, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_g.alt = __pyx_t_2; - - /* "common/transformations/transformations.pyx":54 - * g.lon = geodetic[1] - * g.alt = geodetic[2] - * return g # <<<<<<<<<<<<<< - * - * def euler2quat_single(euler): - */ - __pyx_r = __pyx_v_g; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":49 - * return n - * - * cdef Geodetic list2geodetic(geodetic): # <<<<<<<<<<<<<< - * cdef Geodetic g - * g.lat = geodetic[0] - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.list2geodetic", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":56 - * return g - * - * def euler2quat_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Quaternion q = euler2quat_c(e) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_1euler2quat_single(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_6common_15transformations_15transformations_1euler2quat_single = {"euler2quat_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_1euler2quat_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_1euler2quat_single(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_euler = 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("euler2quat_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_euler,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_euler)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 56, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "euler2quat_single") < 0)) __PYX_ERR(0, 56, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_euler = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("euler2quat_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 56, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.euler2quat_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_euler2quat_single(__pyx_self, __pyx_v_euler); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_euler2quat_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_euler) { - Eigen::Vector3d __pyx_v_e; - Eigen::Quaterniond __pyx_v_q; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - double __pyx_t_3; - double __pyx_t_4; - 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_RefNannySetupContext("euler2quat_single", 1); - - /* "common/transformations/transformations.pyx":57 - * - * def euler2quat_single(euler): - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) # <<<<<<<<<<<<<< - * cdef Quaternion q = euler2quat_c(e) - * return [q.w(), q.x(), q.y(), q.z()] - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_euler, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_euler, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_euler, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 57, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_e = Eigen::Vector3d(__pyx_t_2, __pyx_t_3, __pyx_t_4); - - /* "common/transformations/transformations.pyx":58 - * def euler2quat_single(euler): - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Quaternion q = euler2quat_c(e) # <<<<<<<<<<<<<< - * return [q.w(), q.x(), q.y(), q.z()] - * - */ - __pyx_v_q = euler2quat(__pyx_v_e); - - /* "common/transformations/transformations.pyx":59 - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Quaternion q = euler2quat_c(e) - * return [q.w(), q.x(), q.y(), q.z()] # <<<<<<<<<<<<<< - * - * def quat2euler_single(quat): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_q.w()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_q.x()); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_q.y()); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_q.z()); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyList_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_5)) __PYX_ERR(0, 59, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_6)) __PYX_ERR(0, 59, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 3, __pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_5 = 0; - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":56 - * return g - * - * def euler2quat_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Quaternion q = euler2quat_c(e) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("common.transformations.transformations.euler2quat_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":61 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def quat2euler_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Vector3 e = quat2euler_c(q) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_3quat2euler_single(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_6common_15transformations_15transformations_3quat2euler_single = {"quat2euler_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_3quat2euler_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_3quat2euler_single(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_quat = 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("quat2euler_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_quat,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_quat)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "quat2euler_single") < 0)) __PYX_ERR(0, 61, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_quat = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("quat2euler_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 61, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.quat2euler_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_2quat2euler_single(__pyx_self, __pyx_v_quat); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_2quat2euler_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_quat) { - Eigen::Quaterniond __pyx_v_q; - Eigen::Vector3d __pyx_v_e; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - double __pyx_t_3; - double __pyx_t_4; - double __pyx_t_5; - 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_RefNannySetupContext("quat2euler_single", 1); - - /* "common/transformations/transformations.pyx":62 - * - * def quat2euler_single(quat): - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) # <<<<<<<<<<<<<< - * cdef Vector3 e = quat2euler_c(q) - * return [e(0), e(1), e(2)] - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_q = Eigen::Quaterniond(__pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5); - - /* "common/transformations/transformations.pyx":63 - * def quat2euler_single(quat): - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Vector3 e = quat2euler_c(q) # <<<<<<<<<<<<<< - * return [e(0), e(1), e(2)] - * - */ - __pyx_v_e = quat2euler(__pyx_v_q); - - /* "common/transformations/transformations.pyx":64 - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Vector3 e = quat2euler_c(q) - * return [e(0), e(1), e(2)] # <<<<<<<<<<<<<< - * - * def quat2rot_single(quat): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_e(0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_e(1)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_e(2)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(0, 64, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(0, 64, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":61 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def quat2euler_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Vector3 e = quat2euler_c(q) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("common.transformations.transformations.quat2euler_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":66 - * return [e(0), e(1), e(2)] - * - * def quat2rot_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Matrix3 r = quat2rot_c(q) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_5quat2rot_single(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_6common_15transformations_15transformations_5quat2rot_single = {"quat2rot_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_5quat2rot_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_5quat2rot_single(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_quat = 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("quat2rot_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_quat,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_quat)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 66, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "quat2rot_single") < 0)) __PYX_ERR(0, 66, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_quat = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("quat2rot_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 66, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.quat2rot_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_4quat2rot_single(__pyx_self, __pyx_v_quat); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_4quat2rot_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_quat) { - Eigen::Quaterniond __pyx_v_q; - Eigen::Matrix3d __pyx_v_r; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - double __pyx_t_3; - double __pyx_t_4; - double __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("quat2rot_single", 1); - - /* "common/transformations/transformations.pyx":67 - * - * def quat2rot_single(quat): - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) # <<<<<<<<<<<<<< - * cdef Matrix3 r = quat2rot_c(q) - * return matrix2numpy(r) - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_quat, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_q = Eigen::Quaterniond(__pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5); - - /* "common/transformations/transformations.pyx":68 - * def quat2rot_single(quat): - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Matrix3 r = quat2rot_c(q) # <<<<<<<<<<<<<< - * return matrix2numpy(r) - * - */ - __pyx_v_r = quat2rot(__pyx_v_q); - - /* "common/transformations/transformations.pyx":69 - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Matrix3 r = quat2rot_c(q) - * return matrix2numpy(r) # <<<<<<<<<<<<<< - * - * def rot2quat_single(rot): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((PyObject *)__pyx_f_6common_15transformations_15transformations_matrix2numpy(__pyx_v_r)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":66 - * return [e(0), e(1), e(2)] - * - * def quat2rot_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Matrix3 r = quat2rot_c(q) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.quat2rot_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":71 - * return matrix2numpy(r) - * - * def rot2quat_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Quaternion q = rot2quat_c(r) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_7rot2quat_single(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_6common_15transformations_15transformations_7rot2quat_single = {"rot2quat_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_7rot2quat_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_7rot2quat_single(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_rot = 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("rot2quat_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_rot,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rot)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "rot2quat_single") < 0)) __PYX_ERR(0, 71, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_rot = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("rot2quat_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.rot2quat_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_6rot2quat_single(__pyx_self, __pyx_v_rot); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_6rot2quat_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rot) { - Eigen::Matrix3d __pyx_v_r; - Eigen::Quaterniond __pyx_v_q; - 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; - Eigen::Matrix3d __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("rot2quat_single", 1); - - /* "common/transformations/transformations.pyx":72 - * - * def rot2quat_single(rot): - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) # <<<<<<<<<<<<<< - * cdef Quaternion q = rot2quat_c(r) - * return [q.w(), q.x(), q.y(), q.z()] - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_rot); - __Pyx_GIVEREF(__pyx_v_rot); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_rot)) __PYX_ERR(0, 72, __pyx_L1_error); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_double); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 72, __pyx_L1_error) - __pyx_t_6 = __pyx_f_6common_15transformations_15transformations_numpy2matrix(((PyArrayObject *)__pyx_t_5)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_r = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_6); - - /* "common/transformations/transformations.pyx":73 - * def rot2quat_single(rot): - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Quaternion q = rot2quat_c(r) # <<<<<<<<<<<<<< - * return [q.w(), q.x(), q.y(), q.z()] - * - */ - __pyx_v_q = rot2quat(__pyx_v_r); - - /* "common/transformations/transformations.pyx":74 - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Quaternion q = rot2quat_c(r) - * return [q.w(), q.x(), q.y(), q.z()] # <<<<<<<<<<<<<< - * - * def euler2rot_single(euler): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_q.w()); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_q.x()); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_q.y()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_q.z()); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error); - __pyx_t_5 = 0; - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":71 - * return matrix2numpy(r) - * - * def rot2quat_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Quaternion q = rot2quat_c(r) - */ - - /* 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_AddTraceback("common.transformations.transformations.rot2quat_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":76 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def euler2rot_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Matrix3 r = euler2rot_c(e) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_9euler2rot_single(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_6common_15transformations_15transformations_9euler2rot_single = {"euler2rot_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_9euler2rot_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_9euler2rot_single(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_euler = 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("euler2rot_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_euler,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_euler)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "euler2rot_single") < 0)) __PYX_ERR(0, 76, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_euler = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("euler2rot_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 76, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.euler2rot_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_8euler2rot_single(__pyx_self, __pyx_v_euler); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_8euler2rot_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_euler) { - Eigen::Vector3d __pyx_v_e; - Eigen::Matrix3d __pyx_v_r; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - double __pyx_t_2; - double __pyx_t_3; - double __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("euler2rot_single", 1); - - /* "common/transformations/transformations.pyx":77 - * - * def euler2rot_single(euler): - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) # <<<<<<<<<<<<<< - * cdef Matrix3 r = euler2rot_c(e) - * return matrix2numpy(r) - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_euler, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_euler, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_euler, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_e = Eigen::Vector3d(__pyx_t_2, __pyx_t_3, __pyx_t_4); - - /* "common/transformations/transformations.pyx":78 - * def euler2rot_single(euler): - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Matrix3 r = euler2rot_c(e) # <<<<<<<<<<<<<< - * return matrix2numpy(r) - * - */ - __pyx_v_r = euler2rot(__pyx_v_e); - - /* "common/transformations/transformations.pyx":79 - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Matrix3 r = euler2rot_c(e) - * return matrix2numpy(r) # <<<<<<<<<<<<<< - * - * def rot2euler_single(rot): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((PyObject *)__pyx_f_6common_15transformations_15transformations_matrix2numpy(__pyx_v_r)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":76 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def euler2rot_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Matrix3 r = euler2rot_c(e) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.euler2rot_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":81 - * return matrix2numpy(r) - * - * def rot2euler_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Vector3 e = rot2euler_c(r) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_11rot2euler_single(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_6common_15transformations_15transformations_11rot2euler_single = {"rot2euler_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_11rot2euler_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_11rot2euler_single(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_rot = 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("rot2euler_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_rot,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rot)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 81, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "rot2euler_single") < 0)) __PYX_ERR(0, 81, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_rot = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("rot2euler_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 81, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.rot2euler_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10rot2euler_single(__pyx_self, __pyx_v_rot); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10rot2euler_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rot) { - Eigen::Matrix3d __pyx_v_r; - Eigen::Vector3d __pyx_v_e; - 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; - Eigen::Matrix3d __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("rot2euler_single", 1); - - /* "common/transformations/transformations.pyx":82 - * - * def rot2euler_single(rot): - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) # <<<<<<<<<<<<<< - * cdef Vector3 e = rot2euler_c(r) - * return [e(0), e(1), e(2)] - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_rot); - __Pyx_GIVEREF(__pyx_v_rot); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_rot)) __PYX_ERR(0, 82, __pyx_L1_error); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_double); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error) - __pyx_t_6 = __pyx_f_6common_15transformations_15transformations_numpy2matrix(((PyArrayObject *)__pyx_t_5)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_r = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_6); - - /* "common/transformations/transformations.pyx":83 - * def rot2euler_single(rot): - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Vector3 e = rot2euler_c(r) # <<<<<<<<<<<<<< - * return [e(0), e(1), e(2)] - * - */ - __pyx_v_e = rot2euler(__pyx_v_r); - - /* "common/transformations/transformations.pyx":84 - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Vector3 e = rot2euler_c(r) - * return [e(0), e(1), e(2)] # <<<<<<<<<<<<<< - * - * def rot_matrix(roll, pitch, yaw): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_e(0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_e(1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_e(2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_5)) __PYX_ERR(0, 84, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 2, __pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error); - __pyx_t_5 = 0; - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":81 - * return matrix2numpy(r) - * - * def rot2euler_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Vector3 e = rot2euler_c(r) - */ - - /* 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_AddTraceback("common.transformations.transformations.rot2euler_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":86 - * return [e(0), e(1), e(2)] - * - * def rot_matrix(roll, pitch, yaw): # <<<<<<<<<<<<<< - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_13rot_matrix(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_6common_15transformations_15transformations_13rot_matrix = {"rot_matrix", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_13rot_matrix, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_13rot_matrix(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_roll = 0; - PyObject *__pyx_v_pitch = 0; - PyObject *__pyx_v_yaw = 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("rot_matrix (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_roll,&__pyx_n_s_pitch,&__pyx_n_s_yaw,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_roll)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pitch)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("rot_matrix", 1, 3, 3, 1); __PYX_ERR(0, 86, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_yaw)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("rot_matrix", 1, 3, 3, 2); __PYX_ERR(0, 86, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "rot_matrix") < 0)) __PYX_ERR(0, 86, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - } - __pyx_v_roll = values[0]; - __pyx_v_pitch = values[1]; - __pyx_v_yaw = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("rot_matrix", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 86, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.rot_matrix", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_12rot_matrix(__pyx_self, __pyx_v_roll, __pyx_v_pitch, __pyx_v_yaw); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_12rot_matrix(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_roll, PyObject *__pyx_v_pitch, PyObject *__pyx_v_yaw) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - double __pyx_t_1; - double __pyx_t_2; - double __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("rot_matrix", 1); - - /* "common/transformations/transformations.pyx":87 - * - * def rot_matrix(roll, pitch, yaw): - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) # <<<<<<<<<<<<<< - * - * def ecef_euler_from_ned_single(ecef_init, ned_pose): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_roll); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error) - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_pitch); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error) - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_yaw); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error) - __pyx_t_4 = ((PyObject *)__pyx_f_6common_15transformations_15transformations_matrix2numpy(rot_matrix(__pyx_t_1, __pyx_t_2, __pyx_t_3))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":86 - * return [e(0), e(1), e(2)] - * - * def rot_matrix(roll, pitch, yaw): # <<<<<<<<<<<<<< - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("common.transformations.transformations.rot_matrix", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":89 - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - * def ecef_euler_from_ned_single(ecef_init, ned_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_15ecef_euler_from_ned_single(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_6common_15transformations_15transformations_15ecef_euler_from_ned_single = {"ecef_euler_from_ned_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_15ecef_euler_from_ned_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_15ecef_euler_from_ned_single(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_ecef_init = 0; - PyObject *__pyx_v_ned_pose = 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("ecef_euler_from_ned_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ecef_init,&__pyx_n_s_ned_pose,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef_init)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ned_pose)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ecef_euler_from_ned_single", 1, 2, 2, 1); __PYX_ERR(0, 89, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ecef_euler_from_ned_single") < 0)) __PYX_ERR(0, 89, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_ecef_init = values[0]; - __pyx_v_ned_pose = values[1]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ecef_euler_from_ned_single", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 89, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.ecef_euler_from_ned_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_14ecef_euler_from_ned_single(__pyx_self, __pyx_v_ecef_init, __pyx_v_ned_pose); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_14ecef_euler_from_ned_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ecef_init, PyObject *__pyx_v_ned_pose) { - struct ECEF __pyx_v_init; - Eigen::Vector3d __pyx_v_pose; - Eigen::Vector3d __pyx_v_e; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - struct ECEF __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - double __pyx_t_3; - double __pyx_t_4; - double __pyx_t_5; - 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_RefNannySetupContext("ecef_euler_from_ned_single", 1); - - /* "common/transformations/transformations.pyx":90 - * - * def ecef_euler_from_ned_single(ecef_init, ned_pose): - * cdef ECEF init = list2ecef(ecef_init) # <<<<<<<<<<<<<< - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) - * - */ - __pyx_t_1 = __pyx_f_6common_15transformations_15transformations_list2ecef(__pyx_v_ecef_init); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error) - __pyx_v_init = __pyx_t_1; - - /* "common/transformations/transformations.pyx":91 - * def ecef_euler_from_ned_single(ecef_init, ned_pose): - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) # <<<<<<<<<<<<<< - * - * cdef Vector3 e = ecef_euler_from_ned_c(init, pose) - */ - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ned_pose, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ned_pose, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ned_pose, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_pose = Eigen::Vector3d(__pyx_t_3, __pyx_t_4, __pyx_t_5); - - /* "common/transformations/transformations.pyx":93 - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) - * - * cdef Vector3 e = ecef_euler_from_ned_c(init, pose) # <<<<<<<<<<<<<< - * return [e(0), e(1), e(2)] - * - */ - __pyx_v_e = ecef_euler_from_ned(__pyx_v_init, __pyx_v_pose); - - /* "common/transformations/transformations.pyx":94 - * - * cdef Vector3 e = ecef_euler_from_ned_c(init, pose) - * return [e(0), e(1), e(2)] # <<<<<<<<<<<<<< - * - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_e(0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_e(1)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_e(2)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":89 - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - * def ecef_euler_from_ned_single(ecef_init, ned_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("common.transformations.transformations.ecef_euler_from_ned_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":96 - * return [e(0), e(1), e(2)] - * - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_17ned_euler_from_ecef_single(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_6common_15transformations_15transformations_17ned_euler_from_ecef_single = {"ned_euler_from_ecef_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_17ned_euler_from_ecef_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_17ned_euler_from_ecef_single(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_ecef_init = 0; - PyObject *__pyx_v_ecef_pose = 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("ned_euler_from_ecef_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ecef_init,&__pyx_n_s_ecef_pose,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef_init)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef_pose)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("ned_euler_from_ecef_single", 1, 2, 2, 1); __PYX_ERR(0, 96, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ned_euler_from_ecef_single") < 0)) __PYX_ERR(0, 96, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 2)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - } - __pyx_v_ecef_init = values[0]; - __pyx_v_ecef_pose = values[1]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ned_euler_from_ecef_single", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 96, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.ned_euler_from_ecef_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_16ned_euler_from_ecef_single(__pyx_self, __pyx_v_ecef_init, __pyx_v_ecef_pose); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_16ned_euler_from_ecef_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ecef_init, PyObject *__pyx_v_ecef_pose) { - struct ECEF __pyx_v_init; - Eigen::Vector3d __pyx_v_pose; - Eigen::Vector3d __pyx_v_e; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - struct ECEF __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - double __pyx_t_3; - double __pyx_t_4; - double __pyx_t_5; - 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_RefNannySetupContext("ned_euler_from_ecef_single", 1); - - /* "common/transformations/transformations.pyx":97 - * - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): - * cdef ECEF init = list2ecef(ecef_init) # <<<<<<<<<<<<<< - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) - * - */ - __pyx_t_1 = __pyx_f_6common_15transformations_15transformations_list2ecef(__pyx_v_ecef_init); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) - __pyx_v_init = __pyx_t_1; - - /* "common/transformations/transformations.pyx":98 - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) # <<<<<<<<<<<<<< - * - * cdef Vector3 e = ned_euler_from_ecef_c(init, pose) - */ - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ecef_pose, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ecef_pose, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_ecef_pose, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_pose = Eigen::Vector3d(__pyx_t_3, __pyx_t_4, __pyx_t_5); - - /* "common/transformations/transformations.pyx":100 - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) - * - * cdef Vector3 e = ned_euler_from_ecef_c(init, pose) # <<<<<<<<<<<<<< - * return [e(0), e(1), e(2)] - * - */ - __pyx_v_e = ned_euler_from_ecef(__pyx_v_init, __pyx_v_pose); - - /* "common/transformations/transformations.pyx":101 - * - * cdef Vector3 e = ned_euler_from_ecef_c(init, pose) - * return [e(0), e(1), e(2)] # <<<<<<<<<<<<<< - * - * def geodetic2ecef_single(geodetic): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_e(0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_e(1)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_e(2)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(0, 101, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(0, 101, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_r = __pyx_t_8; - __pyx_t_8 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":96 - * return [e(0), e(1), e(2)] - * - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("common.transformations.transformations.ned_euler_from_ecef_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":103 - * return [e(0), e(1), e(2)] - * - * def geodetic2ecef_single(geodetic): # <<<<<<<<<<<<<< - * cdef Geodetic g = list2geodetic(geodetic) - * cdef ECEF e = geodetic2ecef_c(g) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_19geodetic2ecef_single(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_6common_15transformations_15transformations_19geodetic2ecef_single = {"geodetic2ecef_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_19geodetic2ecef_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_19geodetic2ecef_single(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_geodetic = 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("geodetic2ecef_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_geodetic,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_geodetic)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 103, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "geodetic2ecef_single") < 0)) __PYX_ERR(0, 103, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_geodetic = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("geodetic2ecef_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 103, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.geodetic2ecef_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_18geodetic2ecef_single(__pyx_self, __pyx_v_geodetic); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_18geodetic2ecef_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_geodetic) { - struct Geodetic __pyx_v_g; - struct ECEF __pyx_v_e; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - struct Geodetic __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("geodetic2ecef_single", 1); - - /* "common/transformations/transformations.pyx":104 - * - * def geodetic2ecef_single(geodetic): - * cdef Geodetic g = list2geodetic(geodetic) # <<<<<<<<<<<<<< - * cdef ECEF e = geodetic2ecef_c(g) - * return [e.x, e.y, e.z] - */ - __pyx_t_1 = __pyx_f_6common_15transformations_15transformations_list2geodetic(__pyx_v_geodetic); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) - __pyx_v_g = __pyx_t_1; - - /* "common/transformations/transformations.pyx":105 - * def geodetic2ecef_single(geodetic): - * cdef Geodetic g = list2geodetic(geodetic) - * cdef ECEF e = geodetic2ecef_c(g) # <<<<<<<<<<<<<< - * return [e.x, e.y, e.z] - * - */ - __pyx_v_e = geodetic2ecef(__pyx_v_g); - - /* "common/transformations/transformations.pyx":106 - * cdef Geodetic g = list2geodetic(geodetic) - * cdef ECEF e = geodetic2ecef_c(g) - * return [e.x, e.y, e.z] # <<<<<<<<<<<<<< - * - * def ecef2geodetic_single(ecef): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_e.x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_e.y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_e.z); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyList_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":103 - * return [e(0), e(1), e(2)] - * - * def geodetic2ecef_single(geodetic): # <<<<<<<<<<<<<< - * cdef Geodetic g = list2geodetic(geodetic) - * cdef ECEF e = geodetic2ecef_c(g) - */ - - /* function exit code */ - __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("common.transformations.transformations.geodetic2ecef_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":108 - * return [e.x, e.y, e.z] - * - * def ecef2geodetic_single(ecef): # <<<<<<<<<<<<<< - * cdef ECEF e = list2ecef(ecef) - * cdef Geodetic g = ecef2geodetic_c(e) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_21ecef2geodetic_single(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_6common_15transformations_15transformations_21ecef2geodetic_single = {"ecef2geodetic_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_21ecef2geodetic_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_21ecef2geodetic_single(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_ecef = 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("ecef2geodetic_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ecef,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ecef2geodetic_single") < 0)) __PYX_ERR(0, 108, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_ecef = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ecef2geodetic_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 108, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.ecef2geodetic_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_20ecef2geodetic_single(__pyx_self, __pyx_v_ecef); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_20ecef2geodetic_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ecef) { - struct ECEF __pyx_v_e; - struct Geodetic __pyx_v_g; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - struct ECEF __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ecef2geodetic_single", 1); - - /* "common/transformations/transformations.pyx":109 - * - * def ecef2geodetic_single(ecef): - * cdef ECEF e = list2ecef(ecef) # <<<<<<<<<<<<<< - * cdef Geodetic g = ecef2geodetic_c(e) - * return [g.lat, g.lon, g.alt] - */ - __pyx_t_1 = __pyx_f_6common_15transformations_15transformations_list2ecef(__pyx_v_ecef); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 109, __pyx_L1_error) - __pyx_v_e = __pyx_t_1; - - /* "common/transformations/transformations.pyx":110 - * def ecef2geodetic_single(ecef): - * cdef ECEF e = list2ecef(ecef) - * cdef Geodetic g = ecef2geodetic_c(e) # <<<<<<<<<<<<<< - * return [g.lat, g.lon, g.alt] - * - */ - __pyx_v_g = ecef2geodetic(__pyx_v_e); - - /* "common/transformations/transformations.pyx":111 - * cdef ECEF e = list2ecef(ecef) - * cdef Geodetic g = ecef2geodetic_c(e) - * return [g.lat, g.lon, g.alt] # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_g.lat); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_g.lon); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_g.alt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyList_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":108 - * return [e.x, e.y, e.z] - * - * def ecef2geodetic_single(ecef): # <<<<<<<<<<<<<< - * cdef ECEF e = list2ecef(ecef) - * cdef Geodetic g = ecef2geodetic_c(e) - */ - - /* function exit code */ - __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("common.transformations.transformations.ecef2geodetic_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":117 - * cdef LocalCoord_c * lc - * - * def __init__(self, geodetic=None, ecef=None): # <<<<<<<<<<<<<< - * assert (geodetic is not None) or (ecef is not None) - * if geodetic is not None: - */ - -/* Python wrapper */ -static int __pyx_pw_6common_15transformations_15transformations_10LocalCoord_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_6common_15transformations_15transformations_10LocalCoord_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_geodetic = 0; - PyObject *__pyx_v_ecef = 0; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_geodetic,&__pyx_n_s_ecef,0}; - values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); - values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_geodetic); - if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef); - if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 117, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_geodetic = values[0]; - __pyx_v_ecef = values[1]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 117, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord___init__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self), __pyx_v_geodetic, __pyx_v_ecef); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_6common_15transformations_15transformations_10LocalCoord___init__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_geodetic, PyObject *__pyx_v_ecef) { - int __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - struct Geodetic __pyx_t_3; - struct ECEF __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "common/transformations/transformations.pyx":118 - * - * def __init__(self, geodetic=None, ecef=None): - * assert (geodetic is not None) or (ecef is not None) # <<<<<<<<<<<<<< - * if geodetic is not None: - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_2 = (__pyx_v_geodetic != Py_None); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L3_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_ecef != Py_None); - __pyx_t_1 = __pyx_t_2; - __pyx_L3_bool_binop_done:; - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 118, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 118, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":119 - * def __init__(self, geodetic=None, ecef=None): - * assert (geodetic is not None) or (ecef is not None) - * if geodetic is not None: # <<<<<<<<<<<<<< - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) - * elif ecef is not None: - */ - __pyx_t_1 = (__pyx_v_geodetic != Py_None); - if (__pyx_t_1) { - - /* "common/transformations/transformations.pyx":120 - * assert (geodetic is not None) or (ecef is not None) - * if geodetic is not None: - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) # <<<<<<<<<<<<<< - * elif ecef is not None: - * self.lc = new LocalCoord_c(list2ecef(ecef)) - */ - __pyx_t_3 = __pyx_f_6common_15transformations_15transformations_list2geodetic(__pyx_v_geodetic); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L1_error) - __pyx_v_self->lc = new LocalCoord(__pyx_t_3); - - /* "common/transformations/transformations.pyx":119 - * def __init__(self, geodetic=None, ecef=None): - * assert (geodetic is not None) or (ecef is not None) - * if geodetic is not None: # <<<<<<<<<<<<<< - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) - * elif ecef is not None: - */ - goto __pyx_L5; - } - - /* "common/transformations/transformations.pyx":121 - * if geodetic is not None: - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) - * elif ecef is not None: # <<<<<<<<<<<<<< - * self.lc = new LocalCoord_c(list2ecef(ecef)) - * - */ - __pyx_t_1 = (__pyx_v_ecef != Py_None); - if (__pyx_t_1) { - - /* "common/transformations/transformations.pyx":122 - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) - * elif ecef is not None: - * self.lc = new LocalCoord_c(list2ecef(ecef)) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_t_4 = __pyx_f_6common_15transformations_15transformations_list2ecef(__pyx_v_ecef); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error) - __pyx_v_self->lc = new LocalCoord(__pyx_t_4); - - /* "common/transformations/transformations.pyx":121 - * if geodetic is not None: - * self.lc = new LocalCoord_c(list2geodetic(geodetic)) - * elif ecef is not None: # <<<<<<<<<<<<<< - * self.lc = new LocalCoord_c(list2ecef(ecef)) - * - */ - } - __pyx_L5:; - - /* "common/transformations/transformations.pyx":117 - * cdef LocalCoord_c * lc - * - * def __init__(self, geodetic=None, ecef=None): # <<<<<<<<<<<<<< - * assert (geodetic is not None) or (ecef is not None) - * if geodetic is not None: - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":124 - * self.lc = new LocalCoord_c(list2ecef(ecef)) - * - * @property # <<<<<<<<<<<<<< - * def ned2ecef_matrix(self): - * return matrix2numpy(self.lc.ned2ecef_matrix) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_15ned2ecef_matrix_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_15ned2ecef_matrix_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_15ned2ecef_matrix___get__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_15ned2ecef_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self) { - 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("__get__", 1); - - /* "common/transformations/transformations.pyx":126 - * @property - * def ned2ecef_matrix(self): - * return matrix2numpy(self.lc.ned2ecef_matrix) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((PyObject *)__pyx_f_6common_15transformations_15transformations_matrix2numpy(__pyx_v_self->lc->ned2ecef_matrix)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":124 - * self.lc = new LocalCoord_c(list2ecef(ecef)) - * - * @property # <<<<<<<<<<<<<< - * def ned2ecef_matrix(self): - * return matrix2numpy(self.lc.ned2ecef_matrix) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ned2ecef_matrix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":128 - * return matrix2numpy(self.lc.ned2ecef_matrix) - * - * @property # <<<<<<<<<<<<<< - * def ecef2ned_matrix(self): - * return matrix2numpy(self.lc.ecef2ned_matrix) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_15ecef2ned_matrix_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_15ecef2ned_matrix_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_15ecef2ned_matrix___get__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_15ecef2ned_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self) { - 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("__get__", 1); - - /* "common/transformations/transformations.pyx":130 - * @property - * def ecef2ned_matrix(self): - * return matrix2numpy(self.lc.ecef2ned_matrix) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((PyObject *)__pyx_f_6common_15transformations_15transformations_matrix2numpy(__pyx_v_self->lc->ecef2ned_matrix)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":128 - * return matrix2numpy(self.lc.ned2ecef_matrix) - * - * @property # <<<<<<<<<<<<<< - * def ecef2ned_matrix(self): - * return matrix2numpy(self.lc.ecef2ned_matrix) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ecef2ned_matrix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":132 - * return matrix2numpy(self.lc.ecef2ned_matrix) - * - * @property # <<<<<<<<<<<<<< - * def ned_from_ecef_matrix(self): - * return self.ecef2ned_matrix - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_20ned_from_ecef_matrix_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_20ned_from_ecef_matrix_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_20ned_from_ecef_matrix___get__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_20ned_from_ecef_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self) { - 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("__get__", 1); - - /* "common/transformations/transformations.pyx":134 - * @property - * def ned_from_ecef_matrix(self): - * return self.ecef2ned_matrix # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ecef2ned_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":132 - * return matrix2numpy(self.lc.ecef2ned_matrix) - * - * @property # <<<<<<<<<<<<<< - * def ned_from_ecef_matrix(self): - * return self.ecef2ned_matrix - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ned_from_ecef_matrix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":136 - * return self.ecef2ned_matrix - * - * @property # <<<<<<<<<<<<<< - * def ecef_from_ned_matrix(self): - * return self.ned2ecef_matrix - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_20ecef_from_ned_matrix_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_20ecef_from_ned_matrix_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_20ecef_from_ned_matrix___get__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_20ecef_from_ned_matrix___get__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self) { - 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("__get__", 1); - - /* "common/transformations/transformations.pyx":138 - * @property - * def ecef_from_ned_matrix(self): - * return self.ned2ecef_matrix # <<<<<<<<<<<<<< - * - * @classmethod - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ned2ecef_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":136 - * return self.ecef2ned_matrix - * - * @property # <<<<<<<<<<<<<< - * def ecef_from_ned_matrix(self): - * return self.ned2ecef_matrix - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ecef_from_ned_matrix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":140 - * return self.ned2ecef_matrix - * - * @classmethod # <<<<<<<<<<<<<< - * def from_geodetic(cls, geodetic): - * return cls(geodetic=geodetic) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_3from_geodetic(PyObject *__pyx_v_cls, -#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_6common_15transformations_15transformations_10LocalCoord_3from_geodetic = {"from_geodetic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_3from_geodetic, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_3from_geodetic(PyObject *__pyx_v_cls, -#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_geodetic = 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("from_geodetic (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_geodetic,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_geodetic)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 140, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "from_geodetic") < 0)) __PYX_ERR(0, 140, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_geodetic = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("from_geodetic", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 140, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.from_geodetic", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_2from_geodetic(((PyTypeObject*)__pyx_v_cls), __pyx_v_geodetic); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_2from_geodetic(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_geodetic) { - 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("from_geodetic", 1); - - /* "common/transformations/transformations.pyx":142 - * @classmethod - * def from_geodetic(cls, geodetic): - * return cls(geodetic=geodetic) # <<<<<<<<<<<<<< - * - * @classmethod - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_geodetic, __pyx_v_geodetic) < 0) __PYX_ERR(0, 142, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_v_cls), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":140 - * return self.ned2ecef_matrix - * - * @classmethod # <<<<<<<<<<<<<< - * def from_geodetic(cls, geodetic): - * return cls(geodetic=geodetic) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.from_geodetic", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":144 - * return cls(geodetic=geodetic) - * - * @classmethod # <<<<<<<<<<<<<< - * def from_ecef(cls, ecef): - * return cls(ecef=ecef) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_5from_ecef(PyObject *__pyx_v_cls, -#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_6common_15transformations_15transformations_10LocalCoord_5from_ecef = {"from_ecef", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_5from_ecef, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_5from_ecef(PyObject *__pyx_v_cls, -#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_ecef = 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("from_ecef (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ecef,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "from_ecef") < 0)) __PYX_ERR(0, 144, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_ecef = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("from_ecef", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 144, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.from_ecef", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_4from_ecef(((PyTypeObject*)__pyx_v_cls), __pyx_v_ecef); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_4from_ecef(PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_ecef) { - 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("from_ecef", 1); - - /* "common/transformations/transformations.pyx":146 - * @classmethod - * def from_ecef(cls, ecef): - * return cls(ecef=ecef) # <<<<<<<<<<<<<< - * - * def ecef2ned_single(self, ecef): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_ecef, __pyx_v_ecef) < 0) __PYX_ERR(0, 146, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_v_cls), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":144 - * return cls(geodetic=geodetic) - * - * @classmethod # <<<<<<<<<<<<<< - * def from_ecef(cls, ecef): - * return cls(ecef=ecef) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.from_ecef", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":148 - * return cls(ecef=ecef) - * - * def ecef2ned_single(self, ecef): # <<<<<<<<<<<<<< - * assert self.lc - * cdef ECEF e = list2ecef(ecef) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_7ecef2ned_single(PyObject *__pyx_v_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_6common_15transformations_15transformations_10LocalCoord_7ecef2ned_single = {"ecef2ned_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_7ecef2ned_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_7ecef2ned_single(PyObject *__pyx_v_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_ecef = 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("ecef2ned_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ecef,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ecef)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ecef2ned_single") < 0)) __PYX_ERR(0, 148, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_ecef = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ecef2ned_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 148, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ecef2ned_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_6ecef2ned_single(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self), __pyx_v_ecef); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_6ecef2ned_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_ecef) { - struct ECEF __pyx_v_e; - struct NED __pyx_v_n; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - struct ECEF __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ecef2ned_single", 1); - - /* "common/transformations/transformations.pyx":149 - * - * def ecef2ned_single(self, ecef): - * assert self.lc # <<<<<<<<<<<<<< - * cdef ECEF e = list2ecef(ecef) - * cdef NED n = self.lc.ecef2ned(e) - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = (__pyx_v_self->lc != 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 149, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 149, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":150 - * def ecef2ned_single(self, ecef): - * assert self.lc - * cdef ECEF e = list2ecef(ecef) # <<<<<<<<<<<<<< - * cdef NED n = self.lc.ecef2ned(e) - * return [n.n, n.e, n.d] - */ - __pyx_t_2 = __pyx_f_6common_15transformations_15transformations_list2ecef(__pyx_v_ecef); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 150, __pyx_L1_error) - __pyx_v_e = __pyx_t_2; - - /* "common/transformations/transformations.pyx":151 - * assert self.lc - * cdef ECEF e = list2ecef(ecef) - * cdef NED n = self.lc.ecef2ned(e) # <<<<<<<<<<<<<< - * return [n.n, n.e, n.d] - * - */ - __pyx_v_n = __pyx_v_self->lc->ecef2ned(__pyx_v_e); - - /* "common/transformations/transformations.pyx":152 - * cdef ECEF e = list2ecef(ecef) - * cdef NED n = self.lc.ecef2ned(e) - * return [n.n, n.e, n.d] # <<<<<<<<<<<<<< - * - * def ned2ecef_single(self, ned): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_n.n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_n.e); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_n.d); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyList_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":148 - * return cls(ecef=ecef) - * - * def ecef2ned_single(self, ecef): # <<<<<<<<<<<<<< - * assert self.lc - * cdef ECEF e = list2ecef(ecef) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ecef2ned_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":154 - * return [n.n, n.e, n.d] - * - * def ned2ecef_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_9ned2ecef_single(PyObject *__pyx_v_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_6common_15transformations_15transformations_10LocalCoord_9ned2ecef_single = {"ned2ecef_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_9ned2ecef_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_9ned2ecef_single(PyObject *__pyx_v_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_ned = 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("ned2ecef_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ned,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ned)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ned2ecef_single") < 0)) __PYX_ERR(0, 154, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_ned = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ned2ecef_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 154, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ned2ecef_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_8ned2ecef_single(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self), __pyx_v_ned); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_8ned2ecef_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_ned) { - struct NED __pyx_v_n; - struct ECEF __pyx_v_e; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - struct NED __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ned2ecef_single", 1); - - /* "common/transformations/transformations.pyx":155 - * - * def ned2ecef_single(self, ned): - * assert self.lc # <<<<<<<<<<<<<< - * cdef NED n = list2ned(ned) - * cdef ECEF e = self.lc.ned2ecef(n) - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = (__pyx_v_self->lc != 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 155, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 155, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":156 - * def ned2ecef_single(self, ned): - * assert self.lc - * cdef NED n = list2ned(ned) # <<<<<<<<<<<<<< - * cdef ECEF e = self.lc.ned2ecef(n) - * return [e.x, e.y, e.z] - */ - __pyx_t_2 = __pyx_f_6common_15transformations_15transformations_list2ned(__pyx_v_ned); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 156, __pyx_L1_error) - __pyx_v_n = __pyx_t_2; - - /* "common/transformations/transformations.pyx":157 - * assert self.lc - * cdef NED n = list2ned(ned) - * cdef ECEF e = self.lc.ned2ecef(n) # <<<<<<<<<<<<<< - * return [e.x, e.y, e.z] - * - */ - __pyx_v_e = __pyx_v_self->lc->ned2ecef(__pyx_v_n); - - /* "common/transformations/transformations.pyx":158 - * cdef NED n = list2ned(ned) - * cdef ECEF e = self.lc.ned2ecef(n) - * return [e.x, e.y, e.z] # <<<<<<<<<<<<<< - * - * def geodetic2ned_single(self, geodetic): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_e.x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_e.y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_e.z); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyList_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":154 - * return [n.n, n.e, n.d] - * - * def ned2ecef_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ned2ecef_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":160 - * return [e.x, e.y, e.z] - * - * def geodetic2ned_single(self, geodetic): # <<<<<<<<<<<<<< - * assert self.lc - * cdef Geodetic g = list2geodetic(geodetic) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_11geodetic2ned_single(PyObject *__pyx_v_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_6common_15transformations_15transformations_10LocalCoord_11geodetic2ned_single = {"geodetic2ned_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_11geodetic2ned_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_11geodetic2ned_single(PyObject *__pyx_v_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_geodetic = 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("geodetic2ned_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_geodetic,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_geodetic)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "geodetic2ned_single") < 0)) __PYX_ERR(0, 160, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_geodetic = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("geodetic2ned_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 160, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.geodetic2ned_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_10geodetic2ned_single(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self), __pyx_v_geodetic); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_10geodetic2ned_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_geodetic) { - struct Geodetic __pyx_v_g; - struct NED __pyx_v_n; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - struct Geodetic __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("geodetic2ned_single", 1); - - /* "common/transformations/transformations.pyx":161 - * - * def geodetic2ned_single(self, geodetic): - * assert self.lc # <<<<<<<<<<<<<< - * cdef Geodetic g = list2geodetic(geodetic) - * cdef NED n = self.lc.geodetic2ned(g) - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = (__pyx_v_self->lc != 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 161, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 161, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":162 - * def geodetic2ned_single(self, geodetic): - * assert self.lc - * cdef Geodetic g = list2geodetic(geodetic) # <<<<<<<<<<<<<< - * cdef NED n = self.lc.geodetic2ned(g) - * return [n.n, n.e, n.d] - */ - __pyx_t_2 = __pyx_f_6common_15transformations_15transformations_list2geodetic(__pyx_v_geodetic); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 162, __pyx_L1_error) - __pyx_v_g = __pyx_t_2; - - /* "common/transformations/transformations.pyx":163 - * assert self.lc - * cdef Geodetic g = list2geodetic(geodetic) - * cdef NED n = self.lc.geodetic2ned(g) # <<<<<<<<<<<<<< - * return [n.n, n.e, n.d] - * - */ - __pyx_v_n = __pyx_v_self->lc->geodetic2ned(__pyx_v_g); - - /* "common/transformations/transformations.pyx":164 - * cdef Geodetic g = list2geodetic(geodetic) - * cdef NED n = self.lc.geodetic2ned(g) - * return [n.n, n.e, n.d] # <<<<<<<<<<<<<< - * - * def ned2geodetic_single(self, ned): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_n.n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_n.e); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_n.d); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyList_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 164, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":160 - * return [e.x, e.y, e.z] - * - * def geodetic2ned_single(self, geodetic): # <<<<<<<<<<<<<< - * assert self.lc - * cdef Geodetic g = list2geodetic(geodetic) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.geodetic2ned_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":166 - * return [n.n, n.e, n.d] - * - * def ned2geodetic_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_13ned2geodetic_single(PyObject *__pyx_v_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_6common_15transformations_15transformations_10LocalCoord_13ned2geodetic_single = {"ned2geodetic_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_13ned2geodetic_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_13ned2geodetic_single(PyObject *__pyx_v_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_ned = 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("ned2geodetic_single (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_ned,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ned)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 166, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ned2geodetic_single") < 0)) __PYX_ERR(0, 166, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_ned = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ned2geodetic_single", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 166, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ned2geodetic_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_12ned2geodetic_single(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self), __pyx_v_ned); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_12ned2geodetic_single(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, PyObject *__pyx_v_ned) { - struct NED __pyx_v_n; - struct Geodetic __pyx_v_g; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - struct NED __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ned2geodetic_single", 1); - - /* "common/transformations/transformations.pyx":167 - * - * def ned2geodetic_single(self, ned): - * assert self.lc # <<<<<<<<<<<<<< - * cdef NED n = list2ned(ned) - * cdef Geodetic g = self.lc.ned2geodetic(n) - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = (__pyx_v_self->lc != 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(0, 167, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(0, 167, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":168 - * def ned2geodetic_single(self, ned): - * assert self.lc - * cdef NED n = list2ned(ned) # <<<<<<<<<<<<<< - * cdef Geodetic g = self.lc.ned2geodetic(n) - * return [g.lat, g.lon, g.alt] - */ - __pyx_t_2 = __pyx_f_6common_15transformations_15transformations_list2ned(__pyx_v_ned); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 168, __pyx_L1_error) - __pyx_v_n = __pyx_t_2; - - /* "common/transformations/transformations.pyx":169 - * assert self.lc - * cdef NED n = list2ned(ned) - * cdef Geodetic g = self.lc.ned2geodetic(n) # <<<<<<<<<<<<<< - * return [g.lat, g.lon, g.alt] - * - */ - __pyx_v_g = __pyx_v_self->lc->ned2geodetic(__pyx_v_n); - - /* "common/transformations/transformations.pyx":170 - * cdef NED n = list2ned(ned) - * cdef Geodetic g = self.lc.ned2geodetic(n) - * return [g.lat, g.lon, g.alt] # <<<<<<<<<<<<<< - * - * def __dealloc__(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_g.lat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_g.lon); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_g.alt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyList_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "common/transformations/transformations.pyx":166 - * return [n.n, n.e, n.d] - * - * def ned2geodetic_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.ned2geodetic_single", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "common/transformations/transformations.pyx":172 - * return [g.lat, g.lon, g.alt] - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * del self.lc - */ - -/* Python wrapper */ -static void __pyx_pw_6common_15transformations_15transformations_10LocalCoord_15__dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_pw_6common_15transformations_15transformations_10LocalCoord_15__dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_pf_6common_15transformations_15transformations_10LocalCoord_14__dealloc__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_6common_15transformations_15transformations_10LocalCoord_14__dealloc__(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self) { - - /* "common/transformations/transformations.pyx":173 - * - * def __dealloc__(self): - * del self.lc # <<<<<<<<<<<<<< - */ - delete __pyx_v_self->lc; - - /* "common/transformations/transformations.pyx":172 - * return [g.lat, g.lon, g.alt] - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * del self.lc - */ - - /* function exit code */ -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_17__reduce_cython__(PyObject *__pyx_v_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_6common_15transformations_15transformations_10LocalCoord_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_17__reduce_cython__(PyObject *__pyx_v_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 -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_16__reduce_cython__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_lc_cannot_be_converted_to_a, 0, 0); - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_19__setstate_cython__(PyObject *__pyx_v_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_6common_15transformations_15transformations_10LocalCoord_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6common_15transformations_15transformations_10LocalCoord_19__setstate_cython__(PyObject *__pyx_v_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 -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 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("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __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 **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6common_15transformations_15transformations_10LocalCoord_18__setstate_cython__(((struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_6common_15transformations_15transformations_10LocalCoord_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_6common_15transformations_15transformations_LocalCoord *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":4 - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_lc_cannot_be_converted_to_a, 0, 0); - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("common.transformations.transformations.LocalCoord.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_tp_new_6common_15transformations_15transformations_LocalCoord(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 (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - return o; -} - -static void __pyx_tp_dealloc_6common_15transformations_15transformations_LocalCoord(PyObject *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)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_6common_15transformations_15transformations_LocalCoord) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_pw_6common_15transformations_15transformations_10LocalCoord_15__dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*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 PyObject *__pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ned2ecef_matrix(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6common_15transformations_15transformations_10LocalCoord_15ned2ecef_matrix_1__get__(o); -} - -static PyObject *__pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ecef2ned_matrix(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6common_15transformations_15transformations_10LocalCoord_15ecef2ned_matrix_1__get__(o); -} - -static PyObject *__pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ned_from_ecef_matrix(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6common_15transformations_15transformations_10LocalCoord_20ned_from_ecef_matrix_1__get__(o); -} - -static PyObject *__pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ecef_from_ned_matrix(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_6common_15transformations_15transformations_10LocalCoord_20ecef_from_ned_matrix_1__get__(o); -} - -static PyMethodDef __pyx_methods_6common_15transformations_15transformations_LocalCoord[] = { - {"from_geodetic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_3from_geodetic, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"from_ecef", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_5from_ecef, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"ecef2ned_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_7ecef2ned_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"ned2ecef_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_9ned2ecef_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"geodetic2ned_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_11geodetic2ned_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"ned2geodetic_single", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_13ned2geodetic_single, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_6common_15transformations_15transformations_LocalCoord[] = { - {(char *)"ned2ecef_matrix", __pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ned2ecef_matrix, 0, (char *)0, 0}, - {(char *)"ecef2ned_matrix", __pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ecef2ned_matrix, 0, (char *)0, 0}, - {(char *)"ned_from_ecef_matrix", __pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ned_from_ecef_matrix, 0, (char *)0, 0}, - {(char *)"ecef_from_ned_matrix", __pyx_getprop_6common_15transformations_15transformations_10LocalCoord_ecef_from_ned_matrix, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type_6common_15transformations_15transformations_LocalCoord_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_6common_15transformations_15transformations_LocalCoord}, - {Py_tp_methods, (void *)__pyx_methods_6common_15transformations_15transformations_LocalCoord}, - {Py_tp_getset, (void *)__pyx_getsets_6common_15transformations_15transformations_LocalCoord}, - {Py_tp_init, (void *)__pyx_pw_6common_15transformations_15transformations_10LocalCoord_1__init__}, - {Py_tp_new, (void *)__pyx_tp_new_6common_15transformations_15transformations_LocalCoord}, - {0, 0}, -}; -static PyType_Spec __pyx_type_6common_15transformations_15transformations_LocalCoord_spec = { - "common.transformations.transformations.LocalCoord", - sizeof(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, - __pyx_type_6common_15transformations_15transformations_LocalCoord_slots, -}; -#else - -static PyTypeObject __pyx_type_6common_15transformations_15transformations_LocalCoord = { - PyVarObject_HEAD_INIT(0, 0) - "common.transformations.transformations.""LocalCoord", /*tp_name*/ - sizeof(struct __pyx_obj_6common_15transformations_15transformations_LocalCoord), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6common_15transformations_15transformations_LocalCoord, /*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*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 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_BASETYPE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_6common_15transformations_15transformations_LocalCoord, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_6common_15transformations_15transformations_LocalCoord, /*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 - __pyx_pw_6common_15transformations_15transformations_10LocalCoord_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_6common_15transformations_15transformations_LocalCoord, /*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 PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #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 CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyMethodDef __pyx_methods[] = { - {"rot_matrix", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_6common_15transformations_15transformations_13rot_matrix, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#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 -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 0, 0, 1, 1}, - {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord, __pyx_k_LocalCoord, sizeof(__pyx_k_LocalCoord), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord___reduce_cython, __pyx_k_LocalCoord___reduce_cython, sizeof(__pyx_k_LocalCoord___reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord___setstate_cython, __pyx_k_LocalCoord___setstate_cython, sizeof(__pyx_k_LocalCoord___setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord_ecef2ned_single, __pyx_k_LocalCoord_ecef2ned_single, sizeof(__pyx_k_LocalCoord_ecef2ned_single), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord_from_ecef, __pyx_k_LocalCoord_from_ecef, sizeof(__pyx_k_LocalCoord_from_ecef), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord_from_geodetic, __pyx_k_LocalCoord_from_geodetic, sizeof(__pyx_k_LocalCoord_from_geodetic), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord_geodetic2ned_single, __pyx_k_LocalCoord_geodetic2ned_single, sizeof(__pyx_k_LocalCoord_geodetic2ned_single), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord_ned2ecef_single, __pyx_k_LocalCoord_ned2ecef_single, sizeof(__pyx_k_LocalCoord_ned2ecef_single), 0, 0, 1, 1}, - {&__pyx_n_s_LocalCoord_ned2geodetic_single, __pyx_k_LocalCoord_ned2geodetic_single, sizeof(__pyx_k_LocalCoord_ned2geodetic_single), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, - {&__pyx_n_s__42, __pyx_k__42, sizeof(__pyx_k__42), 0, 0, 1, 1}, - {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, - {&__pyx_n_s_asfortranarray, __pyx_k_asfortranarray, sizeof(__pyx_k_asfortranarray), 0, 0, 1, 1}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_cls, __pyx_k_cls, sizeof(__pyx_k_cls), 0, 0, 1, 1}, - {&__pyx_kp_s_common_transformations_transform, __pyx_k_common_transformations_transform, sizeof(__pyx_k_common_transformations_transform), 0, 0, 1, 0}, - {&__pyx_n_s_common_transformations_transform_2, __pyx_k_common_transformations_transform_2, sizeof(__pyx_k_common_transformations_transform_2), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, - {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, - {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, - {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1}, - {&__pyx_n_s_ecef, __pyx_k_ecef, sizeof(__pyx_k_ecef), 0, 0, 1, 1}, - {&__pyx_n_s_ecef2geodetic_single, __pyx_k_ecef2geodetic_single, sizeof(__pyx_k_ecef2geodetic_single), 0, 0, 1, 1}, - {&__pyx_n_s_ecef2ned_matrix, __pyx_k_ecef2ned_matrix, sizeof(__pyx_k_ecef2ned_matrix), 0, 0, 1, 1}, - {&__pyx_n_s_ecef2ned_single, __pyx_k_ecef2ned_single, sizeof(__pyx_k_ecef2ned_single), 0, 0, 1, 1}, - {&__pyx_n_s_ecef_euler_from_ned_single, __pyx_k_ecef_euler_from_ned_single, sizeof(__pyx_k_ecef_euler_from_ned_single), 0, 0, 1, 1}, - {&__pyx_n_s_ecef_init, __pyx_k_ecef_init, sizeof(__pyx_k_ecef_init), 0, 0, 1, 1}, - {&__pyx_n_s_ecef_pose, __pyx_k_ecef_pose, sizeof(__pyx_k_ecef_pose), 0, 0, 1, 1}, - {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, - {&__pyx_n_s_euler, __pyx_k_euler, sizeof(__pyx_k_euler), 0, 0, 1, 1}, - {&__pyx_n_s_euler2quat_single, __pyx_k_euler2quat_single, sizeof(__pyx_k_euler2quat_single), 0, 0, 1, 1}, - {&__pyx_n_s_euler2rot_single, __pyx_k_euler2rot_single, sizeof(__pyx_k_euler2rot_single), 0, 0, 1, 1}, - {&__pyx_n_s_from_ecef, __pyx_k_from_ecef, sizeof(__pyx_k_from_ecef), 0, 0, 1, 1}, - {&__pyx_n_s_from_geodetic, __pyx_k_from_geodetic, sizeof(__pyx_k_from_geodetic), 0, 0, 1, 1}, - {&__pyx_n_s_g, __pyx_k_g, sizeof(__pyx_k_g), 0, 0, 1, 1}, - {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, - {&__pyx_n_s_geodetic, __pyx_k_geodetic, sizeof(__pyx_k_geodetic), 0, 0, 1, 1}, - {&__pyx_n_s_geodetic2ecef_single, __pyx_k_geodetic2ecef_single, sizeof(__pyx_k_geodetic2ecef_single), 0, 0, 1, 1}, - {&__pyx_n_s_geodetic2ned_single, __pyx_k_geodetic2ned_single, sizeof(__pyx_k_geodetic2ned_single), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, - {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_ned, __pyx_k_ned, sizeof(__pyx_k_ned), 0, 0, 1, 1}, - {&__pyx_n_s_ned2ecef_matrix, __pyx_k_ned2ecef_matrix, sizeof(__pyx_k_ned2ecef_matrix), 0, 0, 1, 1}, - {&__pyx_n_s_ned2ecef_single, __pyx_k_ned2ecef_single, sizeof(__pyx_k_ned2ecef_single), 0, 0, 1, 1}, - {&__pyx_n_s_ned2geodetic_single, __pyx_k_ned2geodetic_single, sizeof(__pyx_k_ned2geodetic_single), 0, 0, 1, 1}, - {&__pyx_n_s_ned_euler_from_ecef_single, __pyx_k_ned_euler_from_ecef_single, sizeof(__pyx_k_ned_euler_from_ecef_single), 0, 0, 1, 1}, - {&__pyx_n_s_ned_pose, __pyx_k_ned_pose, sizeof(__pyx_k_ned_pose), 0, 0, 1, 1}, - {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, - {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, - {&__pyx_n_s_pitch, __pyx_k_pitch, sizeof(__pyx_k_pitch), 0, 0, 1, 1}, - {&__pyx_n_s_pose, __pyx_k_pose, sizeof(__pyx_k_pose), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_q, __pyx_k_q, sizeof(__pyx_k_q), 0, 0, 1, 1}, - {&__pyx_n_s_quat, __pyx_k_quat, sizeof(__pyx_k_quat), 0, 0, 1, 1}, - {&__pyx_n_s_quat2euler_single, __pyx_k_quat2euler_single, sizeof(__pyx_k_quat2euler_single), 0, 0, 1, 1}, - {&__pyx_n_s_quat2rot_single, __pyx_k_quat2rot_single, sizeof(__pyx_k_quat2rot_single), 0, 0, 1, 1}, - {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_roll, __pyx_k_roll, sizeof(__pyx_k_roll), 0, 0, 1, 1}, - {&__pyx_n_s_rot, __pyx_k_rot, sizeof(__pyx_k_rot), 0, 0, 1, 1}, - {&__pyx_n_s_rot2euler_single, __pyx_k_rot2euler_single, sizeof(__pyx_k_rot2euler_single), 0, 0, 1, 1}, - {&__pyx_n_s_rot2quat_single, __pyx_k_rot2quat_single, sizeof(__pyx_k_rot2quat_single), 0, 0, 1, 1}, - {&__pyx_n_s_rot_matrix, __pyx_k_rot_matrix, sizeof(__pyx_k_rot_matrix), 0, 0, 1, 1}, - {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, - {&__pyx_kp_s_self_lc_cannot_be_converted_to_a, __pyx_k_self_lc_cannot_be_converted_to_a, sizeof(__pyx_k_self_lc_cannot_be_converted_to_a), 0, 0, 1, 0}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_yaw, __pyx_k_yaw, sizeof(__pyx_k_yaw), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(0, 31, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 984, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":984 - * __pyx_import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: - */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(2, 984, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); - - /* "../../usr/local/pyenv/versions/3.11.4/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":990 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: - */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(2, 990, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "common/transformations/transformations.pyx":56 - * return g - * - * def euler2quat_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Quaternion q = euler2quat_c(e) - */ - __pyx_tuple__4 = PyTuple_Pack(3, __pyx_n_s_euler, __pyx_n_s_e, __pyx_n_s_q); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_euler2quat_single, 56, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 56, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":61 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def quat2euler_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Vector3 e = quat2euler_c(q) - */ - __pyx_tuple__6 = PyTuple_Pack(3, __pyx_n_s_quat, __pyx_n_s_q, __pyx_n_s_e); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_quat2euler_single, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 61, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":66 - * return [e(0), e(1), e(2)] - * - * def quat2rot_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Matrix3 r = quat2rot_c(q) - */ - __pyx_tuple__8 = PyTuple_Pack(3, __pyx_n_s_quat, __pyx_n_s_q, __pyx_n_s_r); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 66, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_quat2rot_single, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 66, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":71 - * return matrix2numpy(r) - * - * def rot2quat_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Quaternion q = rot2quat_c(r) - */ - __pyx_tuple__10 = PyTuple_Pack(3, __pyx_n_s_rot, __pyx_n_s_r, __pyx_n_s_q); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_rot2quat_single, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 71, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":76 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def euler2rot_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Matrix3 r = euler2rot_c(e) - */ - __pyx_tuple__12 = PyTuple_Pack(3, __pyx_n_s_euler, __pyx_n_s_e, __pyx_n_s_r); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_euler2rot_single, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 76, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":81 - * return matrix2numpy(r) - * - * def rot2euler_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Vector3 e = rot2euler_c(r) - */ - __pyx_tuple__14 = PyTuple_Pack(3, __pyx_n_s_rot, __pyx_n_s_r, __pyx_n_s_e); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_rot2euler_single, 81, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 81, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":86 - * return [e(0), e(1), e(2)] - * - * def rot_matrix(roll, pitch, yaw): # <<<<<<<<<<<<<< - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - */ - __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_s_roll, __pyx_n_s_pitch, __pyx_n_s_yaw); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); - __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_rot_matrix, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 86, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":89 - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - * def ecef_euler_from_ned_single(ecef_init, ned_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) - */ - __pyx_tuple__18 = PyTuple_Pack(5, __pyx_n_s_ecef_init, __pyx_n_s_ned_pose, __pyx_n_s_init, __pyx_n_s_pose, __pyx_n_s_e); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_ecef_euler_from_ned_single, 89, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 89, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":96 - * return [e(0), e(1), e(2)] - * - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) - */ - __pyx_tuple__20 = PyTuple_Pack(5, __pyx_n_s_ecef_init, __pyx_n_s_ecef_pose, __pyx_n_s_init, __pyx_n_s_pose, __pyx_n_s_e); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_ned_euler_from_ecef_single, 96, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 96, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":103 - * return [e(0), e(1), e(2)] - * - * def geodetic2ecef_single(geodetic): # <<<<<<<<<<<<<< - * cdef Geodetic g = list2geodetic(geodetic) - * cdef ECEF e = geodetic2ecef_c(g) - */ - __pyx_tuple__22 = PyTuple_Pack(3, __pyx_n_s_geodetic, __pyx_n_s_g, __pyx_n_s_e); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); - __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_geodetic2ecef_single, 103, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 103, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":108 - * return [e.x, e.y, e.z] - * - * def ecef2geodetic_single(ecef): # <<<<<<<<<<<<<< - * cdef ECEF e = list2ecef(ecef) - * cdef Geodetic g = ecef2geodetic_c(e) - */ - __pyx_tuple__24 = PyTuple_Pack(3, __pyx_n_s_ecef, __pyx_n_s_e, __pyx_n_s_g); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); - __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_ecef2geodetic_single, 108, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 108, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":140 - * return self.ned2ecef_matrix - * - * @classmethod # <<<<<<<<<<<<<< - * def from_geodetic(cls, geodetic): - * return cls(geodetic=geodetic) - */ - __pyx_tuple__26 = PyTuple_Pack(2, __pyx_n_s_cls, __pyx_n_s_geodetic); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__26); - __Pyx_GIVEREF(__pyx_tuple__26); - __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_from_geodetic, 140, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 140, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":144 - * return cls(geodetic=geodetic) - * - * @classmethod # <<<<<<<<<<<<<< - * def from_ecef(cls, ecef): - * return cls(ecef=ecef) - */ - __pyx_tuple__28 = PyTuple_Pack(2, __pyx_n_s_cls, __pyx_n_s_ecef); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__28); - __Pyx_GIVEREF(__pyx_tuple__28); - __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_from_ecef, 144, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 144, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":148 - * return cls(ecef=ecef) - * - * def ecef2ned_single(self, ecef): # <<<<<<<<<<<<<< - * assert self.lc - * cdef ECEF e = list2ecef(ecef) - */ - __pyx_tuple__30 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_ecef, __pyx_n_s_e, __pyx_n_s_n); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__30); - __Pyx_GIVEREF(__pyx_tuple__30); - __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_ecef2ned_single, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 148, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":154 - * return [n.n, n.e, n.d] - * - * def ned2ecef_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - __pyx_tuple__32 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_ned, __pyx_n_s_n, __pyx_n_s_e); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__32); - __Pyx_GIVEREF(__pyx_tuple__32); - __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_ned2ecef_single, 154, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 154, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":160 - * return [e.x, e.y, e.z] - * - * def geodetic2ned_single(self, geodetic): # <<<<<<<<<<<<<< - * assert self.lc - * cdef Geodetic g = list2geodetic(geodetic) - */ - __pyx_tuple__34 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_geodetic, __pyx_n_s_g, __pyx_n_s_n); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__34); - __Pyx_GIVEREF(__pyx_tuple__34); - __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_geodetic2ned_single, 160, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 160, __pyx_L1_error) - - /* "common/transformations/transformations.pyx":166 - * return [n.n, n.e, n.d] - * - * def ned2geodetic_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - __pyx_tuple__36 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_ned, __pyx_n_s_n, __pyx_n_s_g); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__36); - __Pyx_GIVEREF(__pyx_tuple__36); - __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_common_transformations_transform, __pyx_n_s_ned2geodetic_single, 166, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 166, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_tuple__38 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__38); - __Pyx_GIVEREF(__pyx_tuple__38); - __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - */ - __pyx_tuple__40 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__40); - __Pyx_GIVEREF(__pyx_tuple__40); - __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - /* AssertionsEnabled.init */ - if (likely(__Pyx_init_assertions_enabled() == 0)); else - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - /* NumpyImportArray.init */ - /* - * Cython has automatically inserted a call to _import_array since - * you didn't include one when you cimported numpy. To disable this - * add the line - * numpy._import_array - */ -#ifdef NPY_FEATURE_VERSION -#ifndef NO_IMPORT_ARRAY -if (unlikely(_import_array() == -1)) { - PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import " - "(auto-generated because you didn't call 'numpy.import_array()' after cimporting numpy; " - "use 'numpy._import_array' to disable if you are certain you don't need it)."); -} -#endif -#endif - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_module ### */ - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - 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_ptype_6common_15transformations_15transformations_LocalCoord = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_6common_15transformations_15transformations_LocalCoord_spec, NULL); if (unlikely(!__pyx_ptype_6common_15transformations_15transformations_LocalCoord)) __PYX_ERR(0, 114, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_6common_15transformations_15transformations_LocalCoord_spec, __pyx_ptype_6common_15transformations_15transformations_LocalCoord) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - #else - __pyx_ptype_6common_15transformations_15transformations_LocalCoord = &__pyx_type_6common_15transformations_15transformations_LocalCoord; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_ptype_6common_15transformations_15transformations_LocalCoord) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_ptype_6common_15transformations_15transformations_LocalCoord->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_6common_15transformations_15transformations_LocalCoord->tp_dictoffset && __pyx_ptype_6common_15transformations_15transformations_LocalCoord->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_ptype_6common_15transformations_15transformations_LocalCoord->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_LocalCoord, (PyObject *) __pyx_ptype_6common_15transformations_15transformations_LocalCoord) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_6common_15transformations_15transformations_LocalCoord) < 0) __PYX_ERR(0, 114, __pyx_L1_error) - #endif - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_8(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", - #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyTypeObject), - #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyTypeObject), - #else - sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyHeapTypeObject), - #endif - __Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyArray_Descr),__Pyx_ImportType_CheckSize_Ignore_3_0_8); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 202, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyArrayIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_8); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 225, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyArrayMultiIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_8); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 229, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyArrayObject),__Pyx_ImportType_CheckSize_Ignore_3_0_8); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 238, __pyx_L1_error) - __pyx_ptype_5numpy_generic = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(2, 809, __pyx_L1_error) - __pyx_ptype_5numpy_number = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "number", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_number) __PYX_ERR(2, 811, __pyx_L1_error) - __pyx_ptype_5numpy_integer = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(2, 813, __pyx_L1_error) - __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 815, __pyx_L1_error) - __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 817, __pyx_L1_error) - __pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 819, __pyx_L1_error) - __pyx_ptype_5numpy_floating = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(2, 821, __pyx_L1_error) - __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 823, __pyx_L1_error) - __pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 825, __pyx_L1_error) - __pyx_ptype_5numpy_character = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "character", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_8); if (!__pyx_ptype_5numpy_character) __PYX_ERR(2, 827, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_0_8(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_8(PyUFuncObject),__Pyx_ImportType_CheckSize_Ignore_3_0_8); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 866, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_transformations(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_transformations}, - {0, NULL} -}; -#endif - -#ifdef __cplusplus -namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "transformations", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ - #else - -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 -#endif - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC inittransformations(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC inittransformations(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_transformations(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_transformations(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -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) -#endif -{ - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else - result = PyDict_SetItemString(moddict, to_name, value); -#endif - } - 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 (__Pyx_check_single_interpreter()) - return NULL; - 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; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; -#endif - 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_transformations(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - 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_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'transformations' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("transformations", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "transformations" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #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("__Pyx_PyMODINIT_FUNC PyInit_transformations(void)", 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_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #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 - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_common__transformations__transformations) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "common.transformations.transformations")) { - if (unlikely((PyDict_SetItemString(modules, "common.transformations.transformations", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "common/transformations/transformations.pyx":20 - * - * - * import numpy as np # <<<<<<<<<<<<<< - * cimport numpy as np - * - */ - __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":56 - * return g - * - * def euler2quat_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Quaternion q = euler2quat_c(e) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_1euler2quat_single, 0, __pyx_n_s_euler2quat_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_euler2quat_single, __pyx_t_2) < 0) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":61 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def quat2euler_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Vector3 e = quat2euler_c(q) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_3quat2euler_single, 0, __pyx_n_s_quat2euler_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_quat2euler_single, __pyx_t_2) < 0) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":66 - * return [e(0), e(1), e(2)] - * - * def quat2rot_single(quat): # <<<<<<<<<<<<<< - * cdef Quaternion q = Quaternion(quat[0], quat[1], quat[2], quat[3]) - * cdef Matrix3 r = quat2rot_c(q) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_5quat2rot_single, 0, __pyx_n_s_quat2rot_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_quat2rot_single, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":71 - * return matrix2numpy(r) - * - * def rot2quat_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Quaternion q = rot2quat_c(r) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_7rot2quat_single, 0, __pyx_n_s_rot2quat_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_rot2quat_single, __pyx_t_2) < 0) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":76 - * return [q.w(), q.x(), q.y(), q.z()] - * - * def euler2rot_single(euler): # <<<<<<<<<<<<<< - * cdef Vector3 e = Vector3(euler[0], euler[1], euler[2]) - * cdef Matrix3 r = euler2rot_c(e) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_9euler2rot_single, 0, __pyx_n_s_euler2rot_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_euler2rot_single, __pyx_t_2) < 0) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":81 - * return matrix2numpy(r) - * - * def rot2euler_single(rot): # <<<<<<<<<<<<<< - * cdef Matrix3 r = numpy2matrix(np.asfortranarray(rot, dtype=np.double)) - * cdef Vector3 e = rot2euler_c(r) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_11rot2euler_single, 0, __pyx_n_s_rot2euler_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_rot2euler_single, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":86 - * return [e(0), e(1), e(2)] - * - * def rot_matrix(roll, pitch, yaw): # <<<<<<<<<<<<<< - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_13rot_matrix, 0, __pyx_n_s_rot_matrix, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_rot_matrix, __pyx_t_2) < 0) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":89 - * return matrix2numpy(rot_matrix_c(roll, pitch, yaw)) - * - * def ecef_euler_from_ned_single(ecef_init, ned_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ned_pose[0], ned_pose[1], ned_pose[2]) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_15ecef_euler_from_ned_single, 0, __pyx_n_s_ecef_euler_from_ned_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ecef_euler_from_ned_single, __pyx_t_2) < 0) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":96 - * return [e(0), e(1), e(2)] - * - * def ned_euler_from_ecef_single(ecef_init, ecef_pose): # <<<<<<<<<<<<<< - * cdef ECEF init = list2ecef(ecef_init) - * cdef Vector3 pose = Vector3(ecef_pose[0], ecef_pose[1], ecef_pose[2]) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_17ned_euler_from_ecef_single, 0, __pyx_n_s_ned_euler_from_ecef_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ned_euler_from_ecef_single, __pyx_t_2) < 0) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":103 - * return [e(0), e(1), e(2)] - * - * def geodetic2ecef_single(geodetic): # <<<<<<<<<<<<<< - * cdef Geodetic g = list2geodetic(geodetic) - * cdef ECEF e = geodetic2ecef_c(g) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_19geodetic2ecef_single, 0, __pyx_n_s_geodetic2ecef_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_geodetic2ecef_single, __pyx_t_2) < 0) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":108 - * return [e.x, e.y, e.z] - * - * def ecef2geodetic_single(ecef): # <<<<<<<<<<<<<< - * cdef ECEF e = list2ecef(ecef) - * cdef Geodetic g = ecef2geodetic_c(e) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_21ecef2geodetic_single, 0, __pyx_n_s_ecef2geodetic_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ecef2geodetic_single, __pyx_t_2) < 0) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":140 - * return self.ned2ecef_matrix - * - * @classmethod # <<<<<<<<<<<<<< - * def from_geodetic(cls, geodetic): - * return cls(geodetic=geodetic) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_3from_geodetic, __Pyx_CYFUNCTION_CLASSMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord_from_geodetic, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_from_geodetic, __pyx_t_2) < 0) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_from_geodetic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_from_geodetic, __pyx_t_3) < 0) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - - /* "common/transformations/transformations.pyx":144 - * return cls(geodetic=geodetic) - * - * @classmethod # <<<<<<<<<<<<<< - * def from_ecef(cls, ecef): - * return cls(ecef=ecef) - */ - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_5from_ecef, __Pyx_CYFUNCTION_CLASSMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord_from_ecef, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_from_ecef, __pyx_t_3) < 0) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_from_ecef); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_from_ecef, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - - /* "common/transformations/transformations.pyx":148 - * return cls(ecef=ecef) - * - * def ecef2ned_single(self, ecef): # <<<<<<<<<<<<<< - * assert self.lc - * cdef ECEF e = list2ecef(ecef) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_7ecef2ned_single, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord_ecef2ned_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_ecef2ned_single, __pyx_t_2) < 0) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - - /* "common/transformations/transformations.pyx":154 - * return [n.n, n.e, n.d] - * - * def ned2ecef_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_9ned2ecef_single, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord_ned2ecef_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_ned2ecef_single, __pyx_t_2) < 0) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - - /* "common/transformations/transformations.pyx":160 - * return [e.x, e.y, e.z] - * - * def geodetic2ned_single(self, geodetic): # <<<<<<<<<<<<<< - * assert self.lc - * cdef Geodetic g = list2geodetic(geodetic) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_11geodetic2ned_single, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord_geodetic2ned_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_geodetic2ned_single, __pyx_t_2) < 0) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - - /* "common/transformations/transformations.pyx":166 - * return [n.n, n.e, n.d] - * - * def ned2geodetic_single(self, ned): # <<<<<<<<<<<<<< - * assert self.lc - * cdef NED n = list2ned(ned) - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_13ned2geodetic_single, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord_ned2geodetic_single, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_6common_15transformations_15transformations_LocalCoord, __pyx_n_s_ned2geodetic_single, __pyx_t_2) < 0) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_6common_15transformations_15transformations_LocalCoord); - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord___reduce_cython, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.lc cannot be converted to a Python object for pickling" - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_6common_15transformations_15transformations_10LocalCoord_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LocalCoord___setstate_cython, NULL, __pyx_n_s_common_transformations_transform_2, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "common/transformations/transformations.pyx":1 - * # distutils: language = c++ # <<<<<<<<<<<<<< - * # cython: language_level = 3 - * from openpilot.common.transformations.transformations cimport Matrix3, Vector3, Quaternion - */ - __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_d, __pyx_n_s_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); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init common.transformations.transformations", __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 common.transformations.transformations"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} -/* #### 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); -#if PY_MAJOR_VERSION >= 3 - 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); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -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 >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); - return result; -#else -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - 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_b, name); - if (unlikely(!result) && !PyErr_Occurred()) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* 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 >= 0x030C00A6 - local_value = tstate->current_exception; - tstate->current_exception = 0; - if (likely(local_value)) { - local_type = (PyObject*) Py_TYPE(local_value); - Py_INCREF(local_type); - local_tb = PyException_GetTraceback(local_value); - } - #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 -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 - if (unlikely(tstate->current_exception)) -#elif CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) -#else - if (unlikely(PyErr_Occurred())) -#endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; - } - #endif - 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); -#else - PyErr_SetExcInfo(local_type, local_value, local_tb); -#endif - return 0; -bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; -} - -/* 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - 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 - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } - } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { - #if PY_VERSION_HEX >= 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; -} -#endif - -/* 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_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#elif CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(!__pyx_m)) { - return NULL; - } - result = PyObject_GetAttr(__pyx_m, name); - if (likely(result)) { - return result; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **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; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - 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); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - 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 PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - 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 **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 -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **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 PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #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 - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); - #endif - if (f) { - return f(func, args, (size_t)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, (size_t)nargs, NULL); - } - #endif - } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __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 -} - -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - __Pyx_TypeName obj_type_name; - __Pyx_TypeName type_name; - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - type_name = __Pyx_PyType_GetName(type); - PyErr_Format(PyExc_TypeError, - "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, - obj_type_name, type_name); - __Pyx_DECREF_TypeName(obj_type_name); - __Pyx_DECREF_TypeName(type_name); - return 0; -} - -/* IsLittleEndian */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) -{ - union { - uint32_t u32; - uint8_t u8[4]; - } S; - S.u32 = 0x01020304; - return S.u8[0] == 4; -} - -/* BufferFormatCheck */ -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type) { - stack[0].field = &ctx->root; - stack[0].parent_offset = 0; - ctx->root.type = type; - ctx->root.name = "buffer dtype"; - ctx->root.offset = 0; - ctx->head = stack; - ctx->head->field = &ctx->root; - ctx->fmt_offset = 0; - ctx->head->parent_offset = 0; - ctx->new_packmode = '@'; - ctx->enc_packmode = '@'; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->is_complex = 0; - ctx->is_valid_array = 0; - ctx->struct_alignment = 0; - while (type->typegroup == 'S') { - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = 0; - type = type->fields->type; - } -} -static int __Pyx_BufFmt_ParseNumber(const char** ts) { - int count; - const char* t = *ts; - if (*t < '0' || *t > '9') { - return -1; - } else { - count = *t++ - '0'; - while (*t >= '0' && *t <= '9') { - count *= 10; - count += *t++ - '0'; - } - } - *ts = t; - return count; -} -static int __Pyx_BufFmt_ExpectNumber(const char **ts) { - int number = __Pyx_BufFmt_ParseNumber(ts); - if (number == -1) - PyErr_Format(PyExc_ValueError,\ - "Does not understand character buffer dtype format string ('%c')", **ts); - return number; -} -static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { - PyErr_Format(PyExc_ValueError, - "Unexpected format string character: '%c'", ch); -} -static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { - switch (ch) { - case '?': return "'bool'"; - case 'c': return "'char'"; - case 'b': return "'signed char'"; - case 'B': return "'unsigned char'"; - case 'h': return "'short'"; - case 'H': return "'unsigned short'"; - case 'i': return "'int'"; - case 'I': return "'unsigned int'"; - case 'l': return "'long'"; - case 'L': return "'unsigned long'"; - case 'q': return "'long long'"; - case 'Q': return "'unsigned long long'"; - case 'f': return (is_complex ? "'complex float'" : "'float'"); - case 'd': return (is_complex ? "'complex double'" : "'double'"); - case 'g': return (is_complex ? "'complex long double'" : "'long double'"); - case 'T': return "a struct"; - case 'O': return "Python object"; - case 'P': return "a pointer"; - case 's': case 'p': return "a string"; - case 0: return "end"; - default: return "unparsable format string"; - } -} -static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return 2; - case 'i': case 'I': case 'l': case 'L': return 4; - case 'q': case 'Q': return 8; - case 'f': return (is_complex ? 8 : 4); - case 'd': return (is_complex ? 16 : 8); - case 'g': { - PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); - return 0; - } - case 'O': case 'P': return sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(short); - case 'i': case 'I': return sizeof(int); - case 'l': case 'L': return sizeof(long); - #ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(PY_LONG_LONG); - #endif - case 'f': return sizeof(float) * (is_complex ? 2 : 1); - case 'd': return sizeof(double) * (is_complex ? 2 : 1); - case 'g': return sizeof(long double) * (is_complex ? 2 : 1); - case 'O': case 'P': return sizeof(void*); - default: { - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } - } -} -typedef struct { char c; short x; } __Pyx_st_short; -typedef struct { char c; int x; } __Pyx_st_int; -typedef struct { char c; long x; } __Pyx_st_long; -typedef struct { char c; float x; } __Pyx_st_float; -typedef struct { char c; double x; } __Pyx_st_double; -typedef struct { char c; long double x; } __Pyx_st_longdouble; -typedef struct { char c; void *x; } __Pyx_st_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; -#endif -static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, int is_complex) { - CYTHON_UNUSED_VAR(is_complex); - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); -#endif - case 'f': return sizeof(__Pyx_st_float) - sizeof(float); - case 'd': return sizeof(__Pyx_st_double) - sizeof(double); - case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -/* These are for computing the padding at the end of the struct to align - on the first member of the struct. This will probably the same as above, - but we don't have any guarantees. - */ -typedef struct { short x; char c; } __Pyx_pad_short; -typedef struct { int x; char c; } __Pyx_pad_int; -typedef struct { long x; char c; } __Pyx_pad_long; -typedef struct { float x; char c; } __Pyx_pad_float; -typedef struct { double x; char c; } __Pyx_pad_double; -typedef struct { long double x; char c; } __Pyx_pad_longdouble; -typedef struct { void *x; char c; } __Pyx_pad_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; -#endif -static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, int is_complex) { - CYTHON_UNUSED_VAR(is_complex); - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); -#endif - case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); - case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); - case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { - switch (ch) { - case 'c': - return 'H'; - case 'b': case 'h': case 'i': - case 'l': case 'q': case 's': case 'p': - return 'I'; - case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': - return 'U'; - case 'f': case 'd': case 'g': - return (is_complex ? 'C' : 'R'); - case 'O': - return 'O'; - case 'P': - return 'P'; - default: { - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } - } -} -static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { - if (ctx->head == NULL || ctx->head->field == &ctx->root) { - const char* expected; - const char* quote; - if (ctx->head == NULL) { - expected = "end"; - quote = ""; - } else { - expected = ctx->head->field->type->name; - quote = "'"; - } - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected %s%s%s but got %s", - quote, expected, quote, - __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); - } else { - __Pyx_StructField* field = ctx->head->field; - __Pyx_StructField* parent = (ctx->head - 1)->field; - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", - field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), - parent->type->name, field->name); - } -} -static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { - char group; - size_t size, offset, arraysize = 1; - if (ctx->enc_type == 0) return 0; - if (ctx->head->field->type->arraysize[0]) { - int i, ndim = 0; - if (ctx->enc_type == 's' || ctx->enc_type == 'p') { - ctx->is_valid_array = ctx->head->field->type->ndim == 1; - ndim = 1; - if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %zu", - ctx->head->field->type->arraysize[0], ctx->enc_count); - return -1; - } - } - if (!ctx->is_valid_array) { - PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", - ctx->head->field->type->ndim, ndim); - return -1; - } - for (i = 0; i < ctx->head->field->type->ndim; i++) { - arraysize *= ctx->head->field->type->arraysize[i]; - } - ctx->is_valid_array = 0; - ctx->enc_count = 1; - } - group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); - do { - __Pyx_StructField* field = ctx->head->field; - __Pyx_TypeInfo* type = field->type; - if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { - size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); - } else { - size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); - } - if (ctx->enc_packmode == '@') { - size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); - size_t align_mod_offset; - if (align_at == 0) return -1; - align_mod_offset = ctx->fmt_offset % align_at; - if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; - if (ctx->struct_alignment == 0) - ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, - ctx->is_complex); - } - if (type->size != size || type->typegroup != group) { - if (type->typegroup == 'C' && type->fields != NULL) { - size_t parent_offset = ctx->head->parent_offset + field->offset; - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = parent_offset; - continue; - } - if ((type->typegroup == 'H' || group == 'H') && type->size == size) { - } else { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - } - offset = ctx->head->parent_offset + field->offset; - if (ctx->fmt_offset != offset) { - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", - (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); - return -1; - } - ctx->fmt_offset += size; - if (arraysize) - ctx->fmt_offset += (arraysize - 1) * size; - --ctx->enc_count; - while (1) { - if (field == &ctx->root) { - ctx->head = NULL; - if (ctx->enc_count != 0) { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - break; - } - ctx->head->field = ++field; - if (field->type == NULL) { - --ctx->head; - field = ctx->head->field; - continue; - } else if (field->type->typegroup == 'S') { - size_t parent_offset = ctx->head->parent_offset + field->offset; - if (field->type->fields->type == NULL) continue; - field = field->type->fields; - ++ctx->head; - ctx->head->field = field; - ctx->head->parent_offset = parent_offset; - break; - } else { - break; - } - } - } while (ctx->enc_count); - ctx->enc_type = 0; - ctx->is_complex = 0; - return 0; -} -static int -__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) -{ - const char *ts = *tsp; - int i = 0, number, ndim; - ++ts; - if (ctx->new_count != 1) { - PyErr_SetString(PyExc_ValueError, - "Cannot handle repeated arrays in format string"); - return -1; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; - ndim = ctx->head->field->type->ndim; - while (*ts && *ts != ')') { - switch (*ts) { - case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; - default: break; - } - number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return -1; - if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %d", - ctx->head->field->type->arraysize[i], number); - return -1; - } - if (*ts != ',' && *ts != ')') { - PyErr_Format(PyExc_ValueError, - "Expected a comma in format string, got '%c'", *ts); - return -1; - } - if (*ts == ',') ts++; - i++; - } - if (i != ndim) { - PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", - ctx->head->field->type->ndim, i); - return -1; - } - if (!*ts) { - PyErr_SetString(PyExc_ValueError, - "Unexpected end of format string, expected ')'"); - return -1; - } - ctx->is_valid_array = 1; - ctx->new_count = 1; - *tsp = ++ts; - return 0; -} -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { - int got_Z = 0; - while (1) { - switch(*ts) { - case 0: - if (ctx->enc_type != 0 && ctx->head == NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - if (ctx->head != NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - return ts; - case ' ': - case '\r': - case '\n': - ++ts; - break; - case '<': - if (!__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '>': - case '!': - if (__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '=': - case '@': - case '^': - ctx->new_packmode = *ts++; - break; - case 'T': - { - const char* ts_after_sub; - size_t i, struct_count = ctx->new_count; - size_t struct_alignment = ctx->struct_alignment; - ctx->new_count = 1; - ++ts; - if (*ts != '{') { - PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - ctx->enc_count = 0; - ctx->struct_alignment = 0; - ++ts; - ts_after_sub = ts; - for (i = 0; i != struct_count; ++i) { - ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); - if (!ts_after_sub) return NULL; - } - ts = ts_after_sub; - if (struct_alignment) ctx->struct_alignment = struct_alignment; - } - break; - case '}': - { - size_t alignment = ctx->struct_alignment; - ++ts; - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - if (alignment && ctx->fmt_offset % alignment) { - ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); - } - } - return ts; - case 'x': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->fmt_offset += ctx->new_count; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->enc_packmode = ctx->new_packmode; - ++ts; - break; - case 'Z': - got_Z = 1; - ++ts; - if (*ts != 'f' && *ts != 'd' && *ts != 'g') { - __Pyx_BufFmt_RaiseUnexpectedChar('Z'); - return NULL; - } - CYTHON_FALLTHROUGH; - case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': - case 'l': case 'L': case 'q': case 'Q': - case 'f': case 'd': case 'g': - case 'O': case 'p': - if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && - (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { - ctx->enc_count += ctx->new_count; - ctx->new_count = 1; - got_Z = 0; - ++ts; - break; - } - CYTHON_FALLTHROUGH; - case 's': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_count = ctx->new_count; - ctx->enc_packmode = ctx->new_packmode; - ctx->enc_type = *ts; - ctx->is_complex = got_Z; - ++ts; - ctx->new_count = 1; - got_Z = 0; - break; - case ':': - ++ts; - while(*ts != ':') ++ts; - ++ts; - break; - case '(': - if (__pyx_buffmt_parse_array(ctx, &ts) < 0) return NULL; - break; - default: - { - int number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - ctx->new_count = (size_t)number; - } - } - } -} - -/* BufferGetAndValidate */ - static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { - if (unlikely(info->buf == NULL)) return; - if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; - __Pyx_ReleaseBuffer(info); -} -static void __Pyx_ZeroBuffer(Py_buffer* buf) { - buf->buf = NULL; - buf->obj = NULL; - buf->strides = __Pyx_zeros; - buf->shape = __Pyx_zeros; - buf->suboffsets = __Pyx_minusones; -} -static int __Pyx__GetBufferAndValidate( - Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, - int nd, int cast, __Pyx_BufFmt_StackElem* stack) -{ - buf->buf = NULL; - if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { - __Pyx_ZeroBuffer(buf); - return -1; - } - if (unlikely(buf->ndim != nd)) { - PyErr_Format(PyExc_ValueError, - "Buffer has wrong number of dimensions (expected %d, got %d)", - nd, buf->ndim); - goto fail; - } - if (!cast) { - __Pyx_BufFmt_Context ctx; - __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; - } - if (unlikely((size_t)buf->itemsize != dtype->size)) { - PyErr_Format(PyExc_ValueError, - "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", - buf->itemsize, (buf->itemsize > 1) ? "s" : "", - dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); - goto fail; - } - if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; - return 0; -fail:; - __Pyx_SafeReleaseBuffer(buf); - return -1; -} - -/* 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_AVOID_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, PyInt_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_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, PyInt_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_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))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - 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 = PyInt_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, PyInt_FromSsize_t(i)); -} - -/* TupleAndListFromArray */ - #if 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) { - Py_INCREF(__pyx_empty_tuple); - return __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 - 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 - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - 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 PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); - } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - 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)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - 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_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - 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 = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; - } - for (i = 0; i < n; i++) - { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), 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_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); - PyObject *dict; - dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ - static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; - } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; - } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - Py_XDECREF(key); - Py_XDECREF(value); - 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; -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - Py_XDECREF(key); - Py_XDECREF(value); - return -1; -} - -/* 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); -} - -/* KeywordStringCheck */ - static int __Pyx_CheckKeywordStrings( - PyObject *kw, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { - Py_ssize_t kwsize; -#if CYTHON_ASSUME_SAFE_MACROS - kwsize = PyTuple_GET_SIZE(kw); -#else - kwsize = PyTuple_Size(kw); - if (kwsize < 0) return 0; -#endif - if (unlikely(kwsize == 0)) - return 1; - if (!kw_allowed) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, 0); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - goto invalid_keyword; - } -#if PY_VERSION_HEX < 0x03090000 - for (pos = 0; pos < kwsize; pos++) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, pos); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } -#endif - return 1; - } - while (PyDict_Next(kw, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if (!kw_allowed && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 0; -} - -/* FixUpExtensionType */ - #if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - CYTHON_UNUSED_VAR(spec); - CYTHON_UNUSED_VAR(type); -#else - const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; - if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) - const -#endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; - while (memb && memb->name) { - if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 - 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 -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON - 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; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); - return -1; - } - Py_DECREF(descr); - changed = 1; - } -#endif - } - memb++; - } - if (changed) - PyType_Modified(type); - } -#endif - return 0; -} -#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); -} - -/* 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); -} - -/* 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)) -#elif PY_MAJOR_VERSION >= 3 - #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 -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #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_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif - __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; -} - -/* 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; -} - -/* 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_MACROS - n = PyTuple_GET_SIZE(bases); -#else - n = PyTuple_Size(bases); - if (n < 0) return -1; -#endif - for (i = 1; i < n; i++) - { -#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 - PyTypeObject *b; -#if PY_MAJOR_VERSION < 3 - if (PyClass_Check(b0)) - { - PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", - PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } -#endif - b = (PyTypeObject*) b0; - if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(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 || CYTHON_COMPILING_IN_PYPY - 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_GetName(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 || CYTHON_COMPILING_IN_PYPY) - 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 */ - static int __Pyx_PyType_Ready(PyTypeObject *t) { -#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || 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; - 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 PY_VERSION_HEX >= 0x03050000 && !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 PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) - gc = PyImport_GetModule(__pyx_kp_u_gc); - #endif - if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); - if (unlikely(!gc)) return -1; - py_status = __Pyx_PyObject_CallMethod0(gc, __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_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 PY_VERSION_HEX >= 0x03050000 && !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_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 -} - -/* PyObject_GenericGetAttrNoDict */ - #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, attr_name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(attr_name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ - #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* SetupReduce */ - #if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); -#else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); -#else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) { - __Pyx_TypeName type_obj_name = - __Pyx_PyType_GetName((PyTypeObject*)type_obj); - PyErr_Format(PyExc_RuntimeError, - "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); - __Pyx_DECREF_TypeName(type_obj_name); - } - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; -} -#endif - -/* TypeImport */ - #ifndef __PYX_HAVE_RT_ImportType_3_0_8 -#define __PYX_HAVE_RT_ImportType_3_0_8 -static PyTypeObject *__Pyx_ImportType_3_0_8(PyObject *module, const char *module_name, const char *class_name, - size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_8 check_size) -{ - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; - Py_ssize_t itemsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - PyObject *py_itemsize; -#endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { - PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; - } -#if !CYTHON_COMPILING_IN_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; - itemsize = ((PyTypeObject *)result)->tp_itemsize; -#else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; - py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); - if (!py_itemsize) - goto bad; - itemsize = PyLong_AsSsize_t(py_itemsize); - Py_DECREF(py_itemsize); - py_itemsize = 0; - if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; -#endif - if (itemsize) { - if (size % alignment) { - alignment = size % alignment; - } - if (itemsize < (Py_ssize_t)alignment) - itemsize = (Py_ssize_t)alignment; - } - if ((size_t)(basicsize + itemsize) < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize+itemsize); - goto bad; - } - if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_8 && - ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd-%zd from PyObject", - module_name, class_name, size, basicsize, basicsize+itemsize); - goto bad; - } - else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_8 && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; - } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; -} -#endif - -/* Import */ - static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *module = 0; - PyObject *empty_dict = 0; - PyObject *empty_list = 0; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (unlikely(!py_import)) - goto bad; - if (!from_list) { - empty_list = PyList_New(0); - if (unlikely(!empty_list)) - goto bad; - from_list = empty_list; - } - #endif - empty_dict = PyDict_New(); - if (unlikely(!empty_dict)) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); - if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (unlikely(!py_level)) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, level); - #endif - } - } -bad: - Py_XDECREF(empty_dict); - Py_XDECREF(empty_list); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - return module; -} - -/* ImportDottedModule */ - #if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { - PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; - if (unlikely(PyErr_Occurred())) { - PyErr_Clear(); - } - if (likely(PyTuple_GET_SIZE(parts_tuple) == 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( -#if PY_MAJOR_VERSION < 3 - PyExc_ImportError, - "No module named '%s'", PyString_AS_STRING(partial_name)); -#else -#if PY_VERSION_HEX >= 0x030600B1 - PyExc_ModuleNotFoundError, -#else - PyExc_ImportError, -#endif - "No module named '%U'", partial_name); -#endif -bad: - Py_XDECREF(sep); - Py_XDECREF(slice); - Py_XDECREF(partial_name); - return NULL; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { - PyObject *imported_module; -#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - 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; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { - Py_ssize_t i, nparts; - nparts = PyTuple_GET_SIZE(parts_tuple); - 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 = PySequence_ITEM(parts_tuple, i); -#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; -} -#endif -static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if PY_MAJOR_VERSION < 3 - PyObject *module, *from_list, *star = __pyx_n_s__3; - CYTHON_UNUSED_VAR(parts_tuple); - from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; - Py_INCREF(star); - PyList_SET_ITEM(from_list, 0, star); - module = __Pyx_Import(name, from_list, 0); - Py_DECREF(from_list); - return module; -#else - 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); -#endif -} -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 - PyObject *module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(module)) { - PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); - if (likely(spec)) { - PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_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); -} - -/* FetchSharedCythonModule */ - static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); -} - -/* FetchCommonType */ - static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { - if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); - return -1; - } - if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); - return -1; - } - return 0; -} -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(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; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; -done: - Py_DECREF(abi_module); - assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#endif - -/* PyVectorcallFastCallDict */ - #if CYTHON_METH_FASTCALL -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; - Py_ssize_t nkw = PyDict_GET_SIZE(kw); - 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 &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(kwnames, i, key); - 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) -{ - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { - return vc(func, args, nargs, NULL); - } - return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); -} -#endif - -/* CythonFunctionShared */ - #if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - 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; -} -#else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - 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(__pyx_CyFunctionObject *op, void *closure) -{ - CYTHON_UNUSED_VAR(closure); - 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) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif - 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 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_Py_XDECREF_SET(op->func_doc, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_name == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#else - op->func_name = PyString_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 int -__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_name, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_qualname, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - 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 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_Py_XDECREF_SET(op->func_dict, value); - 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_Py_XDECREF_SET(op->defaults_tuple, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); - 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 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_Py_XDECREF_SET(op->defaults_kwdict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); - 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 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_Py_XDECREF_SET(op->func_annotations, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); - 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_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; - CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 - if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_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_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); - Py_DECREF(fromlist); - if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); - Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); - } -ignore: - PyErr_Clear(); - } -#endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); -} -#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[] = { - {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, - {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, - {(char *) "_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 - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, -#endif -#if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, -#if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, -#else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif -#endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, -#else - {(char *) "__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) -{ - CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 - Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif -} -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 || 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_pyobjects = 0; - op->defaults_size = 0; - 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); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[i]); - PyObject_Free(m->defaults); - m->defaults = NULL; - } - 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) -{ - 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); - Py_VISIT(m->func_name); - Py_VISIT(m->func_qualname); - Py_VISIT(m->func_doc); - Py_VISIT(m->func_globals); - Py_VISIT(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); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } - return 0; -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif -} -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; - PyObject *py_name = NULL; - 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*)meth)(self, arg, kw); - case METH_NOARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - 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); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - 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; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif - 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 - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); - if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS - 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_MACROS - 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); -#if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif - 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 -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)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - ret = 1; - } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - 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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_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; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - 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; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); -} -#endif -#if CYTHON_USE_TYPE_SPECS -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 (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 0, - 0, -#if PY_MAJOR_VERSION < 3 - 0, -#else - 0, -#endif - (reprfunc) __Pyx_CyFunction_repr, - 0, - 0, - 0, - 0, - __Pyx_CyFunction_CallAsMethod, - 0, - 0, - 0, - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, - 0, -#if PY_VERSION_HEX < 0x030500A0 - offsetof(__pyx_CyFunctionObject, func_weakreflist), -#else - offsetof(PyCFunctionObject, m_weakreflist), -#endif - 0, - 0, - __pyx_CyFunction_methods, - __pyx_CyFunction_members, - __pyx_CyFunction_getsets, - 0, - 0, - __Pyx_PyMethod_New, - 0, - offsetof(__pyx_CyFunctionObject, func_dict), - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if PY_VERSION_HEX >= 0x030400a1 - 0, -#endif -#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif -}; -#endif -static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - if (unlikely(__pyx_CyFunctionType == NULL)) { - return -1; - } - return 0; -} -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults = PyObject_Malloc(size); - if (unlikely(!m->defaults)) - return PyErr_NoMemory(); - memset(m->defaults, 0, size); - m->defaults_pyobjects = pyobjects; - m->defaults_size = size; - 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_CyFunctionType), - ml, flags, qualname, closure, module, globals, code - ); - if (likely(op)) { - PyObject_GC_Track(op); - } - return op; -} - -/* ClassMethod */ - static PyObject* __Pyx_Method_ClassMethod(PyObject *method) { -#if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM <= 0x05080000 - if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) { - return PyClassMethod_New(method); - } -#else -#if CYTHON_COMPILING_IN_PYPY - if (PyMethodDescr_Check(method)) -#else - #if PY_MAJOR_VERSION == 2 - static PyTypeObject *methoddescr_type = NULL; - if (unlikely(methoddescr_type == NULL)) { - PyObject *meth = PyObject_GetAttrString((PyObject*)&PyList_Type, "append"); - if (unlikely(!meth)) return NULL; - methoddescr_type = Py_TYPE(meth); - Py_DECREF(meth); - } - #else - PyTypeObject *methoddescr_type = &PyMethodDescr_Type; - #endif - if (__Pyx_TypeCheck(method, methoddescr_type)) -#endif - { - PyMethodDescrObject *descr = (PyMethodDescrObject *)method; - #if PY_VERSION_HEX < 0x03020000 - PyTypeObject *d_type = descr->d_type; - #else - PyTypeObject *d_type = descr->d_common.d_type; - #endif - return PyDescr_NewClassMethod(d_type, descr->d_method); - } -#endif - else if (PyMethod_Check(method)) { - return PyClassMethod_New(PyMethod_GET_FUNCTION(method)); - } - else { - return PyClassMethod_New(method); - } -} - -/* GetNameInClass */ - static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { - PyObject *result; - PyObject *dict; - assert(PyType_Check(nmspace)); -#if CYTHON_USE_TYPE_SLOTS - dict = ((PyTypeObject*)nmspace)->tp_dict; - Py_XINCREF(dict); -#else - dict = PyObject_GetAttr(nmspace, __pyx_n_s_dict); -#endif - if (likely(dict)) { - result = PyObject_GetItem(dict, name); - Py_DECREF(dict); - if (result) { - return result; - } - } - PyErr_Clear(); - __Pyx_GetModuleGlobalNameUncached(result, name); - return result; -} - -/* CLineInTraceback */ - #ifndef CYTHON_CLINE_IN_TRACEBACK -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_cython_runtime)) { - return c_line; - } - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { - c_line = 0; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - return c_line; -} -#endif - -/* CodeObjectCache */ - #if !CYTHON_COMPILING_IN_LIMITED_API -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 PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { - return NULL; - } - code_object = __pyx_code_cache.entries[pos].code_object; - Py_INCREF(code_object); - return code_object; -} -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { - int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; - if (unlikely(!code_line)) { - return; - } - if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); - if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_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(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; - entries[pos].code_object = code_object; - Py_DECREF(tmp); - return; - } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); - if (unlikely(!entries)) { - return; - } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; - } - for (i=__pyx_code_cache.count; i>pos; i--) { - entries[i] = entries[i-1]; - } - entries[pos].code_line = code_line; - entries[pos].code_object = code_object; - __pyx_code_cache.count++; - Py_INCREF(code_object); -} -#endif - -/* AddTraceback */ - #include "compile.h" -#include "frameobject.h" -#include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #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; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); - Py_DECREF(replace); - return result; - } - PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else - return NULL; - #endif -} -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 = 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; - 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 PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else - 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; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - #else - py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif - Py_XDECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif - 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_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 - -#if PY_MAJOR_VERSION < 3 -static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { - __Pyx_TypeName obj_type_name; - if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "'" __Pyx_FMT_TYPENAME "' does not have the buffer interface", - obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return -1; -} -static void __Pyx_ReleaseBuffer(Py_buffer *view) { - PyObject *obj = view->obj; - if (!obj) return; - if (PyObject_CheckBuffer(obj)) { - PyBuffer_Release(view); - return; - } - if ((0)) {} - view->obj = NULL; - Py_DECREF(obj); -} -#endif - - - /* Declarations */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - return ::std::complex< float >(x, y); - } - #else - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - return x + y*(__pyx_t_float_complex)_Complex_I; - } - #endif -#else - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - __pyx_t_float_complex z; - z.real = x; - z.imag = y; - return z; - } -#endif - -/* Arithmetic */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) -#else - static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - return (a.real == b.real) && (a.imag == b.imag); - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real + b.real; - z.imag = a.imag + b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real - b.real; - z.imag = a.imag - b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real * b.real - a.imag * b.imag; - z.imag = a.real * b.imag + a.imag * b.real; - return z; - } - #if 1 - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - if (b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); - } else if (fabsf(b.real) >= fabsf(b.imag)) { - if (b.real == 0 && b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); - } else { - float r = b.imag / b.real; - float s = (float)(1.0) / (b.real + b.imag * r); - return __pyx_t_float_complex_from_parts( - (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); - } - } else { - float r = b.real / b.imag; - float s = (float)(1.0) / (b.imag + b.real * r); - return __pyx_t_float_complex_from_parts( - (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); - } - } - #else - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - if (b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); - } else { - float denom = b.real * b.real + b.imag * b.imag; - return __pyx_t_float_complex_from_parts( - (a.real * b.real + a.imag * b.imag) / denom, - (a.imag * b.real - a.real * b.imag) / denom); - } - } - #endif - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { - __pyx_t_float_complex z; - z.real = -a.real; - z.imag = -a.imag; - return z; - } - static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { - return (a.real == 0) && (a.imag == 0); - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { - __pyx_t_float_complex z; - z.real = a.real; - z.imag = -a.imag; - return z; - } - #if 1 - static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { - #if !defined(HAVE_HYPOT) || defined(_MSC_VER) - return sqrtf(z.real*z.real + z.imag*z.imag); - #else - return hypotf(z.real, z.imag); - #endif - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - float r, lnr, theta, z_r, z_theta; - if (b.imag == 0 && b.real == (int)b.real) { - if (b.real < 0) { - float denom = a.real * a.real + a.imag * a.imag; - a.real = a.real / denom; - a.imag = -a.imag / denom; - b.real = -b.real; - } - switch ((int)b.real) { - case 0: - z.real = 1; - z.imag = 0; - return z; - case 1: - return a; - case 2: - return __Pyx_c_prod_float(a, a); - case 3: - z = __Pyx_c_prod_float(a, a); - return __Pyx_c_prod_float(z, a); - case 4: - z = __Pyx_c_prod_float(a, a); - return __Pyx_c_prod_float(z, z); - } - } - if (a.imag == 0) { - if (a.real == 0) { - return a; - } else if ((b.imag == 0) && (a.real >= 0)) { - z.real = powf(a.real, b.real); - z.imag = 0; - return z; - } else if (a.real > 0) { - r = a.real; - theta = 0; - } else { - r = -a.real; - theta = atan2f(0.0, -1.0); - } - } else { - r = __Pyx_c_abs_float(a); - theta = atan2f(a.imag, a.real); - } - lnr = logf(r); - z_r = expf(lnr * b.real - theta * b.imag); - z_theta = theta * b.real + lnr * b.imag; - z.real = z_r * cosf(z_theta); - z.imag = z_r * sinf(z_theta); - return z; - } - #endif -#endif - -/* Declarations */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - return ::std::complex< double >(x, y); - } - #else - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - return x + y*(__pyx_t_double_complex)_Complex_I; - } - #endif -#else - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - __pyx_t_double_complex z; - z.real = x; - z.imag = y; - return z; - } -#endif - -/* Arithmetic */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) -#else - static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - return (a.real == b.real) && (a.imag == b.imag); - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real + b.real; - z.imag = a.imag + b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real - b.real; - z.imag = a.imag - b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real * b.real - a.imag * b.imag; - z.imag = a.real * b.imag + a.imag * b.real; - return z; - } - #if 1 - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - if (b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); - } else if (fabs(b.real) >= fabs(b.imag)) { - if (b.real == 0 && b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); - } else { - double r = b.imag / b.real; - double s = (double)(1.0) / (b.real + b.imag * r); - return __pyx_t_double_complex_from_parts( - (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); - } - } else { - double r = b.real / b.imag; - double s = (double)(1.0) / (b.imag + b.real * r); - return __pyx_t_double_complex_from_parts( - (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); - } - } - #else - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - if (b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); - } else { - double denom = b.real * b.real + b.imag * b.imag; - return __pyx_t_double_complex_from_parts( - (a.real * b.real + a.imag * b.imag) / denom, - (a.imag * b.real - a.real * b.imag) / denom); - } - } - #endif - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { - __pyx_t_double_complex z; - z.real = -a.real; - z.imag = -a.imag; - return z; - } - static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { - return (a.real == 0) && (a.imag == 0); - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { - __pyx_t_double_complex z; - z.real = a.real; - z.imag = -a.imag; - return z; - } - #if 1 - static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { - #if !defined(HAVE_HYPOT) || defined(_MSC_VER) - return sqrt(z.real*z.real + z.imag*z.imag); - #else - return hypot(z.real, z.imag); - #endif - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - double r, lnr, theta, z_r, z_theta; - if (b.imag == 0 && b.real == (int)b.real) { - if (b.real < 0) { - double denom = a.real * a.real + a.imag * a.imag; - a.real = a.real / denom; - a.imag = -a.imag / denom; - b.real = -b.real; - } - switch ((int)b.real) { - case 0: - z.real = 1; - z.imag = 0; - return z; - case 1: - return a; - case 2: - return __Pyx_c_prod_double(a, a); - case 3: - z = __Pyx_c_prod_double(a, a); - return __Pyx_c_prod_double(z, a); - case 4: - z = __Pyx_c_prod_double(a, a); - return __Pyx_c_prod_double(z, z); - } - } - if (a.imag == 0) { - if (a.real == 0) { - return a; - } else if ((b.imag == 0) && (a.real >= 0)) { - z.real = pow(a.real, b.real); - z.imag = 0; - return z; - } else if (a.real > 0) { - r = a.real; - theta = 0; - } else { - r = -a.real; - theta = atan2(0.0, -1.0); - } - } else { - r = __Pyx_c_abs_double(a); - theta = atan2(a.imag, a.real); - } - lnr = log(r); - z_r = exp(lnr * b.real - theta * b.imag); - z_theta = theta * b.real + lnr * b.imag; - z.real = z_r * cos(z_theta); - z.imag = z_r * sin(z_theta); - return z; - } - #endif -#endif - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_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 PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } 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 PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = 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; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* FormatTypeName */ - #if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__42); - } - return name; -} -#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_PyInt_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 PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - 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; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if 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 *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - 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; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - 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 - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - 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_PyInt_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 PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - 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; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if 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 *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - 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; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - 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 CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - 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 - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - 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); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -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); - } -} -#endif -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); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - 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; - } - return version; -#endif -} -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); - } -} - -/* InitStrings */ - #if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, 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; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} -#endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); - #else - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif - ++t; - } - 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_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#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_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - 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_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 - 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; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - 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 PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - 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 = PyInt_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); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif - } else { - Py_ssize_t ival; - PyObject *x; - x = PyNumber_Index(o); - if (!x) return -1; - ival = PyInt_AsLong(x); - Py_DECREF(x); - return ival; - } -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -/* #### Code section: utility_code_pragmas_end ### */ -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - - - -/* #### Code section: end ### */ -#endif /* Py_PYTHON_H */ diff --git a/common/transformations/transformations.so b/common/transformations/transformations.so deleted file mode 100755 index a7d5e60276cd55b49d154be13acd6669e1559b9a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2314456 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 z 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

    KPxVc6NvlAl;I6n4YE7)w<%zf^L-zi#?=78#7# zuTa@(m-J1jEgwkwb`f4?B3J$FosmS}_P~K{cB?z)hR1SNl5p?>Nz%qfpRY6b;*0Vp3xaiy8teIlg zk_geaI9>;?`ir+!^zHqn5u$HbapKHG;cyalAo{j_d4%X<$$(f=8=F-_ERz5Pi#~ z9U=vXAo`ZNnj*|>%p>H5o8hm92t?mne@+n=^wS)wBLdO49cv>*-|}mRcpeT!-;&ow zh`trp98%#x^li@i2+_A^Z+;UY`ldOg+kpM#a4ztIj6l=G zVF*L?ZQTL#x=@;Xu`uMd9I=SL9X=Q#`qo)hfOiX`Z}|>Kh`#k;cAdV>m8J*Wq)ol7 z;zuHqzV%_*G@DM}mPt3$bli-zr~em`^o`4DYaq~uHX)?^7?Jc%2pb^~edB^v^=L%W zw*jhRhBfx5h@@{rH2LVUh@@{$w>7Mc<0MB+N7m|MU4?^-zVSwW9g*>CZ6_jb`li_e zCvk3c`li`t!{++6Hq9106>-xy&9)gf+R!!?y?{EFmHp?4q;JLe70I#~)^sT+YgIEW z>r6z_x2n!XYORD!^zCilY`oK2<$fW#g2^s%8lJ6T<+Q--NsovTH+|kQ@AlA!a7VD@oskd=)a$w*zUa1$Fv1^!JFQZ`zn<<-CHSNT+Ws z9?`dVVROA-QnNksM?})Ma?a>tEr#r$gW`=d**WHW-psn>4xKT}9uv zDcL86hV}OpecS2SJoJsX48LE!Scw*KHnb^;zI+$Kq?XgSLrpdM zc6l+TYIwh72JVQMs%>q9flH%rb=iOstJM}GgGS$kx)-WW-?*C6xLriix5lhr@@Jqa zN2Cn;rex|`E!&HE1L&I=YPrLU?9kS6*l2It;5Mw=aa(IAsh(q@xQ$lbd~Bz>E~<2&??InY6L`j)c?D<)R!aL4Z ztS3clPSG^mX4q;oa@Ikwj(DbBwHMhkG@Ft3rIb4g*{a?fGdMxtJne@yD$>^36{F_M zl%?6UZ?F-4(`>Blyh%m7S{+^?ubz6()0*Hq9EiR- zVGL_PU-U{r-*ov7WO~1(F2CL{;-+t`=lK@M#6{oo^pCjd8~5cUVi^qU6F8jL>6_P~ z{D6p?zNw=b)>hc&>U-NXTdjc+H+^F^!}=Doi@piD!63}?1buU=O0BvdHhRBgCR>BS z7%|2BC3iMq7b*|uqHjOIh2Af@0!1JfD`AM3%z(bF(d3tglDx*;ss;$dx&oQ#+ua6E zklw>^n-}y=m#;ylUu)Cley>F&ebeRJkcqyruTQdoLx)EsebZ(0^@yZz>r}akzSS8K zk@Ss?$`r|e2!k>0ZQBD6*WNbK{PjlSKC06!$dcu zIFi0i8AUGl%$K+eAO52I(4>;SeLp%P>Dve`%2$XY>07S1$i*MGK#TGtqDcB?kBLb7 z_6=(eXQE-a=-Us{FBIqa8EH+&QucTuTR%b|`nK0;UVfpAk?PTLXk$U&o^8%5FKTuM zWs>x*;dpW>7njamM5jD}c#^(Nd?(`2Hy$DO*n|ktw*@M$Qyb?m!~YwOMf9!pM9Ng> zNEW5lGaZAS=-Z-65u$Hd9m$B5nN0SKtb!V`ZLo{IZCU3}dzb7RvdnM&1pA$K01$pN z%K%olDdd2c@n=yj!@3Ix`n9&KBfR|{Ib{4tgh$_xNc!e$Ax|T3FT;Nu?Mw8n|MbjJ2D)9l?u4W2ht%i;0nwP(hraPaNYOX$u@X0I zqezZk80oRMO-bG_06Km1=aTe|-{Bnk##@&EN)qUs4_^xyeLMIPj$p=?HHf(ATLpLX z#!?$bT=dOrzXZFWZ|qKICVK2TeH+{ep*VfZ(lwT+F=lX_zGZEn3%l3==dl~Hq$ZeW zaQc?Xv<@b*0WOp2xu&@D@(pl~$%yTRDmK9BYO`h$qHnr-8mgdgnwr$DdBmY_HPN6( z(j7?k3xS2@1`89?v=<`|eG`(^BI3|DA?<;rHoys~RZBdYkQ?BHbO%zC!U+F}3ja6?%?KvMKgNOo%s-;%xw=?o;b0ZvGLUy3;NjY|dPw^A2<`@256 z8|YhFJ$!Qd#^#ZUg;}eVJs`zo_Dn0WG#8ttMTov}Pa$4_DCnE!+1C~vhF(G`Ja0kN z=$jA+q7)i^XG&?WmSay>)kxa!@%5M8MlG&KR*her$vFBpOVgG^|ggqN~L;Do&b@mH0kc`9K z!u|~-vi%eWQoHj!B=a#=+7~er+D~EFvX?DEQt%TbwO1hNv90t(T}9%%9x?KNaua{$zKx{I-$+*8LGt%qBrp6EF`_3iIIkHHHPS1X z$=N={ABEF@D^a}z8+l6p(Kl+`gFU^ZX~g+YEisIKJ>dCg>@OG?dq}@I;|3d2THnNo z|0e!4$`t4akDHmLyFxNbaR(pXo5C}-XF1)8;b*THW$$}Tzh0et=aAk#;B5#kUTS@q z=3kiMGtRt>L;sal93^PXO7WPNcE+gTot~Xq4Mjj?cYlE-N&E!O=xNACN4pi!57D` zg<@UkTB!2ORa_FICgDPTnO_RAq&`uOU()+I0gc$pP}vJG(+B^C%SfJtOK2f}6(+{k zz=83?^w%_plq*o#dnnUK%DR<$1!wb!X{3+lhZAQr)*EVzPH3IUsU4m0ta}V)S8S!& z7jR%qA$_Kv?H1HKy`j$5)pF=RbJ@lG$%iVKuQ9JTd!AmdH%t}EtY#jY;&_vb1{2a| zAsJ;>F$ejtg6sh7X>Dxn^aSGp{!gFAkI4-o7V& z*9HB&MZwslj`+k~wM9ubKAMS>_}SYpRZE<`Ib4mPkyt~uNa}~HgM9hxe7iBVSZo+R z7#(U+MstX5g36k&#WSLz#3AlMt=}2h%HLAKd<*z-#zE$$%1#*H3T9F*!7u33sDsb2 zTfp7!ha@@sw@`AnEK=nJ{*?!vx@Ae+802u>vRIk(&|5xjCaz<_%JF|Ci+}kx^F!Z) z!zt!ehW*=2{D!Of5tgfE_i~kIk39#K6|-f^zq|&_R}?eW1twPImW>>f5t{_{OZ?xm z^Qc@HTzGJvK_FH&T45~?F3sd@$64B{e2MCHF>sk>cHp0_>Y0h>*m1hAMB+Ty5XRLEPwMBx4C*M(chN_^QB&0tnZLZ_^Oi?VeMw3h6pt*cb2%sMO6 zYvyxWv2~>~wV=1IYbIK(TgU3-UsajXiusy}rMcQ$sxOtpzoqX4sHK^2y9!(tzRRWB zsix+;2P$jc)?F{CxW0H6+|T;aWfrDt?2h#6sd?39Ua=(9lAVOs{n>~k3)TQC>%^^x zmq+bM<(-&a?X4?6GYTK0FebHrHy0~SY!Uv=&RXja#93oy=H>95wK8pnCK#<7ngw5P zYKj{RYad_pC$ky8TXRvMGTA;C4y=jU<;)vUI8R={j&TE4&t)Z9Ae4695QvtML!w@8oP(yCoQfQ|pxYusiA`UMs#01<&fW;zyazUMoHx zPl?&utJIcd3T+G+sV|v{Up_#|cCh4oB!>Q4@nLi0_-h34TJcxAB=Gfh^0neenQ!co zt_ggKpW2CCLS~{+*FqJq6+a0tQuWu0H%7_DYsG)n9FC)GD>k7}t@v2WR(lncCEyK` zv_8O3?&Qu1{I%kFKfyoESlLbq{M%^iqVLcWX5w1J)GlfNSh&$^#eb2mD?F~+YsE7k zQeTCYk%41l71sLxtkGj*Z%19Lu+IL=n&r7aqqGX^3jU3SVoded8?9DhMgA7|yb7rU zdN>Y0qM)=2EBsHCR$)!k9C9vGtFZ1rh|(&of3!oS;}En8YqyyoBFsF>Bbe-j`70m- zt-@NKJwZfRa7T0KhzPU_Ymh&IR$=AfXGzqe8ysjAR_#Cnt-=av4!z+(tFRskCD1CY z1kIrz9B38R#rOnTh4rxJFc=QB3Ts;=fmUHXra8O@2U>+SJt2WsVLh%Kd{5#}L!Ec5 z!aAEffmUHX?eU5|{cr-U!Yb=A`QO1|XcgAfM-pfiRyp3>tTlb**pmRBDlE+*w&KwQT7{*n9Un`eRam;3FF%%ZkHBJr9lE*?s#t|pMU~v}uNa|L zVT~@3K&!Achm_|ECa6_dyi=syh9XyCaV55@Py(&Os-cDMj?P1?u&zImpjKgtEX#@} z&?>CDy;(DG)jthQNUN}3C`Jy4x^V~5oyH<2t-`udoE*+gQW5BJ;XH()RahUCB(Do= zRT%PGj99b^tA42jT7}g}Re*O3T7`8xDS=jDHD`8x71olc$@GAmw2{PWT{=Oo!fM5` zX*PWoR(vwKnWp1rq-}ys??B*kT8~(QT!kfs{ACj4Dl8%Fg+QyYxL^$}n;=(VwNn){ ztP;;8$W>UKH2HW+f?S2=bX&uk@+`>_(~-5hSgGX`+^ewIx$<>KWNcKdklSl@uENr*^D|`E zDl8Fu(hCXhRaio&X`A+~T$3A1K-PA@H?lo3X5NM&MGYaPqhk*XTY~KZ55W1jELeJVVs=z6z4~B)bTgudkVP)N z8a$U=YMC3k3ombUF(#36=~bcmQD^BDJCI==g+xoQUWcIF!hF0CuBBHK7Lap2Q*-8i z)^iKVW|K|Gw;dNgfXo5 zR-#v?qF46T@)=gmRZ+S0O834Exm!JW%h!stp68n=6W7wKFIGq0ORu;uFA>Xtk#P+k zO6p6mybfhPi@KLysiPUzIoRgvORqHBw9ljNrB}>`UoT%9buYaV@*T*_#nLOMs-m}A zi@u1;rB|73jn+lw(yQvPvI~`mb1l7k02f+%H62AD7we-9Q9gsg(yQ5;+-MWYYs_EN z0AX0+%^1kUiw_1kSG%pcC>6MVj?Z8MamR_xO4io(t#gR*|lD{FBd*)H@!iT@;bu_75dbNL7R4%=` zr$t$gD01o5fZgQck1I5k)kj3RhbVICRi3?3x%6r^YYuH5?OJ-ZL;8i{96uwi-*=Qf zUdYxH`=WB`)fZ0l@(W#zRJ*=M8;hk^YqTfyZTm4wORuudpK_G!8?wxAU4@;NUS%1;TJ{q;M9i!sbUhZ8ORutyQ1m!C zWc){j({P}l_8tD3tGNyTqiEl^GO&>95$lbUU2~t zz4Au0ewMbYnL=1of5r@);#Z zjrJ3w(bB7r{(xI|wDDlyN_R9-c>i+>JPYzRaIHK#=dw9lQX`mDrRLj-ibP^s$N8c8cD?`0C&h$RYJN3 zNxfEFNUJ7BomEvr8a65Ftf~@Hg~?H8Rh5u@??#(#undPb~A?<>sR#gdU^wg-cs)|bm7tps%&La9hfiI*+_Uxa%f$oM?Rfk>^ zpeZqlO%W3-uvRHMYB-6>>={*JO)i#uJxZ&pxTg@WLlmp3G|#0YqWU`xgy)MRF|l#p zX&}VxD22AFii@heM*eIcg6vM5gCubtlC|rRwAqN{*KJ5D?L_i3=1ca7Z;=$+gXDjh zh1i4kBgy>(k{*YU2f!}U+4#{o|opzVYNP-y8?4?(bG`@=DCdMNB zk3W%o{Wp>={~%dmB;e%)aY$O_K$4gf$vuDs`#Zn_dv+Mft5GENb0L}W5RzZE4j08bW`*0?jnh}@F zXx)cF(bO*dPfk&dLX6O5JM)KO6snAD@%*2)*rR-Q7gar%jb%$b z!POt3cJ6B!RWE94fxo2hUF~Q_fhda2o$u>%#p00J}7ip+~vu`*1zS&jUe zOpRcA_&7|FOs38-vF~bCAI@YN3R8A)#Hs}{nI^-;i}9pp`iR$ZDNL`iV>Qaono`uA zFC!QQ6(?i~Dx9-wd2vFX8iNz^HE48nB69N+Qi)DTm28Pqq4}5#HGDOaW-^^6)cP-w z&PyOpNGeI7h1 zCY>kia>c!nc}u*PeIJX=i_D8w@n@L$37MJ6WS|ZB3Hd0KsW43Zge=KqdIlzbLRMxn zrNYFEu}(9I&X@rcKOyI`v!)bvFUX3>Pe}Adkoku&Y?O*K^Cu3#!pzr_@H?p(OzWox ze1qp<-3|U51g%LSB*n9J#y?HFU0l=R_~+nlSbfwhu4#4r&DMt4z2izT2fJgOnK%kY zqf|4P>`v;R+}f4?=^M*jtX6PgrMJ7qO@SbC3Y%d(A02SpX9NdDjkX_|MzgNv?mfVF zj&691SvGu(c$9ycBtV?$1Bod5eEc_<(;*T*^NtZQ>u3O_N1=Hy{6) zQks9fSCxOfpT<9?w&5Ss`tXkr#_*3BGx*2MRs3VtQT{Re7XO%+D~`onP?&!#OyVDl zYVnW7jrqsN{rJa{iTq>fQvR`Q6aQF#g@0Vj=3`NAl;a<_YVwcU+t3uvy8YRV|LgCb z{Nv6h{&9CW|F}1UfBf?UKFa!fCKx5~f7b@=e2Yt_S=%PNvLSTa&PVyjtC#r4J9qiV zM+w=P?eil1V^r5&p-Q{ zr}^gy^EUrnWQKCEIP1*<{By6F#6M4&Rr%+2vjP7snXMiFw6gslV{ZW-#rb`Y&(6Nt zO_&9OZGugKAi>>&2MZqDEn(3F_u>x4p%iO@BE^bBks>Wlfl{CpYoS=7u9OP&cg~%e z&BEvVf1W?j!@1|4bKg7f$j;7gc6a(oEUt!2ETN`LEUA`CEUh+4ETaxeEUP||SYF+h zSV8?Dv7&k*v9ikO{X^GWTyu|9Nox~cdzrW;joK-( zt-2twy?P?CgVG|{x1)-Z*jbg3*hSTq*j06s*j){gn51S(OjfHT2Gm}OJ=JN6z0?hf zebjdn`>KB>_EYK8aXI~!DRF=*C2^pNmpE9pk~l>5lsHt4lsH1ok~mVWkT^U1BXPX?S>gocGPt~nDzn7NDn{ZIRbJv$RbS$C)n4KZ)lcF~HCEyqYM#W| zYPG~UYNy0`>SKxX)m4cL)FX+D)H8{TRYo6|`=%-=@hw$N;!@R0;xg4w;tDlM;!3ql z;@fJ6#8v9F#MSD)#5L+aiECBP^z6G%6_>bP)sXm}YA$i3N|v}u4U@P`DpLmb-=p$L+^fn;{6N)_xL>uActG_=Z1WKJdW`!4&;Tcf zu47!mGlP2`Y_0W>nkx`n51I3~gn3~Znaz)qu;AB7W(%`sVpvpE!s2)dZ?>1PWRQfn z=15q&O2V?O5|&?)u;OVSlICrMcQ4no_o7K8A4xpw)1@~QZC z#cUSduDs16+f@hSyAILq5^Rqhr2}i$_@X>z~j{CE5_=(aI zPBxKns*i-zQzV>OBH`>V3Fj_K_~cs&=RJN7zmQ$R#ZnSJtta79CkdYomT-9nLgEm^ zwN|3fbx>k@*ENYbU7Szi5YxqtlQ<-=i<>2JNPZVLNaB!Kdt70AToD)^)H_1N0-Wj5v@m;t{|aI z!gY$}8cSBbt%M3m5-O%js60|a+*}D&)=8*(P(t-f5^8+#7rWH@2_J-RJvzQ8F4|g; zu8lt;BGeh2m7(4vsjUBtgoJ-3H1I}qE{!rvXdEk{Np%TLTS-XlE1~%WhB4*ekWgX1 zgo+y&#@E~@q1I^$@z*8Pej=gH-xBH?*;!dHmxTJoB_vdr(4d)whTSAI8YH3dBnfR7 zF-%HYCn0&egupooJ-?LD>qiN_wH&PMlUYLF7zzE#OGxQ1A$6>T{!1kc*dbxyX$gbA zk}xWEGE8p~W-_$QA)%E#8%%FgK(e+KB($$Dp<_DBBwdw|{7^!VrxF6**SNf%xh3=}A)$8-34Ib7X2o@9nB62*Lem)%nyr<*JRHy}kA&70B(!NPp>48+cEcpJpDv-pyAnDcmeA?Cgw8)n=;F!CW?l12 z=vGle_ofn(dLY!AxE?1n{9iadLx-h!9TR*XB7Sq48owii?@i-cgY_=FF@$%g7Vk^< z(&&cWMf~hB-n|M0X~#aKAIZBh1;QF3alQGkx09TY>hYyrXCGcOz4_d$)f#DJ(hA}m zT3uJU_*yD$Ub*>%d1W}h`%uxc*)6_`#pNx0O|`~ce1pHoTV!3ySfM2C_8nLW!bloR zz6F~^mhUStg2_}Z#Jgzb3L5vw){}`Qu!rd#7T5h5!|M24nt6trq?gI4soP|qM}QH` zdc31@E6nP92WOG)?M*7g=}$jV6Q^gtmlEgzki%gnop9gkb=a-)vCX z%7gJ|RDF`pBBQ1jlWiyiMlctb21_EmPvcxEun)-Ex7CLOO}=bi!=H0>TQygCc;cCvwJJ!v5XKW$6Fwp&pw4W}2H!Ak!eOyhp-Iy(!F-jf0eaFHNEk-QQXSA5VDjrf zs!)Hhh3q2fN-}C{1KIw5U;=xYe$W*u!DMQlr8cx1(#sriWIEWF)Fl0ejGFp|tl3mB z0qt$1O-CUmm`u&A)Qr)XTK^e<`DA|(^1Y6dGIXzwK{}T1B*JvUY{C-4?eT#1WZMZ( zCIAkQ9Vc8Md_nk{@Et%+XVYy1kbX<}gT~*4CIjJ$u>;Ka8R1t#mO+4WghDeht21oS zfoUn7?!Higi5;EUqY6LR_wT4BI63pC4l^jlTU|nOEzi`C)x^xG;0Wh0!M73n3x9Hv_ zJS2Qe_?=LUCJ>s^Xi3pnGe}uKhvok_7|8bO}Di}8qprGjK*5RM#2MX1v>!VXSxeu7F~@l zz%nkpdoiR0b0bpoRDPrc^AuexrSZG~w42n(d}8pcE8DbA$pYfG&YKy85G>&~<%p&wx&4Y~N?WsvH}rsFF? z8%E}?j4ot~nknwu;#ebsITMC?CJ$1A`5s3I+eucu1Pp5G7}Eg$JZ#!N8ZX2K_g?+NL10gj>0EP*dv`pPmr$zemm zOlev;H_|DD8#L|{9uvBnfHj04nEnbdhqB8Kj+I5aX2b9hmgIxR_9k6lHflKl>Q@-P z*O=xf6eg4aM04wAZ-y778n#8-lGrL`A)D7^o@7iFQ}bJDRq;m(vuGA*4>G}hK~2)| zwP2!UCR>UUlc1O?Nmyi4%QkQ`dOr~ZYYDJb~eg!rGwv%OD0jLEqtJD2$ zCDI~vOA^WvDidlG{#gZRLe`cLjz7rwx|8)I3?qyu%p@!Vs6}jgVIIJw|#?ORI3jk#ZEeW5Z&b-P7qnKXhu!CTxG##)I={dq<8ov_$B&=Tq_=fN=Q`csU z$gv(>o^q@#G7_3E8{zg_(AeIj>&s8AFhEsW3RZ$?Swba3HGuiST(|^t0GmomrYd4B z)nsbzz)UhFdyD(cTuI|(8SK#e0AG(gfU|_B0P`T-jb9^;=Yr}J8WWlmIudp~fEyqi zKsfvm=_smm~K6ev?|$_55Nc}Q!|lT z@BK)VPs1?pf$>J=K1utNQBxzyw%-90n9ekc=>jtU6)=Ly)Lc*P3R2%ijP+D|D|Dz9ifud{0<+1MrkgyARlT6OfK9E5Rhh63P&&0#x*SXxi^A()S4U zXfz_EI|o;cR50IM!gj(X!Y_o8s59HMLDVNm$8uOZFjJbQKaaFGVF8U5gw=%F7XVWU z>zQr_n5)=jF~`ax570P582uSEwm0eeE>OD+P}gAizF>Nr@HOEPz-)a6F2VerO(i8$ zpVJ862<<6dG9`P9`_0TtqjNdH5m&K8cN02u;YkGl z=jbfPC@|l0!Xd(K!gInr)R~nwqe09yq>DMM2bd{Mvws0?D8O6`Lmks}%?z+u(g9@D z)F`s%FHj;dgXw|iNEebV`UQ+&GBr0)OZ*iJ8tBq-nMoG+8=x1!JV7`6A4rGM9ZeWd zm_nFK$omZLQnGgmCH_LXm24m37~ve@D&Z@D%Dx3nAAf_o{Eq>TY5YK#j#P>9Ee+!d zpctVEp+6yqj+O4f28)@#hSc{tm?=$XeGBa&p)8GRgm}WS@1W`51L`wv3@}%-OC}VX zvdE4!x)J{T2^!m*bbSM;4F#x{KO-H*bR1zaVFn?073^Aq`3Oyw><{i4HSrPFC}JxX z^e&hwAn8I5dyCNQI`--U!b+xV0A>}ASj`Ud@HH1lg5HFoMa{jHfm~6ISJoJb-MO z0iy};0nBc6+h;{OpYEH4<%Cs)O@!`IfZb$=3H_r1r^!Ae+#)M;x76DC~o&)n0NC#+2qaC3$K{EjH zge0cD0A|%~=+c~HWs$>ayiTZ?5gOZ@bbYg^%>$@KFno)dE+f1{SW9C%Tcw17Eg<_D z%p_CPOuA|#>VhAytXtAN$U=&WOv%pVe)M(C2aO-g>_RZ_vFIS<0L@S=SG z!Hwfgb9+IpkC>~i;hL6fHT)y^AN9FQ-s%qXp{Nk+&0;_wS)Q7Y&?H&LYI<`dMlNYK z1fTSDw_=Ic%fOp6?682O9 z>>~S+aEfq=aFg%=pepV_)BZ(}ZYKOl<2OS3qHx6+2e8-rcB%C9B3J5t>DZHSrfjxZ{vYD_GGZ98mOigzI zun+O8cVdcF5;BAKVa}G-YGo|TsYV8sMPiXu`ct$AO959UVoT=Ui zBeL#Bmnj@8i_8Sg=O^@S4UO$hy1oL`iU8Cp7`~EB%MmIQs?+GoR;wC;^&yLCjIm^j znn_npqA{)^N@kO_BU?ovGs#RE=E|Bl)(GYv)(Ja8cCZc%YU%>h%JDqUG~glu=GW9D z%YUL#p|a|F^YbaxQ;5)Kkh5blizTqL_r_~~_OWZx5> z60|9RbcCz`b%9Mc^+o!SVA6;oB=mzT#uhN&dBP8b3@Lz;ghbSt8TO(R=e4rsX9zna|M{dd8ReyAtjhh&AZh8Me6JN4q)PZz#~GI z1t@tz_vAvPJ?Qo!^d}4v|^3{dIjg7s#aN*GKSLD-&vLz!Ua`2agW zKz54k4?c#>1Q@>EWG%>!fGIx0%@ic(3>z5b><>An9Fo7hkXiWO4BK8k=`M^OJgfxC*j~az`uljOb-Ff8|-4B z*px+{qwy)>myOWa-lXgMirRgEYO)FJG1DIizY_kW!Tn_6&x~hU z2kUD#CJT`L%VBR_1?xsl(!ONW)KIe6%U}YNnHD;QlwdM7-=g*asjvR$fIg=I7YY9W z%)NBqKZ~?6-R6WggpPy&Vefgs0J2epk1qfwlg%N#MOZ`FLf8vX=?H6wXYXnf=!0;t9ZB6Jv=t|=@TWMGs#T{UN$F$WU zus_JUf+_AEQyoIOl|}}#3uHam;J=^1@==qt7#THHfo%Q{U;=fS&ifiE!DMQ-r`Gr$ z=Cb`~z-MF??gNqm<_Nmk9wOaC_WCAAEr{&vif{8pQ~ckt#7B(eT~?#1a}1`V!is&P@Ly8q8u0CaygAvgx~H!V|$aXZyUAU0M+a+*nXym2_F+q z(|CuidSi_gcYygm(+|l$AUn-{#NA__Vwx3o<|VT7WartSi2?TkHA#OYqo$sbeH9KS z;604=%YQL~U@|pxQd|BUC)v}@Up~n)H{)oN`LedaNmkO5K4`DK!1SjOb^^>K)+OWb zQ@(O^D-)^{Y7?3e`ndsZ$+{CpDr#iI2;&Je35y7C1Jnm>TIM$_qd(z28e0jUAys0O z`yEDW!f?V{g#CmYs576j!B~bV7>>0ut-2bLVZHfSj=i1 z8>BKVh19nV%#^0dnUEeK)S=Oo(2}q$GvF4X9n;PL^8~wm%dxV^6dHpFm;BJ!-lXfB zKy4~O6^jC!#dIEFF<}{vjK{$0Vr7)<50mLS?wMG!?c6=wGiF7m|I(;MmYXB^2s0Cz zR{a&M16h4A#mAr7hv{M(L&)}m@vRrFEWXHvPgnBWW9A$>!U$dY4P5?#w^>Al``99U z5(NLc^1HYqri*Z&al~o-HW(|72=^sNoaKnV2={ec>^2V~7aO$>KCKnY{xV(z zRqequ1^}6nMcp%cgzZ;Rd5oB>7}<>z$ZKdZxtt`Q5gwD@Nn(u1n95F)--wQBV8!CfP~a8Y5$-I7vHWLd<(k(%zU6^Rbh3Fy_a6#Eq=#`P=A@GZj7u>$ zousF6J?1|r>1EuFDOlQW(A#(%)5uBs7(d7Kb&|fuv%nlD>1W_uYx|rm#Rzu=ZaG=1 z5$Ou3GIqoMMzkvs?PLRtJgz_iCmU$Qx&mdLY>-jP6{ziGgN;hAKqn^~V$^g6MmgC~ zBf%9|;$*{&L|0&)lMOf8xdNA*Y=qIx6?pDsBaPm!fUm4Qvr)!CSKu`#8*Pkq1xh*D z>&66Epr(_JF=n^|jh$?)G2a#F=w#!JrLMqeCmV09b_EtY*#u*wE3nPUCK@|jfh$fn z$=L4-eB)%3jbpCBKTbBqIO7VWFK5qls&UB`$n9j)jO(sIWha|%+;s(7IoS;3u`AHq z$z~cqy8;uOY?krN6`1X0Zy1^$Sng!Ajc`5izLU){BK5#|C!1?T>w#~bY@U%v4?K6W z`9`cB$bethl4EayQA!WwcCv*=B|T8i$rc$k^*|#hTWlogfo@Lrrje)z1~}Ogqn#dj z-O1iEy6J&gPPWwOtp}Dm*)n6G9@yn%%Z-tkwUezdCScZ1w$hlP2QpT$=lQlVUk~JS zvUiN7dZ46}tuj{Yff`P>+SsTE`a0PfV}~AC;$-g{`}M#ECtGVA(*t{*Y@KmN51e(f z^~NPV@VS$1Fs|!?2Tt~$aaRv$744aAG#=}L98R{$_*oAWbh6FHGd)nz$+j4pJJ8I@ zwi@B?K(dp)Z$!ESgPm-f5$z64aI)=29(Q1clkG5K-GRMMw$mu(4xDqcT}CB$;D(d! zHfp*9VU_H8?lBVFfoLb&Yb3e@Wt?oE(as&H&Kb|#f$>iEiJ_^$JSRJEgsZ?RC%a%os=#(9yJ$qKz)>gr z)X1X(mz?a95vu}UJK1MODHZtD$u1j}R6xbqYjnk^sRDi{yJ{q;K&+E}ZX~KeoReKM z+NnTeC;P(arUG4@?7Gog1qM3V4P&4ROmecD#z+-d>}0o$2`aF`$!;4nRA9f8eQC^B zfpbpwm9bO>Zadi>W3>wW=wx?|jVhqw5<$){UmH7=mQ)QXFCU_Q!{y8b`x>PZ#Nh|mbiC@Qxii?YIS6Xjfsq`EHRhm<+X{%b&*N_XIL#q=J zdGV{=R`DX`4o{&WB<+(6{kmXy6;hiS*~WtOPuEbi2q&2;TF zg#K3ucK`!Eh4dZBz~_LwGpy0L?$x696!WDPX|HP;?}Z^1f8Z3$SM=F1Hqr72bOg!C z!jz>q!?d5dz#LgJrp8v)wapMx`-AKQ8L$WBV~~MKAB1V8CWiF;tVnd~A6UyFFtEHH zSHrZ%wvRunYEikcyl*giFbr+r?z>^yI@`uEuSJ!};!Vv_P1laWNNoc03CTo|Yaj!@ z0r?ta5SQx=fq$|c>Z5Nf43_OM9Yp#b0+GIXYlZZ6 z20DFzL{&)Na-n@2pzn_uEPW4xNZ;uoR^RxLzRp0WZ!1)V^i2ru+X#KL)wcUyKo_eo zi1h6UE4Y1~fx*70vihcQzvaOfw4%D9-x{aiRS@YHUdQg&A0*gssXY;=Ulo`k^V|_S z&m{D%QrDiR7exAA4fcf+?CT74`mPD~m3by|o;}d7Sv{v8h}92mWWC>n66|;4m3gi~ zRmeOaht6{d`rdN-W~guXjR%pw8$p77oq^6ghrtZ#`)_F9Vdy(7!Jcm|5SecV5UVdp zu&*=F>3i$tzLAqdj@J?F+ra4yV)X^F`ho=eIs=1!u~2)ypWB!^owUV4FB zxajk=A)LpoEDPFuwUi%lsPEuB-pG2`qsO!W!vx%43#hjt8}FP4D} z9FNWEltiK=s$-4xsXt@zd>8}Tpniq3!JRU0@NQALQe$As1|ReuO7@5Bj&9Mu)R}Pi zv&V-Z$3Zl0@EN;?3mVV{Q`mqh;8|b>);xR~82-tVL~;#Z>S}Dic$F`B#rNrV1ts6I4&*E8AJuP%C4nk^Ika{2kPJ*-`F z`hpA`0cae$;7Y}PsS8m*69#tcYIGgY6$`3rt;ah!hNjr{xlj-_J4;xqzm=|Sg&{}D zjF7bq>!3%ZHh^m#CE~9R@uTKo^ccq%`@>LsKJ4v|tqtVDXHVrO#OI&zKkD5q?qPiT z4HdaeEoBL&pXWc6EX)#-dJio&LP)LBTG#e~3~1C2k7JT?Am>5kS^j5x+1&k6Yl=st zzK42i3va)JEzEwD%eK+Ak07Mpgnt2Kz-%ZtKn5%OvWAb#0T0^h+9TT0Sjw*;ax6L} zvY#8{SbT`Vax6ANeehUx%A8{{8fMzD7-=s@TpWwz;L5SM6T~_eacdeJTdO(gmN?iR zU=DJy;c(-IbS}W;Xk3F!mP$B{Ufmn#^{Rfhb$)BpmZNGm(E5bhA$(Sb;G%9dQWyzfQ6{o2J#Af@2r|My&rLOdI1Q_wkG|!%1?b*R+jJatjT5 z+mD>#uHGYUI^uii6P$!2oMURl{&Qj4V*98V@f*sP+M9g@m$E-Jx$Pt@Q!}lZX-Vm- z`m~tqc=@LAHu#Liy69mLqxYeM^F^z=J@Y`~Pm4q~Mcsb8PV=^eQ~_3EPA}KI9H?F_ zDITGl8xNN+!Xn)5)>}=hLriK0n1{lsq{%jrXBHsBN& z-3iV!+nEkAx>7o4in^Ax8OjeVtAnzHWmbdrESnoF%c3Qnfs*wG%D%>*1Ac7fk`+GA zvTB&IwZa*-qz6!{uE*K5w4`28zF^s(C`+`<^Spu*5zBU>>|eXA&&y@l_2ZnfJt%u&myLp$ zG!LNPLW2`yGR=fKMia8!Nel>LOV zSi9^78@vEaVS~MJs@Tq7FE_wDKpAWJv@IE*IQT2d;MzgTtv-M+BPdcRy2p(TxnlIJ$cE}*Q2J-5*>mxXIdi=otK*;$mm*Us9A z^Ik6VYDpWR$hJO-vd(tdT8K#p0kRvn!l`dBXCIxjfOpyYAe;uaa{^+>YKLh_x1h+O z{2R)0wzp<*jSZdy?z6#twze1g?Bxcyxn7Q%cG&}zoo#D1$ObW~B0wHYf5EwAHz-4= zD?pCXD{z|HbL&87xZ_-f)6RAV(U}8~O?3`VlI_f(vj!kr=M9h#u?pYA zNw#OO9b(8f$gCw@fpURm-=d6PEuWU*D>S$R zXQ%DBA%-j`gO-#JitMcSQ8vJys0lHtG@uz9?1D4Mc8a~+z^x_Kf+7dsMU)M-%c`kA=VCd}nt%Naq`Xtj{GlAK5dw zN9Q>}4vO7y&e_g0I_YcMNBn6xZS8L15R>u%S?d43Rvk@Tc^BB%swzHPbNdjkm6HZ%u*2gG*36L3l1gD9;oa=Oc z0xY_RF)r-j7Pj*(#E>0aRZGf^_u=J%{uvs~wacO*CY1%q(fb5Wj6IzabP@q_jD8Gf zg*~Pbog{!fy?+H~jy=)NbjCPij>B1Jj~PK{EfGr<@bNy}0nF%rE zQ!ThAxDKTp%LbwB**jL*6_zavUPj{?IbVGo75FqvRMBkssE+-5AUDLML5}k;oV&J@ zLg$#{eB#H&*qc`CLv+$7*xjZ^;bnpCghLGZ6W8ysCfKW*_9rf?GaNPe=P)fg!ad(n zgMSXAy3|&+qz-7G`yp1ePI!cSwJo=X7@dR%x%EN-7eD=+vf3z%U2RReC&Z-PfG%vX z8av_GD$CghF=Jn-MPJ9;cNskS!g@!Ad14B-%w!!i9*-7t0M-o-^m@W$Heg}5`8lL; zPh`wojL!B5PJ|~qW{sxlX^PNpj?=y?R2Mez;R0C#v!`I+NXQy_!`;W z&b@|1)ONfOlX^H#QXXt6+v!SYzvKK3r2jlaaQKT`q)k{ zI-fXBY7ExLc23bL(!}nToFD6BI|U#nO?RB#a5Ve%_9Tc+*I;LtZ;F#pbSYPruc2sF zo&sG}42XJ_JhZgxtWqtGR;hzjtI`qZs?wJQR)cL@GifR+eMFVv;=e8aaq-RSZSaxV z3T-j|dIzu(kMT)AGBuHGL3^-a0CPUmGfbD0i6(9ty4$FABim1wh<@hBWFvAxnh)M5eL5Oh}r#pFk6qo@^jz`Z{5JXTV#8f;4u5shZu8mS?&QOw}M0 z&DR~Nmu^dHMaVjn9it(@)V#qi?5tj=D{LxR_pTV>>H)|OP|K)2?g@4tU~XjkS}&x# z$V3x&Cf!riJ|Me9R+e2lvJ3mE2h@c9NOnH}t!h6&=Dw)YzlGKuO!>$}J3%8S)5pDG zd`u|9l*}YE-%0`74p6mej2i%!1Tb4L-OIESnP}p^Mt2~!CS;?@&a%rd?81I(E;V6G z$wu{u+kX&X8o>8t7)l7{dvMjtpWbV6}2vOpAJF#1Jmp@{v=z? zrcFk|y)y!u@f|di=^mtN2HEoAF!Iy*1`I!42}VtIr%{dR6tXjDr8ra7oSLwXWQkmE z_fddRgaOnRfvJ3Bkd9+I08Gswqo$s`4&yDRK9(F}F&n5Y)P(INtIfKHV*$?zXQ@Sv zL*3d5NUt-^KM^aK2vFZJrJ+*kK4m(WtOiH0i%R!BG+|lEPLGGXHWu5t6`pC#SZb1% zA)}_M%7_|Z4+)K!9xV$-FqxWNsf{TIP_+TB@_?R%MF4Xw-MSS45p**UvJj#P`3Ozo z0L92E5IR%=)Ff+2XhrBk=uH?5P?y;>YY{*qVGNClgxyG$82+M2D-zlfMiG`1wxQ0< z@&nj0rn@=JRScRm-3R8&R2*=c#%F|Ugzu@9C;_;|^e(_`&o0$CRu=ga4cw9e-*PDf zjqOdkK6f2JI6#eu;Y-gnGa-tQiv~BlxrzO<6b9Q(W`Zg16!T-I{b-ygn@yw0EbP2n zOece>hh(BXWqNid+`p)O52ofb4gV48Zl(bNygzK_qP7G~6(kE#i(qksGx))XI2suV zRcBLU$(vxRC7Ed9bCBM818y&BFTm8hOouZ)$#evv$`oj`sPV0EwU~^W(rK(^T7c|* zvg?yz>>_-~l*}YE56lJIIS=qTjZesa1E^($C)9-fM)vvwXfi@hOWvQL3Cl$G9a}vm zy+!^hQ(2%qo88ua%EV(0?Koh3bnjs~aOwI1p{zjU?yX56>kuWzW&?fV>0w_uM zbb&TL5%7SJsX5wgWZm%=fCF@o5RMbh5H1rwX$`nd_K0x34d7?8zX_@ zehbLHB3sE_$h~L&!1M`?KgrTzrB$oN*bAOtkgfq!kz~|VP8zQZNL?aSq0G0VW%KrLs9 zuytfx=$?NE@PM$N+6yo>YYo!VOpSMO7*zzQYfNdVR&*aS9Y$7g6*P8He^C?W{uON7 zYPfH#1*|1RQ9BH#PQS-tOtpo zp@vfvHi0a4J=|GjUveidCW{SVOG+wiBelP%?IL>trU>RoOtbbxO2ZWPIklQe&$kKrf8QNp`e1G)c*nFqW7dP-0eRNj#ZA6Q;a- zoY|IaWe<$tDwsW)2JpIGk(tAoE=6koLw5>OGR19BN`>LCB^x`N)jXRsX>atw&6M+K zu4*ToByWPN+Ua4qSu>q{^Ic_F-Z{oqw9oHu&E21{8=zTw{t(@k3fPiVm3HB$yz}6H z=R*Hr)Js-1$Q^0LvedR%rIqdhc{Z)WA)~l#t@JX;AJQtqJaiPU@35v}VI%N5Ax~$& z=O)&IkDks^nrCAp{2^0#xaX^&9_jgdPo&%>s&jPoD2^*ya-T=T$9BS2!HDi0?zx@W z9vGo{s`;$%26c`I_we?X(l8>j>^(I66aPD><3=m`l=H;*=n=xg_G7Bioilpk@Fu0y zM{1rdw{UALP9`$k6F=7O6B${yFlwbwCh1fC59z}#kpC>Ku&}Rzt}Y)1f5bibW9g!N z0awUv5HAZBhpi`Vw|?4x zhxOC`JFTDg-(~%@|8D-YKQ1+%x;1ZEKz2;In_-0I=@#a}=}%MG2HiZGClmBpnZVOU z<40>Cs*W7e6VL`$^hG1ARCIz2DGoP!q2}oWJqazM7e#uq;_Z#taPY;^p57TXZ3V_f zpU-22spvOH7eXOldq%&bbW*LKn~$`!3? zo(9POV)F~JID>$MH-+L=D&3!M?R6Ci^yUOigc^O*2up~*;=%b}u~3CSLv0`0nX13=G4)75U{ppe`L3QZ7x)(Jq2#MN?gj~x zn7m$(;nB_+C2zn->$n5C>ytO?kuhU+>rJ=h&3bgqR4isC8YFMk^Te#gVJ*o{JvQb| zG~mRNPw1s$?xO4>%TDQ)g74ZTpV4c^ydPngozoLEwFWibt$_D1pv74)@5QnLRE^4b z9CRUQ55wi1jNbFX^^58X*PQWVgF@@K3 zT5?0I0^cW;q_LhoW2&s*_Qf{PQX{noEE|Ar@E68N*&sb3=1(L~>5R}5V|bz% z{ST7Y^>%or3AsSnEfhp1kJDuf%SIiK^;?a zliR7Bt3X(3kUYt8u9)RG6IJFys<^ZmKh)+-s=C5s_@-GZlj<%Ui`Bt0HU#KwQ4!yh z<~;HEr=A4JMZJHjG zK-w8MV4rb&;M^PtkM;~f4IiC>YcDG$7ykDHd8$9Bpa(cCxcQLjs{HR=f6!MweTN~+mw#=at zKr?WUxdnJ!xi8}Z=H}bTqT#pPP&3Xu61bg%qSV-z2T48G!mgK}`jflrZbjiWjOkf# zeB?oJXZy*M=y@9Xy_cYWM_PJ(B=3b})kJFECrBQ^NR0OW4tft%FA%Qq$tjOZ@nNsz z=l{|@#~Nh=6dH}&Zx=DbDitp1`2)o@pcO8pc}(bE;jvjbHa2+vC|tOd=52_ANDg`p zJE?Gv;K`_PPR&yXKTge!Q8-tm=LMQ^>lDr%?FmD@a1%RBE_3-yUh)%PO5WGw4@j$- z8Sz3}-aL~VWAN4pa*ZfIA*TYHk@6S6RPYDDk=kZlBIktbo3;suh5RHje`s2jq_!3pQ6@pfP6nf< z5@;}0EyxZ`02AoWbpKGK1e2*bjM}hafa@6H`-&P*ZGf5#!}m4QM}+SPKhrqKRxA60$^JOY^dIh-D`XxT+%x7qrY(`0-;)ic z!EfZN_>G$8=dC__CCCpTTEBwm#pRo}3>TBVs*m;N2VY8F&j^d`74JFK7gysrntRpJ zJfAqcZn!qV^(nGm&2<0gj16_3Ta2J+MaUD2Ak;mfonLxUcoVrrgvgCO!lSBt+$T-Fv-;)L2=XQ$t>8x&0$TR1=jY|`_kIOdknv7`3KXA zOxqrse-xFC)(U*V9$ymdO~EBia^2@b9|L^6-1kr7h&5IZ*-KP4Z$`XmdW%*f5B0`! zsPlzXucp?aF1%T|7CsY2Vc`>9t5`hD-bDWO%o>Nh^zv_^(!u@8D>DC18RnALXmU{N zA5b|XLU3Ezo8l-f`~V$R=@l#d3@mTBeuovW^Iq9$6`KBt>NvSgXKI;CJdj=0t- zg_0!1%B_o2ipnjIQ%cA!h*QeSJ(5$($vu)&D)?sO^d1YNQ|iin zkW=c*eUMWUj1DNW@D$SH|(1LTzEyaBSF z9_O;u@^a7-G(9tgiXlQ2g~}m9E(%qGg4-IGkLs$Rs_7XhR1XolQK%mx)S%EcL?}ez z-4LM|h4mpq844SNg1zjDRFl%wcX0z`{P-LnGu3DX(kzOa-tB9bmfAb0YI<#!^$QVr z*VfejLBZW=4ZHQm&*7)ePE*M=Jqv4V231WTN})lB(C#kA%?lBtSrH#1%%IRHO^~a! zrV#rt@$yJ*OZukXm1V8d%JhH;ax4=xJw=4z-DWj?2!*yGLq>@ZGGu}XAw#B9Xdg0U zjtC(`7K;!vWCew#AwyP+5He(g2q8nZQaBMDV(-hnq6Wvg$u#|_sKLS3Ew=Tx_)ayx zOu}bBf~KEk*@NId$ z@wWUH<*Xr1 zW`u#VH88wd%{UZE9S=E>@H7L@P4gz0_49cu|BEf&4i8sr&Xuf@Ey*H#Z zFH2%z56$Y2$2Ie?>Mq{2*t+`m7lASCnl4IV+{+%H{{ea{16B--)JBAbg)Kz9KD@Mt zf0W`}hL_bmr7?^zEQVJI_f&Uy#Yj&hhgXXBw0C&rJf7YTkBjvTcX*Xjo+%EmTFJA( z;niw--gbD+1kVBAWu6HGJ>NOJ!BEd{ z;M-W!aHPkJbsB@eBMfgc!IK4?Z<-BnI?0m{Jf3>9$(~~12Uy>HhUZU=Jw@JrzNaDd z&&WG2^|S%MMc!$(r#raJq4P%10C2u=9NuMzXAC%BtPStF-!mCp=GN_)XD0YVj!im& z`yYbj{0vJ`-1Oeb*o*%m)0e6vaHhJ-pm=yu(W`;#%hWZFs1L60lC=a2+3#63|GQ9z z{igG^vRhsmbHVNmndDU}_qBf$D;`)opRW+zas>EyQ2yI`+d^Jy${7C#l&e`X3+*E) z=OD;+ESZJ!>NHA=JB;#E95Ug5JbzKF+ORJ|j=IUNi!A+8B>xxW4P5f>hP<{DcE+0d zMFh11N3j1Zmc?3SFTeD6ORfJA3-Vi+51!0CxDB9B2LDK}dC1_>u&meE_JS%xP<-m~ zZ)WYo|JhE@D1VnGYySD%7EP`7l^Myzxec*FTrktIV7gTxo7VFDnW^h;c^IZW7X3LW zw|Qmzxj*Bocy9yy!ylPvn(GQqBb~tG#sa2s(BA)ZkbfS%E$?2)ktW+%zd)~h+7ZgFq3Ktt_LZZR?`yaT z`0@+Y$*-#SskVK!!?#oq$;MCX;Qy6sytR*C-aGF6S+R&ot|ADkB*0e=kh3&S1^Pc6 z^;NK!rt5UT# zpWaTFynpqIr#GWFU1lg7S$w9Nzb&mg*5i>!x#sUoMYojTp0c)>KS0kT@AX;duaHiu z^bE_B*~?&SDZ}Yy4DsZEv%Fl~nT^tpQ9LZip?o@rObM0sxs=wW^_F+g^f#%VO;fp8 zO@Eu}wlvkMT~GCDnrhWC@E7~Hsn+-M;M`2w zK7VH7lt9XY&%}%waEG>$vHHR3g9dZ_@QWh|FG_Rp#S6c6*XRAha z>`ru0ZvgZJ^C+0Q)oLgBj$<+yo+79Z^%(`;cA4TMOPC9dh78eaK4}F&m zv);z$m5t{An{qvCq0*jml;$r;J;GXS$Q+AN9&E{SX(S8qm!UjOm$UAFoTM-TDVXHq z)o5HLl*O}Dy)qBCHP43dTGD^(e<##|`qs1!X#G`(Q`6$Q!Rt%^VTeC6C-=`-pief? zU>5AuCu4xM@BAaF%(iB|7j^$TYySPp{}1=eqmccQZ9E1}Ey-o)oz5O!xBYjhf0#A4 zO6?65t7En3Kym38nJXWdAv&Uy!836+IXVhL|kSR53rW#(N+b)S7a#%)2i zhsyHMS>!!Psgz5$vzv#9=KqLNxsVN=cGOr;R>nvaG_?xEv(_l?ECycY;FW2MkV7g; zYjy+reR?~1eCpqk9+I;RLG%AgVf?FG!~YlM)**9|V@s~>bRE-}DtCvoj$2Xv={UL0 zuT0LqNIZkjD^5uY@#H|XXP*TFb8+zT|8sG1`Qa6(f5!6DX5ueLx#$1Y*S>nKj)M9u z`Xpp*S_5ySskCPBrNlJIwq`&u@riT zR7|6=Dk!*fU_qKbkE(Sdx5h1{V4Z|5VGRZAjA{v+DU1v@()8UFtP`kJ@gaptAr&Vn zOb-z*QkWegT!%2NB8OWqHo|0f_gJ9%Go_3VYkPe%P@Vs(>ZfWwOQ&`4=cby;x?oRh;V(dW zjw|?_uK7z)nV43H3k)h#U!Ib6y{lKFW$mkAQ`@RbYwZ6u%HM=mwzNf9tK)A)InkO+ z+RXKiloxU9$Vte0KwBFtnbxheC390~{=QUW+1^@%DL;L+cr?}8uNKd6O@y8f zKac2|l~-vqU3-wO25b0B?{F>tDQ_7# z!=;Um)XIXn?gUF`;X_JNT5_OEE>>o^N}(z*K7`~7%jYb50;*=YI{Y>jA4Er=)~ImT z#82-Q3RaW>vu=Di!!;B36a3Vqt6tFN+%a%JC&0OO3p$)DoPXd%a%!W4j!cc8<1U%( z+KIJ@=jXT`&d+f>d?~&MZ*z1i^E#feIsFsCPMm%`t2(${-SG*vcy@I-yE>d*ZLYoH zI#v(66aNO{zbkcH5rwyW@$U%8pr@GjRoll0J+!$#Uuro-ZnM;0AQ?dhU3#Ue!*A|X zd|^Z5_D{V4@­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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __linux__ +#include +#include +#ifndef __USE_GNU +#define __USE_GNU +#endif +#include +#endif // __linux__ + +namespace util { + +void set_thread_name(const char* name) { +#ifdef __linux__ + // pthread_setname_np is dumb (fails instead of truncates) + prctl(PR_SET_NAME, (unsigned long)name, 0, 0, 0); +#endif +} + +int set_realtime_priority(int level) { +#ifdef __linux__ + long tid = syscall(SYS_gettid); + + // should match python using chrt + struct sched_param sa; + memset(&sa, 0, sizeof(sa)); + sa.sched_priority = level; + return sched_setscheduler(tid, SCHED_FIFO, &sa); +#else + return -1; +#endif +} + +int set_core_affinity(std::vector cores) { +#ifdef __linux__ + long tid = syscall(SYS_gettid); + cpu_set_t cpu; + + CPU_ZERO(&cpu); + for (const int n : cores) { + CPU_SET(n, &cpu); + } + return sched_setaffinity(tid, sizeof(cpu), &cpu); +#else + return -1; +#endif +} + +int set_file_descriptor_limit(uint64_t limit_val) { + struct rlimit limit; + int status; + + if ((status = getrlimit(RLIMIT_NOFILE, &limit)) < 0) + return status; + + limit.rlim_cur = limit_val; + if ((status = setrlimit(RLIMIT_NOFILE, &limit)) < 0) + return status; + + return 0; +} + +std::string read_file(const std::string& fn) { + std::ifstream f(fn, std::ios::binary | std::ios::in); + if (f.is_open()) { + f.seekg(0, std::ios::end); + int size = f.tellg(); + if (f.good() && size > 0) { + std::string result(size, '\0'); + f.seekg(0, std::ios::beg); + f.read(result.data(), size); + // return either good() or has reached end-of-file (e.g. /sys/power/wakeup_count) + if (f.good() || f.eof()) { + result.resize(f.gcount()); + return result; + } + } + // fallback for files created on read, e.g. procfs + std::stringstream buffer; + buffer << f.rdbuf(); + return buffer.str(); + } + return std::string(); +} + +std::map read_files_in_dir(const std::string &path) { + std::map ret; + DIR *d = opendir(path.c_str()); + if (!d) return ret; + + struct dirent *de = NULL; + while ((de = readdir(d))) { + if (de->d_type != DT_DIR) { + ret[de->d_name] = util::read_file(path + "/" + de->d_name); + } + } + + closedir(d); + return ret; +} + +int write_file(const char* path, const void* data, size_t size, int flags, mode_t mode) { + int fd = HANDLE_EINTR(open(path, flags, mode)); + if (fd == -1) { + return -1; + } + ssize_t n = HANDLE_EINTR(write(fd, data, size)); + close(fd); + return (n >= 0 && (size_t)n == size) ? 0 : -1; +} + +FILE* safe_fopen(const char* filename, const char* mode) { + FILE* fp = NULL; + do { + fp = fopen(filename, mode); + } while ((nullptr == fp) && (errno == EINTR)); + return fp; +} + +size_t safe_fwrite(const void* ptr, size_t size, size_t count, FILE* stream) { + size_t written = 0; + do { + size_t ret = ::fwrite((void*)((char *)ptr + written * size), size, count - written, stream); + if (ret == 0 && errno != EINTR) break; + written += ret; + } while (written != count); + return written; +} + +int safe_fflush(FILE *stream) { + int ret = EOF; + do { + ret = fflush(stream); + } while ((EOF == ret) && (errno == EINTR)); + return ret; +} + +int safe_ioctl(int fd, unsigned long request, void *argp) { + int ret; + do { + ret = ioctl(fd, request, argp); + } while ((ret == -1) && (errno == EINTR)); + return ret; +} + +std::string readlink(const std::string &path) { + char buff[4096]; + ssize_t len = ::readlink(path.c_str(), buff, sizeof(buff)-1); + if (len != -1) { + buff[len] = '\0'; + return std::string(buff); + } + return ""; +} + +bool file_exists(const std::string& fn) { + struct stat st = {}; + return stat(fn.c_str(), &st) != -1; +} + +static bool createDirectory(std::string dir, mode_t mode) { + auto verify_dir = [](const std::string& dir) -> bool { + struct stat st = {}; + return (stat(dir.c_str(), &st) == 0 && (st.st_mode & S_IFMT) == S_IFDIR); + }; + // remove trailing /'s + while (dir.size() > 1 && dir.back() == '/') { + dir.pop_back(); + } + // try to mkdir this directory + if (mkdir(dir.c_str(), mode) == 0) return true; + if (errno == EEXIST) return verify_dir(dir); + if (errno != ENOENT) return false; + + // mkdir failed because the parent dir doesn't exist, so try to create it + size_t slash = dir.rfind('/'); + if ((slash == std::string::npos || slash < 1) || + !createDirectory(dir.substr(0, slash), mode)) { + return false; + } + + // try again + if (mkdir(dir.c_str(), mode) == 0) return true; + return errno == EEXIST && verify_dir(dir); +} + +bool create_directories(const std::string& dir, mode_t mode) { + if (dir.empty()) return false; + return createDirectory(dir, mode); +} + +std::string getenv(const char* key, std::string default_val) { + const char* val = ::getenv(key); + return val ? val : default_val; +} + +int getenv(const char* key, int default_val) { + const char* val = ::getenv(key); + return val ? atoi(val) : default_val; +} + +float getenv(const char* key, float default_val) { + const char* val = ::getenv(key); + return val ? atof(val) : default_val; +} + +std::string hexdump(const uint8_t* in, const size_t size) { + std::stringstream ss; + ss << std::hex << std::setfill('0'); + for (size_t i = 0; i < size; i++) { + ss << std::setw(2) << static_cast(in[i]); + } + return ss.str(); +} + +int random_int(int min, int max) { + std::random_device dev; + std::mt19937 rng(dev()); + std::uniform_int_distribution dist(min, max); + return dist(rng); +} + +std::string random_string(std::string::size_type length) { + const std::string chrs = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + std::mt19937 rg{std::random_device{}()}; + std::uniform_int_distribution pick(0, chrs.length() - 1); + std::string s; + s.reserve(length); + while (length--) { + s += chrs[pick(rg)]; + } + return s; +} + +std::string dir_name(std::string const &path) { + size_t pos = path.find_last_of("/"); + if (pos == std::string::npos) return ""; + return path.substr(0, pos); +} + +bool starts_with(const std::string &s1, const std::string &s2) { + return strncmp(s1.c_str(), s2.c_str(), s2.size()) == 0; +} + +bool ends_with(const std::string &s1, const std::string &s2) { + return strcmp(s1.c_str() + (s1.size() - s2.size()), s2.c_str()) == 0; +} + +std::string check_output(const std::string& command) { + char buffer[128]; + std::string result; + std::unique_ptr pipe(popen(command.c_str(), "r"), pclose); + + if (!pipe) { + return ""; + } + + while (fgets(buffer, std::size(buffer), pipe.get()) != nullptr) { + result += std::string(buffer); + } + + return result; +} + +struct tm get_time() { + time_t rawtime; + time(&rawtime); + + struct tm sys_time; + gmtime_r(&rawtime, &sys_time); + + return sys_time; +} + +bool time_valid(struct tm sys_time) { + int year = 1900 + sys_time.tm_year; + int month = 1 + sys_time.tm_mon; + return (year > 2023) || (year == 2023 && month >= 6); +} + +} // namespace util diff --git a/common/util.h b/common/util.h new file mode 100644 index 0000000..5178787 --- /dev/null +++ b/common/util.h @@ -0,0 +1,184 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// keep trying if x gets interrupted by a signal +#define HANDLE_EINTR(x) \ + ({ \ + decltype(x) ret_; \ + int try_cnt = 0; \ + do { \ + ret_ = (x); \ + } while (ret_ == -1 && errno == EINTR && try_cnt++ < 100); \ + ret_; \ + }) + +#ifndef sighandler_t +typedef void (*sighandler_t)(int sig); +#endif + +const double MILE_TO_KM = 1.609344; +const double KM_TO_MILE = 1. / MILE_TO_KM; +const double MS_TO_KPH = 3.6; +const double MS_TO_MPH = MS_TO_KPH * KM_TO_MILE; +const double METER_TO_MILE = KM_TO_MILE / 1000.0; +const double METER_TO_FOOT = 3.28084; +const double FOOT_TO_METER = 1 / METER_TO_FOOT; +const double CM_TO_INCH = 1 / 2.54; +const double INCH_TO_CM = 1 / CM_TO_INCH; + +namespace util { + +void set_thread_name(const char* name); +int set_realtime_priority(int level); +int set_core_affinity(std::vector cores); +int set_file_descriptor_limit(uint64_t limit); + +// ***** Time helpers ***** +struct tm get_time(); +bool time_valid(struct tm sys_time); + +// ***** math helpers ***** + +// map x from [a1, a2] to [b1, b2] +template +T map_val(T x, T a1, T a2, T b1, T b2) { + x = std::clamp(x, a1, a2); + T ra = a2 - a1; + T rb = b2 - b1; + return (x - a1) * rb / ra + b1; +} + +// ***** string helpers ***** + +template +std::string string_format(const std::string& format, Args... args) { + size_t size = snprintf(nullptr, 0, format.c_str(), args...) + 1; + std::unique_ptr buf(new char[size]); + snprintf(buf.get(), size, format.c_str(), args...); + return std::string(buf.get(), buf.get() + size - 1); +} + +std::string getenv(const char* key, std::string default_val = ""); +int getenv(const char* key, int default_val); +float getenv(const char* key, float default_val); + +std::string hexdump(const uint8_t* in, const size_t size); +std::string dir_name(std::string const& path); +bool starts_with(const std::string &s1, const std::string &s2); +bool ends_with(const std::string &s1, const std::string &s2); + +// ***** random helpers ***** +int random_int(int min, int max); +std::string random_string(std::string::size_type length); + +// **** file helpers ***** +std::string read_file(const std::string& fn); +std::map read_files_in_dir(const std::string& path); +int write_file(const char* path, const void* data, size_t size, int flags = O_WRONLY, mode_t mode = 0664); + +FILE* safe_fopen(const char* filename, const char* mode); +size_t safe_fwrite(const void * ptr, size_t size, size_t count, FILE * stream); +int safe_fflush(FILE *stream); +int safe_ioctl(int fd, unsigned long request, void *argp); + +std::string readlink(const std::string& path); +bool file_exists(const std::string& fn); +bool create_directories(const std::string &dir, mode_t mode); + +std::string check_output(const std::string& command); + +inline void sleep_for(const int milliseconds) { + if (milliseconds > 0) { + std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); + } +} + +} // namespace util + +class ExitHandler { +public: + ExitHandler() { + std::signal(SIGINT, (sighandler_t)set_do_exit); + std::signal(SIGTERM, (sighandler_t)set_do_exit); + +#ifndef __APPLE__ + std::signal(SIGPWR, (sighandler_t)set_do_exit); +#endif + } + inline static std::atomic power_failure = false; + inline static std::atomic signal = 0; + inline operator bool() { return do_exit; } + inline ExitHandler& operator=(bool v) { + signal = 0; + do_exit = v; + return *this; + } +private: + static void set_do_exit(int sig) { +#ifndef __APPLE__ + power_failure = (sig == SIGPWR); +#endif + signal = sig; + do_exit = true; + } + inline static std::atomic do_exit = false; +}; + +struct unique_fd { + unique_fd(int fd = -1) : fd_(fd) {} + unique_fd& operator=(unique_fd&& uf) { + fd_ = uf.fd_; + uf.fd_ = -1; + return *this; + } + ~unique_fd() { + if (fd_ != -1) close(fd_); + } + operator int() const { return fd_; } + int fd_; +}; + +class FirstOrderFilter { +public: + FirstOrderFilter(float x0, float ts, float dt, bool initialized = true) { + k_ = (dt / ts) / (1.0 + dt / ts); + x_ = x0; + initialized_ = initialized; + } + inline float update(float x) { + if (initialized_) { + x_ = (1. - k_) * x_ + k_ * x; + } else { + initialized_ = true; + x_ = x; + } + return x_; + } + inline void reset(float x) { x_ = x; } + inline float x(){ return x_; } + +private: + float x_, k_; + bool initialized_; +}; + +template +void update_max_atomic(std::atomic& max, T const& value) { + T prev = max; + while (prev < value && !max.compare_exchange_weak(prev, value)) {} +} diff --git a/common/utils.py b/common/utils.py new file mode 100644 index 0000000..b9de020 --- /dev/null +++ b/common/utils.py @@ -0,0 +1,11 @@ +class Freezable: + _frozen: bool = False + + def freeze(self): + if not self._frozen: + self._frozen = True + + def __setattr__(self, *args, **kwargs): + if self._frozen: + raise Exception("cannot modify frozen object") + super().__setattr__(*args, **kwargs) diff --git a/common/version.h b/common/version.h index 787bc89..177882e 100644 --- a/common/version.h +++ b/common/version.h @@ -1 +1 @@ -#define COMMA_VERSION "0.9.6" +#define COMMA_VERSION "0.9.7" diff --git a/common/watchdog.cc b/common/watchdog.cc new file mode 100644 index 0000000..3483ad2 --- /dev/null +++ b/common/watchdog.cc @@ -0,0 +1,11 @@ +#include + +#include "common/watchdog.h" +#include "common/util.h" + +const std::string watchdog_fn_prefix = "/dev/shm/wd_"; // + + +bool watchdog_kick(uint64_t ts) { + static std::string fn = watchdog_fn_prefix + std::to_string(getpid()); + return util::write_file(fn.c_str(), &ts, sizeof(ts), O_WRONLY | O_CREAT) > 0; +} diff --git a/common/watchdog.h b/common/watchdog.h new file mode 100644 index 0000000..12dd2ca --- /dev/null +++ b/common/watchdog.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +bool watchdog_kick(uint64_t ts);