Как вызвать скрипты на python в 1С по технологии NativeAPI

// тут какой-то код который был написан до нас

// это тоже код, который писали не мы, просто показываю после чего я воткнул свою вставочку
add_library(${TARGET} SHARED
        ${SOURCES})

// Это наш код для поиска библиотек питона
find_package(Python3 3.12 REQUIRED COMPONENTS Development)
if (Python3_FOUND)
    message("Python include directory: " ${Python3_INCLUDE_DIRS})
    include_directories(${Python3_INCLUDE_DIRS})
    target_link_libraries(${TARGET} ${Python3_LIBRARIES})
endif (Python3_FOUND)

// тут дальше есть какой-то код, который сейчас нам не очень то интересен

long GetClassObject(const WCHAR_T *clsName, IComponentBase **pInterface) {
    if (!*pInterface) {
        auto cls_name = std::u16string(reinterpret_cast<const char16_t *>(clsName));
        if (cls_name == u"Component4Python") {
            *pInterface = new Component4Python;

            // Вот тут инициализируем
            Py_Initialize();

        }
        return (long) *pInterface;
    }
    return 0;
}

long DestroyObject(IComponentBase **pInterface) {
    if (!*pInterface) {
        return -1;
    }

    // Вот тут сделаем то сложное слово из последнего пункта
    Py_FinalizeEx();

    delete *pInterface;
    *pInterface = nullptr;
    return 0;
}

#ifndef QRCode41ADDIN_H
#define QRCode41ADDIN_H

#include "Component.h"
// Подключим заголовочный файл питона
#include "Python.h"

class Component4Python final : public Component {
public:
    const char *Version = u8"1.0.0";
    Component4Python();
private:
    std::string extensionName() override;
    variant_t isInitialized;
    void initializePython();
    void uninitializePython();
    void initMethods();
    void initProperty();
};

#endif //QRCode41ADDIN_H

std::string Component4Python::extensionName() {
    return "Component4Python";
}

Component4Python::Component4Python() {
    initProperty();
    initMethods();
}

void Component4Python::initProperty() {
    AddProperty(L"Version", L"ВерсияКомпоненты", [&]() {
        auto s = std::string(Version);
        return std::make_shared<variant_t>(std::move(s));
    });
    AddProperty(L"isInitialized", L"ПитонВключен", [&]() {
        return std::make_shared<variant_t>(isInitialized);
    });
}

void Component4Python::initMethods() {
    AddMethod(L"initializePython", L"ВключитьПитон", this, &Component4Python::initializePython);
    AddMethod(L"uninitializePython", L"ВыключитьПитон", this, &Component4Python::uninitializePython);
}

void Component4Python::uninitializePython() {
    Py_Finalize();
    if (Py_IsInitialized()) {
        throw std::runtime_error(u8"Ошибка выключения Python.");
    }

    isInitialized = false;
}

void Component4Python::initializePython() {
    Py_Initialize();

    if (!Py_IsInitialized()) {
        throw std::runtime_error(u8"Ошибка инициализации Python.");
    }
    isInitialized = true;
}

variant_t pathToVenv;

void Component4Python::initProperty() {
    AddProperty(L"Version", L"ВерсияКомпоненты", [&]() {
        auto s = std::string(Version);
        return std::make_shared<variant_t>(std::move(s));
    });
    AddProperty(L"isInitialized", L"ПитонВключен", [&]() {
        return std::make_shared<variant_t>(isInitialized);
    });
    AddProperty(L"pathToVenv", L"ПутьКВиртуальномуОкружению", [&]() {
        return std::make_shared<variant_t>(pathToVenv);
    }, [&](const variant_t &value) {
        pathToVenv = value;
    });
}

void Component4Python::initializePython() {
    // Преобразуем тип variant_t в string
    auto ccPath = std::get<std::string>(pathToVenv).c_str();
    // если переменная пустая, просто инициализируем питон
    if (!ccPath) {
        Py_Initialize();
    } else {
        // создаем конфигурацию
        PyConfig config;
        // говорим, что запускаем конфигурацию изолированно
        PyConfig_InitIsolatedConfig(&config);

        // приколы языка С. Строк в С нету, зато есть 100500 вариантов хранения строк
        // в данный момент мы вытащили string из variant_t, но конфигурация готова принять 
        // строку только в варианте wchar_t. Тут мы все это преобразовываем
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        auto wsPath = converter.from_bytes(ccPath);
        auto venv_path = new wchar_t[wsPath.size() + 1];
        std::copy(wsPath.begin(), wsPath.end(), venv_path);
        venv_path[wsPath.size()] = L'\0';
        // Устанавливаем переданный путь в конфигурацию
        PyConfig_SetString(&config, &config.executable, venv_path);

        // инициализируем с конфигурацией
        auto status = Py_InitializeFromConfig(&config);
        PyConfig_Clear(&config);

        // обработаем ошибку
        if (PyStatus_Exception(status)) {
            auto ss = std::stringstream();
            auto msg = u8"Ошибка инициализации Python.";
            ss << msg << u8" status.func: " << (status.func ? status.func : "N/A") << u8" status.err_msg: "
               << (status.err_msg ? status.err_msg : "N/A");
            throw std::runtime_error(ss.str());
        }
    }

    // проверим состояние
    if (!Py_IsInitialized()) {
        throw std::runtime_error(u8"Ошибка инициализации Python.");
    }
    isInitialized = true;
}

import qrcode
import io
img = qrcode.make('Some data here')
bytes_io = io.BytesIO()
img.save(bytes_io)
return bytes_io.getvalue()

	Если Не ПодключитьВнешнююКомпоненту(Путь, "Vissarion", ТипВнешнейКомпоненты.Native) Тогда
		Сообщение = "Не удалось подключить";
	КонецЕсли;
	Компонента = Новый("AddIn.Vissarion.Component4Python"); 
	Если Компонента = Неопределено Тогда
		Сообщение = "Не удалось создать";
	КонецЕсли;    

	Компонента.ПутьКВиртуальномуОкружению = "E:\PythonVenvs\Component4Python\Scripts\python.exe"; 
	Компонента.ВключитьПитон();

	Данные = Компонента.СоздатьПростойQR("Привет, мир!");
	Картинка = Новый Картинка(Данные);   

	Компонента.ВыключитьПитон();

	Компонента = "";

#ifndef QRCode41ADDIN_H
#define QRCode41ADDIN_H

#include "Component.h"
#include "Python.h"

class Component4Python final : public Component {
public:
    const char *Version = u8"1.0.0";
    Component4Python();
private:
    std::string extensionName() override;
    variant_t isInitialized;
    variant_t pathToVenv;
    void initializePython();
    void uninitializePython();
    void initMethods();
    void initProperty();

    // Наш метод СоздатьПростойQR
    variant_t makeSimpleQR(const variant_t &data);
    // метод для работы с исключениями
    static void exceptionHandler(std::shared_ptr<std::string> msg);
    // метод для преобразования байтов питона в двоичные данные 1С
    static std::shared_ptr<std::vector<char>> imgToBytes(PyObject *img);

};

#endif //QRCode41ADDIN_H

void Component4Python::initMethods() {
    AddMethod(L"initializePython", L"ВключитьПитон", this, &Component4Python::initializePython);
    AddMethod(L"uninitializePython", L"ВыключитьПитон", this, &Component4Python::uninitializePython);
    AddMethod(L"MakeSimpleQR", L"СоздатьПростойQR", this, &Component4Python::makeSimpleQR);
}

void Component4Python::exceptionHandler(std::shared_ptr<std::string> msg) {
    // получаем инфу об исключении внутри питона
    auto error = PyErr_GetRaisedException();
    if (!error) {
        // если данных нет, просто кидаем исключение
        throw std::runtime_error(msg->c_str());
    } else {
        // если данные есть, парсим их и выводим нормальную ошибку
        auto error_str = PyObject_Str(error);
        auto error_cstr = PyUnicode_AsUTF8(error_str);
        auto ss = std::stringstream();
        ss << msg->c_str() << u8" по причине: " << error_cstr;

        Py_DECREF(error_str);
        Py_DECREF(error);
        throw std::runtime_error(ss.str());
    }
}

std::shared_ptr<std::vector<char>> Component4Python::imgToBytes(PyObject *img) {
    // импортируем модуль io
    auto io = PyImport_ImportModule("io");
    // если модуль не импортировался, то выводим сообщение об ошибке
    if (!io) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при импорте модуля io");
        exceptionHandler(msg);
    }
    // создаем объект BytesIO
    auto bytesio_name = PyUnicode_FromString("BytesIO");
    auto bytesio = PyObject_CallMethodNoArgs(io, bytesio_name);
    // если объект не создался, то выводим сообщение об ошибке
    if (!bytesio) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при создании объекта BytesIO");
        exceptionHandler(msg);
    }
    // преобразуем имя метода save из строки в объект Python
    auto save_method = PyUnicode_FromString("save");
    // вызываем метод save объекта img передавая объект bytesio
    PyObject_CallMethodOneArg(img, save_method, bytesio);
    // преобразуем имя метода getvalue из строки в объект Python
    auto getvalue_method = PyUnicode_FromString("getvalue");
    // вызываем метод getvalue объекта bytesio
    auto image_bytes = PyObject_CallMethodNoArgs(bytesio, getvalue_method);
    // если метод не вернул объект, то выводим сообщение об ошибке
    if (!image_bytes) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при получении байтового представления изображения");
        exceptionHandler(msg);
    }

    // конвертируем объект bytes в std::vector<unsigned char>
    char* buffer;
    Py_ssize_t length;
    PyBytes_AsStringAndSize(image_bytes, &buffer, &length);
    auto result = std::make_shared<std::vector<char>>(buffer, buffer + length);

    // удаляем объекты Python
    Py_DECREF(image_bytes);
    Py_DECREF(bytesio);
    Py_DECREF(io);

    return result;
}

variant_t Component4Python::makeSimpleQR(const variant_t &data) {
    // импортируем модуль qrcode
    auto qrcode = PyImport_ImportModule("qrcode");
    if (!qrcode) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при импорте модуля qrcode");
        exceptionHandler(msg);
    }
    // преобразуем имя метода make из строки в объект Python
    auto make_method = PyUnicode_FromString("make");
    // вызываем метод make передавая строку с данными
    auto img = PyObject_CallMethodOneArg(qrcode, make_method, PyUnicode_FromString(std::get<std::string>(data).c_str()));
    if (!img) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при создании изображения QR кода");
        exceptionHandler(msg);
    }

    // конвертируем объект img в std::vector<unsigned char>
    auto result =  imgToBytes(img);

    // удаляем объекты Python
    Py_DECREF(img);
    Py_DECREF(qrcode);

    return *result;
}

from jsonschema import validate
import json


class Validator:
    def __init__(self, data, schema):
        self.schema = json.loads(schema)
        self.data = json.loads(data)

    def validate(self):
        validate(self.data, self.schema)

from setuptools import setup, find_packages

setup(
    name='validator',
    version='0.1',
    packages=find_packages(),
    install_requires=[
        'jsonschema',
    ],
)

#ifndef QRCode41ADDIN_H
#define QRCode41ADDIN_H

#include "Component.h"
#include "Python.h"

class Component4Python final : public Component {
public:
    const char *Version = u8"1.0.0";
    Component4Python();
private:
    std::string extensionName() override;
    variant_t isInitialized;
    variant_t pathToVenv;
    void initializePython();
    void uninitializePython();
    void initMethods();
    void initProperty();

    variant_t makeSimpleQR(const variant_t &data);
    static void exceptionHandler(std::shared_ptr<std::string> msg);
    static std::shared_ptr<std::vector<char>> imgToBytes(PyObject *img);

    variant_t validator(const variant_t &data, const variant_t &schema);
};

#endif //QRCode41ADDIN_H

variant_t Component4Python::validator(const variant_t &data, const variant_t &schema) {
    // проверяем параметры на заполненность
    if (std::get<std::string>(data).empty() || std::get<std::string>(schema).empty()) {
        auto msg = std::make_shared<std::string>(u8"Параметры data и schema должны быть заполнены");
        exceptionHandler(msg);
    }

    // импортируем модуль validator
    auto validator = PyImport_ImportModule("schema.validator");
    if (!validator) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при импорте модуля validator");
        exceptionHandler(msg);
    }

    // создаем класс Validator
    auto validator_attr = PyObject_GetAttrString(validator, "Validator");
    auto py_data = PyUnicode_FromString(std::get<std::string>(data).c_str());
    auto py_schema = PyUnicode_FromString(std::get<std::string>(schema).c_str());
    // тот самый массив, в который мы передаем первым параметром данные, а вторым схему
    auto args = PyTuple_Pack(2, py_data, py_schema);
    auto validator_class = PyObject_CallObject(validator_attr, args);
    if (!validator_class) {
        auto msg = std::make_shared<std::string>(u8"Ошибка при создании объекта класса Validator");
        exceptionHandler(msg);
    }

    // вызываем метод validate класса Validator
    auto validate_method = PyUnicode_FromString("validate");
    PyObject_CallMethodNoArgs(validator_class, validate_method);

    auto error = PyErr_GetRaisedException();

    if (!error) {
        // удаляем объекты Python
        Py_DECREF(validator_class);
        Py_DECREF(validator_attr);
        Py_DECREF(validator);
        Py_DECREF(args);
        // если ошибки нет, тогда возвращаем ок
        auto res = std::make_shared<std::string>("OK");
        return *res;
    } else {
        // если ошибка есть, перехватываем ее в питоне и возвращаем в 1С
        auto error_str = PyObject_Str(error);
        auto error_cstr = PyUnicode_AsUTF8(error_str);

        Py_DECREF(error_str);
        Py_DECREF(error);
        Py_DECREF(validator_class);
        Py_DECREF(validator_attr);
        Py_DECREF(validator);
        Py_DECREF(args);
        auto res = std::make_shared<std::string>(error_cstr);
        return *res;
    }
}

	Если Не ПодключитьВнешнююКомпоненту(Путь, "Vissarion", ТипВнешнейКомпоненты.Native) Тогда
		Сообщение = "Не удалось подключить";
	КонецЕсли;
	Компонента = Новый("AddIn.Vissarion.Component4Python"); 
	Если Компонента = Неопределено Тогда
		Сообщение = "Не удалось создать";
	КонецЕсли;    
	Компонента.ПутьКВиртуальномуОкружению = "E:\PythonVenvs\Component4Python\Scripts\python.exe"; 
	Компонента.ВключитьПитон();   
	
	Схема = "{""type"": ""object"", ""properties"": {""name"": {""type"": ""string""}, ""age"": {""type"": ""number""}}}";
	Данные = "{""name"": ""John"", ""age"": ""30""}"; 
	Ответ = Компонента.Валидатор(Данные, Схема);  
	Если Не Ответ = "OK" Тогда
		Сообщение = СтрШаблон("Произошла ошибка: %1", Ответ);
		ПоказатьЗначение(,Сообщение);	
	КонецЕсли;
	
	Компонента.ВыключитьПитон();
	Компонента = "";