Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

где в этом коде можно регулировать длительность выполнения метода? я хочу вызывать…

  1. User

    где в этом коде можно регулировать длительность выполнения метода? я хочу вызывать функцию чтобы она работала до определенного момента времени и останавливалась package ru.sber.pprb.mars.spr.lt.gatling.scenario;

    import com.sbt.ott.api.client.interfaces.TokenResult; import io.gatling.javaapi.core.ChainBuilder; import io.gatling.javaapi.core.PopulationBuilder; import io.gatling.javaapi.core.ScenarioBuilder; import io.gatling.javaapi.core.Simulation; import io.gatling.javaapi.http.HttpProtocolBuilder; import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderValues; import lombok.SneakyThrows; import lombok.Synchronized; import lombok.extern.slf4j.Slf4j; import ru.sber.pprb.mars.spr.lt.gatling.utils.Feeders; import ru.sber.pprb.mars.spr.lt.gatling.utils.dto.RepeatResult; import ru.sber.pprb.mars.spr.lt.services.OTTService;

    import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.time.Duration; import java.util.concurrent.atomic.AtomicInteger;

    import static io.gatling.javaapi.core.CoreDsl.*; import static io.gatling.javaapi.http.HttpDsl.http; import static io.gatling.javaapi.http.HttpDsl.status;

    @Slf4j public class OrchestratorStrategy extends Simulation { public static String test = null; public static String strategy = null; public static OTTService ottService = null; public static String repeatFile = null; private static AtomicInteger count; private static final AtomicInteger i = new AtomicInteger();

    public static String URL = "ссылка";
    private static FileWriter fileError;
    
    // настройка протокола http
    HttpProtocolBuilder httpProtocol = http.baseUrl(URL)
            .sign(request -> {
                if (ottService.isEnable()) {
                    TokenResult tokenResult = ottService.getTokenResult();
                    request.getHeaders().add("ott-token", tokenResult.getTokenCompactSerialization());
                    request.getHeaders().add("ott-hash", tokenResult.hash(request.getBody().getBytes()));
                }
            })
            .transformResponse((response, session) -> {
                if (response.status().code() != 200)
                    writeErrorLine(RepeatResult.builder()
                            .uuid(session.get("uuid"))
                            .request(new String(response.request().getBody().getBytes()).replaceAll("\r\n","\t"))
                            .response(response.status().reasonPhrase() + " " + response.body().string().replaceAll("\r\n","\t"))
                            .build().toString());
                return response;
            });
    
    
    ScenarioBuilder applicationMMBLT = scenario("applicationMMBLT")
            .asLongAs(session -> count.decrementAndGet() >= 0)
            .on(exec(MmbStrategy.applicationStrategy()));
    

    // ScenarioBuilder applicationMMBLTRepeat = scenario("applicationMMBLTRepeat") // .asLongAs(session -> count.decrementAndGet() >= 0) // .on(exec(MmbStrategy.applicationStrategyRepeat()));

    {
        count = test.equals("debug") ? new AtomicInteger(10) : countByFeeder();
        log.info("Пулл {}", count.get());
        setUp(switchLoad()).protocols(httpProtocol);
    }
    
    
    @SneakyThrows
    @Override
    public void before() {
        File file = new File("./result/" + System.currentTimeMillis() + "/repeat.csv");
        file.getParentFile().mkdirs();
        fileError = new FileWriter(file);
        fileError.write(String.join(";", new String[]{"uuid", "request", "response"}));
        fileError.write("\n");
        fileError.flush();
    }
    
    
    @SneakyThrows
    @Override
    public void after() {
        fileError.close();
        log.info("Завершили запись файла {}!", fileError);
    }
    
    @Synchronized
    public void writeErrorLine(String line) {
        try {
            fileError.write(line);
            fileError.write("\n");
            i.getAndIncrement();
            if (i.get() % 10 == 0) fileError.flush();
        } catch (IOException e) {
            log.error("{}", line);
        }
    }
    
    private AtomicInteger countByFeeder() {
        return switch (strategy) {
          
            case "applicationMMB" -> new AtomicInteger(Feeders.appMMB.recordsCount());
            case "applicationMMBRepeat" -> new AtomicInteger(Feeders.appMMBRepeat(repeatFile).recordsCount());
            default -> throw new IllegalStateException("Не выбран тип стратегии для запуска");
        };
    }
    
    private PopulationBuilder switchLoad() {
        if (test.equals("debug")) {
            return switch (strategy) {
                
                case "applicationMMB" -> applicationMMBLT.injectOpen(atOnceUsers(5));
                //case "applicationMMBRepeat" -> applicationMMBLTRepeat.injectOpen(atOnceUsers(5));
                default -> throw new IllegalStateException("Не выбран тип стратегии для запуска");
            };
        } else {
            return switch (strategy) {
                
                case "applicationMMB" ->
                        applicationMMBLT.injectClosed(constantConcurrentUsers(1).during(Duration.ofMinutes(510)));
    

    // case "applicationMMBRepeat" -> // applicationMMBLTRepeat.injectClosed(constantConcurrentUsers(35).during(Duration.ofMinutes(60))); default -> throw new IllegalStateException("Не выбран тип стратегии для запуска"); }; } }

    static class MmbStrategy {
        
    
       @SneakyThrows
        public static ChainBuilder applicationStrategy() {
            return feed(Feeders.uuid32)
                    .feed(Feeders.appMMB)
                    .exec(
                            http("applicationStrategy")
                                    .post("/v1/execute")
                                    .header(
                                            HttpHeaderNames.CONTENT_TYPE,
                                            String.valueOf(HttpHeaderValues.APPLICATION_JSON))
                                    .requestTimeout(60000)
                                    .body(ElFileBody("data/requestCommonTemplate.json"))
                                    .check(status().is(200))
                                    .check(bodyLength().exists())
                    );
        }
    

    package ru.sber.pprb.mars.spr.lt.gatling.test;

    import org.springframework.stereotype.Component; import ru.sber.pprb.mars.spr.lt.config.OttConfigProperties; import ru.sber.pprb.mars.spr.lt.gatling.scenario.*; import io.gatling.app.Gatling; import io.gatling.core.config.GatlingPropertiesBuilder; import lombok.extern.slf4j.Slf4j; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; import ru.sber.pprb.mars.spr.lt.services.OTTService;

    import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is;

    @Slf4j @SpringBootTest(classes = {OttConfigProperties.class}) @EnableAutoConfiguration public class PackageLT { @Autowired OttConfigProperties ottConfigProperties;

    final GatlingPropertiesBuilder properties = new GatlingPropertiesBuilder()
            .resourcesDirectory("./src/main/resources")
            .resultsDirectory("./target/gatling");
    

    @Test public void appMMBLTDebug() { log.info("Запуск разового прогона скриптов"); OrchestratorStrategy.test = "debug"; OrchestratorStrategy.strategy="applicationMMB"; OrchestratorStrategy.repeatFile="result\1715699813726\repeat.csv"; OrchestratorStrategy.ottService = new OTTService(ottConfigProperties); log.info("Параметры запуска: ott-{}", ottConfigProperties.isEnabled()); runSimulation(OrchestratorStrategy.class.getName()); } void runSimulation(String simulationClass) { properties.simulationClass(simulationClass); int statusCode = Gatling.fromMap(properties.build()); String error = statusCode == 2 ? "AssertionsFailed" : "InvalidArguments"; assertThat("Результат теста не успешный (" + error + ") ", statusCode, is(0)); } }

  2. Assistant

    В вашем коде управление временем выполнения симуляции осуществляется с помощью вызовов методов injectClosed(constantConcurrentUsers().during(Duration)). Эта конструкция используется для указания продолжительности, в течение которой будет выполняться сценарий.

    Наиболее вероятное место, где вы захотите изменить длительность выполнения симуляции, находится в методе switchLoad. Он содержит блок:

    applicationMMBLT.injectClosed(constantConcurrentUsers(1).during(Duration.ofMinutes(510)));
    

    Здесь Duration.ofMinutes(510) определяет, сколько минут будет выполняться сценарий "applicationMMBLT". Вы можете заменить Duration.ofMinutes(510) на другой временной интервал, указав нужное количество минут или использовать другой метод Duration, такой как Duration.ofSeconds() или Duration.ofHours().

    Для изменения длительности выполнения просто замените 510 на другое значение:

    applicationMMBLT.injectClosed(constantConcurrentUsers(1).during(Duration.ofMinutes(60)));
    

    Таким образом, сценарий будет выполняться в течение 60 минут. Вам следует изменить это значение на соответствующее вашему сценарию.

  3. User

    все равно даже если поставить 1 минуту выполняется прога до тех пор пока не прогонится весь файл, а это долго

  4. Assistant

    Похоже, что проблема связана с логикой, определяющей завершение сценария. В вашем коде сценарий будет выполняться, пока условие count.decrementAndGet() >= 0 в методе asLongAs является истинным. Это условие используется для определения количества итераций, основываясь на значении count, которое инициализируется в зависимости от выбранной стратегии и числа записей в фидере.

    Чтобы обеспечить завершение сценария по истечении конкретного времени, независимо от количества оставшихся записей в фидере, можно попробовать следующий подход:

    1. Использование времени и итераций: Комбинирование условия времени и итераций. Например, можно использовать сочетание exitHereIfFailed или сменить логику с count на проверку времени внутри ChainBuilder.

    2. Вычисление против сочетания с временем запуска:

      • Измените логику окончания врессии так, чтобы сценарий был ограничен по времени, даже если count не достигнет нуля.
    3. Асинхронная отмена:

      • В самой цепочке ChainBuilder можно добавлять проверку времени в каждом шагу и завершать цепочку при достижении лимита времени.

    Пример, как можно изменить логику для ограничения времени на выполнение:

    ScenarioBuilder applicationMMBLT = scenario("applicationMMBLT")
            .during(Duration.ofMinutes(1)).on(
                exec(session -> {
                    // Проверка времени и завершение сценария
                    long startTime = session.getLong("startTime");
                    if (System.currentTimeMillis() - startTime > Duration.ofMinutes(1).toMillis()) {
                        return session.markAsFailed();
                    }
                    return session;
                })
                .exec(MmbStrategy.applicationStrategy())
            );
    

    Этот код устанавливает сценарий для выполнения в течение одной минуты, независимо от состояния ресурса count. Вы можете дополнить его, чтобы отслеживать начало работы теста и сравнивать его со временем выполнения. Эти подходы будут блокировать дальнейшие шаги в сценарии после окончания указанного промежутка времени.

  5. User

    я хочу сделать независимый класс, который будет создавать и запускать функцию appMMBLoadTesting так же как в PackageLT, но делать еще доп функционал. мне надо выполнять функцию столько минут, сколько осталось до конца дня затем после выполнения функции нужно запускать скрипт питон который находится по пути C:\Users\22240938\Desktop\пакеты\PYTHON_Project\generate_requests.py затем выполнять функцию заново. и так в цикле несколько итераций (число итераций задается пользователем). то есть в корректировке которую ты предложил (она рабочая) количество секунд замени переменной сколько осталось до конца дня. и в отдельном классе реализуй функционал что я прописал

  6. Assistant

    Для того чтобы создать независимый класс, который будет выполнять заданный вами функционал, вы можете следовать следующему подходу. Можно использовать комбинацию Java для выполнения основной логики и сценариев нагрузки, а также для запуска Python-скрипта через командную строку.

    Вот пример того, что можно реализовать:

    import ru.sber.pprb.mars.spr.lt.gatling.scenario.OrchestratorStrategy;
    import ru.sber.pprb.mars.spr.lt.services.OTTService;
    import ru.sber.pprb.mars.spr.lt.config.OttConfigProperties;
    
    import java.io.IOException;
    import java.time.Duration;
    import java.time.LocalDateTime;
    import java.time.temporal.ChronoUnit;
    import java.util.Scanner;
    
    public class LoadTestExecutor {
    
        private static final String PYTHON_SCRIPT_PATH = "C:\\Users\\22240938\\Desktop\\пакеты\\PYTHON_Project\\generate_requests.py";
    
        public static void main(String[] args) {
            OrchestratorStrategy.ottService = new OTTService(new OttConfigProperties());
            
            Scanner scanner = new Scanner(System.in);
            System.out.println("Введите количество итераций:");
            int iterations = scanner.nextInt();
            
            for (int i = 0; i < iterations; i++) {
                performLoadTest();
                executePythonScript();
            }
        }
    
        private static void performLoadTest() {
            OrchestratorStrategy.test = "normal";  // Или другой режим, если нужно
            OrchestratorStrategy.strategy = "applicationMMB";
    
            Duration durationUntilEndOfDay = calculateDurationUntilEndOfDay();
            System.out.println("Запуск нагрузки на: " + durationUntilEndOfDay.toMinutes() + " минут.");
            
            // Устанавливаем продолжительность в OrchestratorStrategy на значение durationUntilEndOfDay
            OrchestratorStrategy setStrategy = new OrchestratorStrategy(durationUntilEndOfDay);
            setStrategy.runSimulation();
        }
    
        private static Duration calculateDurationUntilEndOfDay() {
            LocalDateTime now = LocalDateTime.now();
            LocalDateTime endOfDay = now.withHour(23).withMinute(59).withSecond(59);
    
            return Duration.between(now, endOfDay);
        }
    
        private static void executePythonScript() {
            try {
                ProcessBuilder processBuilder = new ProcessBuilder("python", PYTHON_SCRIPT_PATH);
                Process process = processBuilder.start();
                
                int exitCode = process.waitFor();
                if (exitCode == 0) {
                    System.out.println("Python script executed successfully.");
                } else {
                    System.out.println("Python script execution failed with exit code: " + exitCode);
                }
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    Краткое пояснение:

    • Класс LoadTestExecutor выполняет основной цикл работы.

    • Метод performLoadTest определяет время до конца дня и запускает сценарий нагрузки (где вы устанавливаете продолжительность в высокоуровневом компоненте OrchestratorStrategy).

    • Метод calculateDurationUntilEndOfDay вычисляет оставшееся время до конца дня.

    • Метод executePythonScript выполняет Python скрипт, используя ProcessBuilder для запуска системного процесса.

    Замечание:

    • Убедитесь, что все указанные пути и конфигурации корректны и соответствуют вашим рабочим условиям.
    • Перед выполнением кода убедитесь, что среда, где вы выполняете эту программу, позволяет запускать Python и Java программы на уровне операционной системы.
  7. User

    мне надо рассчитывать количество минут до конца дня в другом классе OrchestratorStrategy . вот сюда вместо 1 минуты надо поставить количество мин до конца дня ScenarioBuilder applicationMMBLT = scenario("applicationMMBLT") .during(Duration.ofMinutes(1)).on( exec(session -> { // Проверка времени и завершение сценария long startTime = session.getLong("startTime"); if (System.currentTimeMillis() - startTime > Duration.ofMinutes(1).toMillis()) { return session.markAsFailed(); } return session; }) .exec(MmbStrategy.applicationStrategy()) );

  8. Assistant

    Чтобы сделать расчёт количества минут до конца дня в классе OrchestratorStrategy и использовать это значение для управления длительностью выполнения сценария, можно реализовать это следующим образом:

    1. Добавьте метод для расчета количества минут до конца дня в вашем классе OrchestratorStrategy.

    2. Используйте это значение для установки длительности выполнения сценария.

    Шаги реализации:

    1. Добавьте метод в OrchestratorStrategy для расчета времени до конца дня.

    2. Используйте возвращаемое значение метода в месте, где вы определяете длительность сценария.

    Вот пример, как это можно сделать:

    import java.time.Duration;
    import java.time.LocalDateTime;
    import java.time.temporal.ChronoUnit;
    
    public class OrchestratorStrategy extends Simulation {
        // Другие члены класса...
    
        private Duration calculateDurationUntilEndOfDay() {
            LocalDateTime now = LocalDateTime.now();
            LocalDateTime endOfDay = now.withHour(23).withMinute(59).withSecond(59);
            return Duration.between(now, endOfDay);
        }
    
        ScenarioBuilder applicationMMBLT = scenario("applicationMMBLT")
            .during(calculateDurationUntilEndOfDay()).on(
                exec(session -> {
                    long startTime = session.getLong("startTime", System.currentTimeMillis());
                    if (System.currentTimeMillis() - startTime > calculateDurationUntilEndOfDay().toMillis()) {
                        return session.markAsFailed();
                    }
                    return session;
                })
                .exec(MmbStrategy.applicationStrategy())
            );
    
        // Другие методы...
    }
    

    Краткое объяснение:

    • Метод calculateDurationUntilEndOfDay возвращает Duration, который вычисляет разницу между текущим временем и концом дня (23:59:59).
    • Используйте это Duration в методе during() для управления продолжительностью выполнения сценария.
    • Внутри exec вы можете использовать calculateDurationUntilEndOfDay().toMillis() для сравнения длительности выполнения. Обратите внимание, что session.getLong("startTime") нуждается в дефолтном значении (например, System.currentTimeMillis()) на случай, если startTime еще не был установлен.

    Эта модификация позволит вашему сценарию работать вплоть до конца текущего дня.

  9. User

    с учетом этого редактируй класс LoadTestExecutor

  10. Assistant

    Хорошо, давайте объединим это все вместе. Мы будем использовать измененный класс OrchestratorStrategy, который умеет определять количество времени до конца дня, и создадим класс LoadTestExecutor, который управляет процессом запуска тестов и выполнения Python-скрипта.

    Измененный OrchestratorStrategy

    Мы предположим, что метод calculateDurationUntilEndOfDay вернет правильное время до конца дня.

    Новый класс LoadTestExecutor

    import ru.sber.pprb.mars.spr.lt.gatling.scenario.OrchestratorStrategy;
    import ru.sber.pprb.mars.spr.lt.services.OTTService;
    import ru.sber.pprb.mars.spr.lt.config.OttConfigProperties;
    
    import java.io.IOException;
    import java.time.Duration;
    import java.util.Scanner;
    
    public class LoadTestExecutor {
    
        private static final String PYTHON_SCRIPT_PATH = "C:\\Users\\22240938\\Desktop\\пакеты\\PYTHON_Project\\generate_requests.py";
    
        public static void main(String[] args) {
            OrchestratorStrategy.ottService = new OTTService(new OttConfigProperties());
            
            Scanner scanner = new Scanner(System.in);
            System.out.println("Введите количество итераций:");
            int iterations = scanner.nextInt();
            
            for (int i = 0; i < iterations; i++) {
                performLoadTest();
                executePythonScript();
            }
        }
    
        private static void performLoadTest() {
            OrchestratorStrategy.test = "normal";  // Вы используете значение, применимое для вашей задачи
            OrchestratorStrategy.strategy = "applicationMMB";
    
            // Создание объекта OrchestratorStrategy и настройка сценария
            OrchestratorStrategy orchestratorStrategy = new OrchestratorStrategy();
            System.out.println("Запуск нагрузки на: " + orchestratorStrategy.calculateDurationUntilEndOfDay().toMinutes() + " минут.");
            
            // Необходима корректировка, чтобы запускать симуляцию
            orchestratorStrategy.runSimulation();
        }
    
        private static void executePythonScript() {
            try {
                ProcessBuilder processBuilder = new ProcessBuilder("python", PYTHON_SCRIPT_PATH);
                Process process = processBuilder.start();
                
                int exitCode = process.waitFor();
                if (exitCode == 0) {
                    System.out.println("Python script executed successfully.");
                } else {
                    System.out.println("Python script execution failed with exit code: " + exitCode);
                }
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    Краткое объяснение:

    1. Объект OrchestratorStrategy: Мы создали объект OrchestratorStrategy, который управляет параметрами теста.

    2. Использование метода calculateDurationUntilEndOfDay: Этот метод используется для расчета продолжительности сценария перед запуском. Убедитесь, что этот метод правильно определён в OrchestratorStrategy.

    3. Запуск симуляции: runSimulation должен быть вызван для запуска Gatling сценария. Убедитесь, что это метод, который инициирует выполнение сценария внутри OrchestratorStrategy.

    Этот подход позволяет выполнить нагрузочное тестирование до конца текущего дня, а после этого выполнить Python скрипт и повторить процесс заданное количество раз.

  11. User

    поменяй функцию чтоб она добавляла новые элементы в словарь при модификации json строки

    ЕСЛИ НУЖНО ЗАПОЛНИТЬ NULL ЕСЛИ НЕ НАШЕЛСЯ ПАРАМЕТР ДЛЯ АГРЕГАТОВ

    def update_json(template, data_row, missing_keys): if isinstance(template, dict): for key, value in template.items(): if isinstance(value, (dict, list)): update_json(value, data_row, missing_keys) # Рекурсивно обходим словарь или список else: # Если данные отсутствуют, либо в строке имеется NaN, заменяем на None (null в JSON) try: template[key] = float(data_row.get(key.lower(), None).replace(',', '.')) if ',' in data_row.get(key.lower()) else data_row.get(key.lower(), None) except: template[key] = data_row.get(key.lower(), None)

                # Добавляем в список отсутствующих, если данные не найдены
                if pd.isna(template[key]):
                    template[key] = None  # Убедимся, что установлено None, если значение NaN
                    missing_keys.add(key)
                
    elif isinstance(template, list):
        for item in template:
            update_json(item, data_row, missing_keys)  # Рекурсивно обходим каждую часть списка
    
  12. Assistant

    Чтобы модифицировать функцию update_json так, чтобы она добавляла новые элементы в словарь, когда модифицирует JSON-строку, необходимо следовать логике, при которой отсутствующие ключи из набора данных будут добавлены в JSON с значением None (эквивалент null в JSON).

    Вот обновленный код функции, которая учитывает эти изменения:

    import pandas as pd
    
    def update_json(template, data_row, missing_keys):
        if isinstance(template, dict):
            for key, value in template.items():
                if isinstance(value, (dict, list)):
                    update_json(value, data_row, missing_keys)  # Рекурсивно обходим словарь или список
                else:
                    # Получаем значение из data_row, приводим к нижнему регистру и, если нужно, преобразуем запятые
                    data_value = data_row.get(key.lower(), None)
                    
                    if data_value is not None:
                        try:
                            # Преобразуем значение, если это необходимо
                            data_value = float(data_value.replace(',', '.')) if isinstance(data_value, str) and ',' in data_value else data_value
                        except ValueError:
                            pass
                    
                    template[key] = data_value
    
                    # Добавляем в список отсутствующих ключей, если данные не найдены или NaN
                    if pd.isna(template[key]):
                        template[key] = None  # Убедимся, что установлено None, если значение NaN
                        missing_keys.add(key)
            
            # Добавляем отсутствующие ключи с None в template, если параметров для заполнения нет
            for key in missing_keys:
                if key not in template:
                    template[key] = None
                    
        elif isinstance(template, list):
            for item in template:
                update_json(item, data_row, missing_keys)  # Рекурсивно обходим каждую часть списка
    
    # Пример использования
    template_example = {'key1': 'value1', 'key2': 'value2'}
    data_row_example = {'key1': '1,23'}  # Data row с отсутствующим 'key2'
    missing_keys_example = set()
    
    update_json(template_example, data_row_example, missing_keys_example)
    print(template_example)
    # Output: {'key1': 1.23, 'key2': None}
    

    Изменения и объяснения:

    • Получение и преобразование значений: Теперь значения извлекаются, и если они отсутствуют или являются NaN, они заменяются None.
    • Добавление отсутствующих ключей: В конце обработки словаря, добавляются отсутствующие ключи из missing_keys со значением None, если они еще не существуют в template.
    • Рекурсивный обход: Используется рекурсивная обработка как словарей, так и списков для глубокой модификации JSON структуры.
    • Использование большого регистра для отсутствующих ключей: В примере missing_keys не используется для добавления новых отсутствующих ключей в JSON, если они уже не в template. Если это нужно поменять, просто обеспечьте передачу этих ключей (ключии не добавляются, только если они изначально не принадлежат шаблону).
  13. User

    напиши функцию которая создает словарь из данных таблицы и записывает его в джейсон строку

  14. Assistant

    Для создания словаря из данных таблицы и записи его в строку JSON, можно использовать библиотеку pandas для чтения таблицы и библиотеку json для сериализации данных в формат JSON. Вот пример того, как это можно сделать:

    import pandas as pd
    import json
    
    def table_to_json_string(file_path):
        """
        Читает таблицу из файла (скажем, CSV или Excel), преобразует её в словарь и затем в JSON строку.
    
        :param file_path: Путь к файлу таблицы (например, CSV)
        :return: JSON строка, представляющая данные таблицы
        """
        # Считываем таблицу в DataFrame
        df = pd.read_csv(file_path)  # Или pd.read_excel(file_path) для Excel файлов
        
        # Преобразуем DataFrame в список словарей (каждая строка таблицы — это отдельный словарь)
        data_list = df.to_dict(orient='records')
    
        # Преобразуем список словарей в JSON строку
        json_string = json.dumps(data_list, ensure_ascii=False, indent=4)
        
        return json_string
    
    # Пример использования
    # Принимаем путь к таблице в формате CSV
    file_path = 'path_to_your_table.csv'
    json_result = table_to_json_string(file_path)
    print(json_result)
    

    Объяснения:

    • Загрузка данных: Используем pandas для чтения данных из файла. Можно использовать pd.read_csv() для CSV файлов или pd.read_excel() для Excel файлов.
    • Конвертация в словарь: Метод df.to_dict(orient='records') преобразует каждую строку в словарь, где ключами являются названия столбцов.
    • Преобразование в JSON строку: Используем json.dumps() для сериализации списка словарей в JSON формат. Параметры ensure_ascii=False и indent=4 позволяют использовать не-ASCII символы в строках и форматировать вывод с отступом для удобочитаемости.
    • Вывод: Функция возвращает JSON строку, представляющую данные таблицы.

    Этот пример позволяет вам преобразовать любую таблицу в формате CSV или Excel в формат JSON и затем работать с этой информацией как с JSON строкой.

  15. User

    напиши функцию которая создает файл джейсон в котором каждая строка является словарем, данные для которого берутся из таблицы

  16. Assistant

    Для создания JSON-файла, в котором каждая строка является словарем, данных для которого берутся из таблицы, можно использовать библиотеку pandas для обработки таблицы и библиотеку json для записи данных.

    Это решение будет записывать каждые строки таблицы в виде отдельных JSON словарей в файл. Этот подход полезен, когда вам нужен файл в формате JSON Lines или JSONL (по сути, текстовый файл, где каждая строка — это допустимый JSON объект).

    Вот пример такого подхода:

    import pandas as pd
    import json
    
    def create_json_file_from_table(file_path, output_json_path):
        """
        Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.
        
        :param file_path: Путь к файлу таблицы (например, CSV).
        :param output_json_path: Путь, куда будет сохранён JSONL файл.
        """
        # Считываем таблицу в DataFrame
        df = pd.read_csv(file_path)  # Или pd.read_excel(file_path) для Excel файлов
        
        # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
        data_list = df.to_dict(orient='records')
    
        # Записываем каждый словарь в отдельную строку файла
        with open(output_json_path, 'w', encoding='utf-8') as f:
            for data in data_list:
                json_line = json.dumps(data, ensure_ascii=False)
                f.write(json_line + "\n")
        
        print(f"Данные были успешно записаны в {output_json_path}")
    
    # Пример использования
    input_file_path = 'path_to_your_table.csv'
    output_json_file_path = 'output_file.jsonl'
    create_json_file_from_table(input_file_path, output_json_file_path)
    

    Объяснения:

    • Загрузка данных: Используем pandas для поиска данных из файла таблицы, например, CSV. Поддерживаются и другие форматы, такие как Excel, если заменить pd.read_csv() на pd.read_excel().

    • Преобразование в словари: Метод df.to_dict(orient='records') преобразует каждую строку в словарь с использованием названий столбцов как ключей.

    • Запись в файл: Для каждого словаря из списка создается строка JSON, которая затем записывается в файл. Каждый JSON объект занимает одну строку в выходном файле. Это делает файл JSON "строковым" или JSONL.

    • Формат JSON Lines: Формат JSONL (или NDJSON - Newline Delimited JSON) широко используется для логов и больших данных, он удобен для построчной обработки JSON данных.

    Этот метод создаст файл output_file.jsonl, где каждая строка представляет собой JSON объект, соответствующий одной строке данных из таблицы.

  17. User

    напиши скрипт который убирает колонки в конце которых есть _format или col_nm. и меняет название колонки total_debt_max24 на Total_debt_max24

  18. Assistant

    Для выполнения этой задачи с помощью Python можно использовать библиотеку pandas для обработки таблиц и простую проверку строк для фильтрации и изменения имен столбцов. Ниже представлен пример скрипта, который справится с этой задачей:

    import pandas as pd
    
    def process_table(file_path, output_file_path):
        """
        Обрабатывает таблицу, удаляя колонки с суффиксами '_format' и 'col_nm',
        и изменяет имя столбца 'total_debt_max24' на 'Total_debt_max24'.
        
        :param file_path: Путь к входному файлу таблицы (например, CSV).
        :param output_file_path: Путь для сохранения отредактированного файла.
        """
        # Считываем таблицу в DataFrame
        df = pd.read_csv(file_path)  # Или используйте pd.read_excel(file_path) для Excel файлов
    
        # Фильтрация столбцов по условию
        columns_to_keep = [
            col for col in df.columns 
            if not (col.endswith('_format') or col.endswith('col_nm'))
        ]
        
        # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
        df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
    
        # Сохраняем отредактированную таблицу
        df.to_csv(output_file_path, index=False)  # Или используйте to_excel() для сохранения в Excel
    
        print(f"Обработанный файл сохранен как {output_file_path}")
    
    # Пример использования
    input_file_path = 'path_to_your_input_file.csv'
    output_file_path = 'path_to_your_output_file.csv'
    process_table(input_file_path, output_file_path)
    

    Объяснения:

    • Чтение данных: Используется pd.read_csv() для загрузки данных из CSV файла (для Excel можно заменить).
    • Фильтрация столбцов: columns_to_keep создается с помощью спискового включения, сохраняющее только те столбцы, которые не заканчиваются на _format или col_nm.
    • Изменение имени столбца: Используется метод rename для замены 'total_debt_max24' на 'Total_debt_max24'.
    • Сохранение данных: Преобразованные данные сохраняются в новый CSV файл.

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

  19. User

    добавь к этому коду замену , на . в колонках дф

  20. Assistant

    Чтобы заменить запятые на точки в числовых колонках DataFrame, можно использовать метод replace() библиотеки pandas. Мы применим это во всем DataFrame для всех строк и столбцов, чтобы убедиться, что запятые заменяются точками, если они присутствуют.

    Вот обновленный скрипт с дополнительным шагом по замене запятых на точки:

    import pandas as pd
    
    def process_table(file_path, output_file_path):
        """
        Обрабатывает таблицу, удаляя колонки с суффиксами '_format' и 'col_nm',
        изменяет имя столбца 'total_debt_max24' на 'Total_debt_max24',
        и заменяет запятые на точки в числовых данных.
        
        :param file_path: Путь к входному файлу таблицы (например, CSV).
        :param output_file_path: Путь для сохранения отредактированного файла.
        """
        # Считываем таблицу в DataFrame
        df = pd.read_csv(file_path)  # Или используйте pd.read_excel(file_path) для Excel файлов
        
        # Замена запятых на точки в строках
        df = df.applymap(lambda x: str(x).replace(',', '.') if isinstance(x, str) else x)
        
        # Фильтрация столбцов по условию
        columns_to_keep = [
            col for col in df.columns 
            if not (col.endswith('_format') or col.endswith('col_nm'))
        ]
        
        # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
        df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
    
        # Сохраняем отредактированную таблицу
        df.to_csv(output_file_path, index=False)  # Или используйте to_excel() для сохранения в Excel
    
        print(f"Обработанный файл сохранен как {output_file_path}")
    
    # Пример использования
    input_file_path = 'path_to_your_input_file.csv'
    output_file_path = 'path_to_your_output_file.csv'
    process_table(input_file_path, output_file_path)
    

    Объяснения:

    • Замена запятых на точки: Используем applymap() для применения функции ко всем элементам DataFrame, которая заменяет запятые на точки в строках. Это может быть полезно для корректного представления чисел, если они представлены в виде строк с запятыми.
    • Обработка строковых данных: Прежде чем применять замену, проверяется, является ли элемент строки объектом str.

    Этот скрипт изменяет весь DataFrame, чтобы справиться с запятыми в строках, представляющих числовые данные, удаляет ненужные столбцы и изменяет имя столбца.

  21. User

    сори, не к этому коду, а к этому def create_json_file_from_table(file_path, output_json_path): """ Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.

    :param file_path: Путь к файлу таблицы (например, CSV).
    :param output_json_path: Путь, куда будет сохранён JSONL файл."""
    # Считываем таблицу в DataFrame
    df = pd.read_csv(file_path)  # Или используйте pd.read_excel(file_path) для Excel файлов
    
    # Фильтрация столбцов по условию
    columns_to_keep = [
        col for col in df.columns 
        if not (col.endswith('_format') or col.endswith('col_nm'))
    ]
    
    # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
    df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
    
    # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
    data_list = df.to_dict(orient='records')
    
    # Записываем каждый словарь в отдельную строку файла
    with open(output_json_path, 'w', encoding='utf-8') as f:
        for data in data_list:
            json_line = json.dumps(data, ensure_ascii=False)
            f.write(json_line + "\n")
    
    print(f"Данные были успешно записаны в {output_json_path}")
    

    input_file_path = 'ckp_mmbscore_20240919.csv' output_json_file_path = f'ckpip_mmbscore{current_date}.json' create_json_file_from_table(input_file_path, output_json_file_path) input_file_path = 'ckp_mmbscore_20240919.csv' output_json_file_path = f'ckpip_irb_sme{current_date}.json' create_json_file_from_table(input_file_path, output_json_file_path)

  22. Assistant

    Для того чтобы заменить запятые на точки в колонках DataFrame перед записью в JSON Lines файл, вы можете использовать метод applymap() для обработки всех строковых значений в DataFrame. Соответствующие изменения нужно внести в код create_json_file_from_table.

    Вот как можно обновить ваш скрипт, добавив шаг замены запятых на точки:

    import pandas as pd
    import json
    import datetime
    
    def replace_commas(df):
        """
        Заменяет запятые на точки в строковых представлениях численных данных.
        
        :param df: DataFrame для обработки.
        :return: DataFrame с преобразованными значениями.
        """
        return df.applymap(lambda x: str(x).replace(',', '.') if isinstance(x, str) else x)
    
    def create_json_file_from_table(file_path, output_json_path):
        """
        Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.
        
        :param file_path: Путь к файлу таблицы (например, CSV).
        :param output_json_path: Путь, куда будет сохранён JSONL файл.
        """
        # Считываем таблицу в DataFrame
        df = pd.read_csv(file_path)  # Или используйте pd.read_excel(file_path) для Excel файлов
    
        # Замена запятых на точки в строковых данных
        df = replace_commas(df)
    
        # Фильтрация столбцов по условию
        columns_to_keep = [
            col for col in df.columns 
            if not (col.endswith('_format') or col.endswith('col_nm'))
        ]
        
        # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
        df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
    
        # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
        data_list = df.to_dict(orient='records')
    
        # Записываем каждый словарь в отдельную строку файла
        with open(output_json_path, 'w', encoding='utf-8') as f:
            for data in data_list:
                json_line = json.dumps(data, ensure_ascii=False)
                f.write(json_line + "\n")
        
        print(f"Данные были успешно записаны в {output_json_path}")
    
    # Пример использования
    current_date = datetime.datetime.now().strftime("%Y%m%d")
    input_file_path = 'ckp_mmbscore_20240919.csv'
    output_json_file_path = f'ckpip_mmbscore{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    
    output_json_file_path = f'ckpip_irb_sme{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    

    Объяснения:

    • replace_commas Функция: Эта функция обрабатывает все элементы DataFrame, заменяя запятые на точки в строках. Строки с числами, в которых используются десятичные запятые, станут похожи на строки с десятичными точками.
    • Вызов replace_commas: Запускается перед фильтрацией колонок, чтобы убедиться, что обработка данных произойдет независимо от будущих операций с DataFrame.
    • Изменение и сохранение: Остальная часть процесса фильтрации и сохранения в JSONL остается неизменной.

    Теперь скрипт заменяет все запятые на точки во всех строковых значениях DataFrame, обрабатывая их перед записью в JSONL формат.

  23. User

    в этом коде поправь. нужно джейсон строки записывать, а там пустые данные это null, а не NaN, которые записались def replace_commas(df): """ Заменяет запятые на точки в строковых представлениях численных данных.

    :param df: DataFrame для обработки.
    :return: DataFrame с преобразованными значениями.
    """
    return df.applymap(lambda x: float(x.replace(',', '.')) if isinstance(x, str) and ',' in x else x)
    

    def create_json_file_from_table(file_path, output_json_path): """ Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.

    :param file_path: Путь к файлу таблицы (например, CSV).
    :param output_json_path: Путь, куда будет сохранён JSONL файл.
    """
    # Считываем таблицу в DataFrame
    if 'irb' in output_json_path:
        df = pd.read_csv(file_path, dtype = {'inn': str}, parse_dates=['signed_dt']).sort_values(by='signed_dt').drop_duplicates(subset='inn', keep='last')
        df['signed_dt'] = df['signed_dt'].astype(str)
    else:
        df = pd.read_csv(file_path, dtype = {'inn': str})
    
    # Фильтрация столбцов по условию
    columns_to_keep = [
        col for col in df.columns 
        if not (col.endswith('_format') or col.endswith('col_nm'))
    ]
    
    # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
    df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
    
    # Замена запятых на точки в строковых данных
    df = replace_commas(df)
    if 'mmbscore' in output_json_path:
        df['crm_segm'] = 'Малые'
    
    # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
    data_list = df.to_dict(orient='records')
    
    # Записываем каждый словарь в отдельную строку файла
    with open(output_json_path, 'w', encoding='utf-8') as f:
        for data in data_list:
            json_line = json.dumps(data, ensure_ascii=False)
            f.write(json_line + "\n")
    
    print(f"Данные были успешно записаны в {output_json_path}")
    

    input_file_path = 'ckp_mmbscore_20240919.csv' output_json_file_path = f'ckpip_mmbscore{current_date}.json' create_json_file_from_table(input_file_path, output_json_file_path) input_file_path = 'ckp_irb_20240919.csv' output_json_file_path = f'ckpip_irb_sme{current_date}.json' create_json_file_from_table(input_file_path, output_json_file_path)

  24. Assistant

    Чтобы убедиться, что все отсутствующие или пустые данные преобразуются в null вместо NaN в JSON-строках, можно использовать метод fillna() для замены NaN значениями None, который автоматически преобразуется в null при сериализации в JSON с использованием json.dumps().

    Вот обновленный код:

    import pandas as pd
    import json
    import datetime
    
    def replace_commas(df):
        """
        Заменяет запятые на точки в строковых представлениях численных данных.
        
        :param df: DataFrame для обработки.
        :return: DataFrame с преобразованными значениями.
        """
        return df.applymap(lambda x: float(x.replace(',', '.')) if isinstance(x, str) and ',' in x else x)
    
    def create_json_file_from_table(file_path, output_json_path):
        """
        Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.
        
        :param file_path: Путь к файлу таблицы (например, CSV).
        :param output_json_path: Путь, куда будет сохранён JSONL файл.
        """
        # Считываем таблицу в DataFrame
        if 'irb' in output_json_path:
            df = pd.read_csv(file_path, dtype={'inn': str}, parse_dates=['signed_dt']).sort_values(by='signed_dt').drop_duplicates(subset='inn', keep='last')
            df['signed_dt'] = df['signed_dt'].astype(str)
        else:
            df = pd.read_csv(file_path, dtype={'inn': str})
        
        # Фильтрация столбцов по условию
        columns_to_keep = [
            col for col in df.columns 
            if not (col.endswith('_format') or col.endswith('col_nm'))
        ]
        
        # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
        df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
        
        # Замена запятых на точки в строковых данных
        df = replace_commas(df)
        
        if 'mmbscore' in output_json_path:
            df['crm_segm'] = 'Малые'
        
        # Замена NaN на None для возможности конвертации в null в JSON
        df = df.where(pd.notnull(df), None)
        
        # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
        data_list = df.to_dict(orient='records')
    
        # Записываем каждый словарь в отдельную строку файла
        with open(output_json_path, 'w', encoding='utf-8') as f:
            for data in data_list:
                json_line = json.dumps(data, ensure_ascii=False)
                f.write(json_line + "\n")
        
        print(f"Данные были успешно записаны в {output_json_path}")
    
    # Установка текущей даты
    current_date = datetime.datetime.now().strftime("%Y%m%d")
    
    # Пример использования
    input_file_path = 'ckp_mmbscore_20240919.csv'
    output_json_file_path = f'ckpip_mmbscore{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    
    input_file_path = 'ckp_irb_20240919.csv'
    output_json_file_path = f'ckpip_irb_sme{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    

    Краткие объяснения:

    • Замена NaN на None: Использование df.where(pd.notnull(df), None) обеспечивает замену всех значений NaN на None в DataFrame. При сериализации None в JSON, None автоматически преобразуется в null.
    • Цепочка операций фильтрации и изменения: Остается неизменной, но теперь она сосредоточена на подготовке данных перед преобразованием в JSON.
    • Обработка специфических требований: Все предыдущие операции, включающие проверку в зависимости от условия в имени выходного файла, остаются на своих местах.
  25. User

    не сработало

  26. Assistant

    Извините за недоразумение. Давайте попробуем другой способ, чтобы убедиться, что NaN правильно преобразуются в null в JSON-выходе. Мы можем обновить код, чтобы явно проверять значения и заменять NaN на None (что сериализуется в null в JSON).

    Вот обновленный код:

    import pandas as pd
    import json
    import datetime
    import numpy as np
    
    def replace_commas(df):
        """
        Заменяет запятые на точки в строковых представлениях численных данных.
        
        :param df: DataFrame для обработки.
        :return: DataFrame с преобразованными значениями.
        """
        return df.applymap(lambda x: float(x.replace(',', '.')) if isinstance(x, str) and ',' in x else x)
    
    def create_json_file_from_table(file_path, output_json_path):
        """
        Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.
        
        :param file_path: Путь к файлу таблицы (например, CSV).
        :param output_json_path: Путь, куда будет сохранён JSONL файл.
        """
        # Считываем таблицу в DataFrame
        if 'irb' in output_json_path:
            df = pd.read_csv(file_path, dtype={'inn': str}, parse_dates=['signed_dt']).sort_values(by='signed_dt').drop_duplicates(subset='inn', keep='last')
            df['signed_dt'] = df['signed_dt'].astype(str)
        else:
            df = pd.read_csv(file_path, dtype={'inn': str})
        
        # Фильтрация столбцов по условию
        columns_to_keep = [
            col for col in df.columns 
            if not (col.endswith('_format') or col.endswith('col_nm'))
        ]
        
        # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
        df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
        
        # Замена запятых на точки в строковых данных
        df = replace_commas(df)
        
        if 'mmbscore' in output_json_path:
            df['crm_segm'] = 'Малые'
        
        # Замена NaN на None для возможности конвертации в null в JSON
        df = df.where(pd.notnull(df), None)
    
        # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
        data_list = json.loads(df.to_json(orient='records', default_handler=str))
    
        # Записываем каждый словарь в отдельную строку файла
        with open(output_json_path, 'w', encoding='utf-8') as f:
            for data in data_list:
                json_line = json.dumps(data, ensure_ascii=False)
                f.write(json_line + "\n")
        
        print(f"Данные были успешно записаны в {output_json_path}")
    
    # Установка текущей даты
    current_date = datetime.datetime.now().strftime("%Y%m%d")
    
    # Пример использования
    input_file_path = 'ckp_mmbscore_20240919.csv'
    output_json_file_path = f'ckpip_mmbscore{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    
    input_file_path = 'ckp_irb_20240919.csv'
    output_json_file_path = f'ckpip_irb_sme{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    

    Объяснения:

    • where метод: Мы используем df.where(pd.notnull(df), None), чтобы заменить все NaN на None в DataFrame.
    • to_json с обработчиком: Используем df.to_json(orient='records', default_handler=str), чтобы обрабатывать преобразования DataFrame в JSON, сохраняя строки в правильном формате и заменяя NaN на None.
    • Проверка и исправление данных: При каждом этапе обработки мы проверяем корректное преобразование данных, делая NaN удобные для преобразований JSON через None.

    Эти шаги должны корректно обработать NaN и записать их как null в JSON-строках.

  27. User

    не работает. давай дата лист менять

  28. Assistant

    Давайте изменим подход и обработаем data_list так, чтобы каждое значение NaN было преобразовано в None в процессе создания data_list. Это можно сделать, вручную проходя по списку словарей и заменяя NaN на None.

    Вот обновленный код:

    import pandas as pd
    import json
    import datetime
    import numpy as np
    
    def replace_commas(df):
        """
        Заменяет запятые на точки в строковых представлениях численных данных.
    
        :param df: DataFrame для обработки.
        :return: DataFrame с преобразованными значениями.
        """
        return df.applymap(lambda x: float(x.replace(',', '.')) if isinstance(x, str) and ',' in x else x)
    
    def create_json_file_from_table(file_path, output_json_path):
        """
        Читает таблицу из файла и записывает её в файл в формате JSON Lines (JSONL), где каждая строка — это отдельный JSON объект.
    
        :param file_path: Путь к файлу таблицы (например, CSV).
        :param output_json_path: Путь, куда будет сохранён JSONL файл.
        """
        # Считываем таблицу в DataFrame
        if 'irb' in output_json_path:
            df = pd.read_csv(file_path, dtype={'inn': str}, parse_dates=['signed_dt']).sort_values(by='signed_dt').drop_duplicates(subset='inn', keep='last')
            df['signed_dt'] = df['signed_dt'].astype(str)
        else:
            df = pd.read_csv(file_path, dtype={'inn': str})
    
        # Фильтрация столбцов по условию
        columns_to_keep = [
            col for col in df.columns 
            if not (col.endswith('_format') or col.endswith('col_nm'))
        ]
        
        # Изменение имени столбца 'total_debt_max24' на 'Total_debt_max24'
        df = df[columns_to_keep].rename(columns={'total_debt_max24': 'Total_debt_max24'})
        
        # Замена запятых на точки в строковых данных
        df = replace_commas(df)
    
        if 'mmbscore' in output_json_path:
            df['crm_segm'] = 'Малые'
        
        # Преобразуем DataFrame в список словарей (каждая строка — отдельный словарь)
        data_list = df.to_dict(orient='records')
    
        # Замена NaN на None
        for record in data_list:
            for key, value in record.items():
                if pd.isna(value):  # Используем Pandas для проверки на NaN
                    record[key] = None
    
        # Записываем каждый словарь в отдельную строку файла
        with open(output_json_path, 'w', encoding='utf-8') as f:
            for data in data_list:
                json_line = json.dumps(data, ensure_ascii=False)
                f.write(json_line + "\n")
        
        print(f"Данные были успешно записаны в {output_json_path}")
    
    # Установка текущей даты
    current_date = datetime.datetime.now().strftime("%Y%m%d")
    
    # Пример использования
    input_file_path = 'ckp_mmbscore_20240919.csv'
    output_json_file_path = f'ckpip_mmbscore{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    
    input_file_path = 'ckp_irb_20240919.csv'
    output_json_file_path = f'ckpip_irb_sme{current_date}.json'
    create_json_file_from_table(input_file_path, output_json_file_path)
    

    Объяснения:

    • Обход списка: После создания списка data_list из DataFrame, каждой строке соответствуют словари. Мы проходим по каждому словарю и заменяем значения NaN на None.
    • Использование pd.isna(): Pandas предоставляет pd.isna() для проверки на NaN, что помогает обеспечить корректную замену значений на None.

    Эти изменения должны гарантировать, что все значения NaN в данных заменяются на None до того, как они будут преобразованы в JSON, обеспечивая корректную запись null в выходном файле.

  29. User

    как отфильтровать дф по колонке? мне надо выбрать только тех длина инн которых == 12

  30. Assistant

    Чтобы отфильтровать DataFrame по длине значений в определённой колонке (в данном случае длина ИНН равна 12), вы можете использовать метод apply() в сочетании с логической индексацией. Это позволяет вам создавать маску фильтрации и применять её к DataFrame.

    Вот пример кода, как это можно сделать:

    import pandas as pd
    
    # Предположим, у вас есть DataFrame df с колонкой 'inn'
    data = {
        'inn': ['123456789012', '987654321098', '1234567890', '0123456789012'],
        'name': ['Company A', 'Company B', 'Company C', 'Company D']
    }
    
    df = pd.DataFrame(data)
    
    # Фильтрация данных по длине значения в колонке 'inn'
    filtered_df = df[df['inn'].apply(lambda x: len(str(x)) == 12)]
    
    print(filtered_df)
    

    Объяснения:

    • Используем apply со строковой функцией len: Мы применяем метод apply к колонке 'inn', преобразовывая каждое значение в строку и проверяя её длину.
    • Логическая индексация: df[...] используется для фильтрации DataFrame на основании булевой маски, возвращённой методом apply.
    • Преобразование в строку: Мы используем str(x), чтобы гарантировать, что длина считается правильно, даже если значения имеют числовой тип.

    Этот способ эффективен для фильтрации строк в DataFrame по конкретным условиям, связанным с содержимым колонки.

  31. User

    вернемся к джаве. вот так я поменял код, все ли ок? закомментил, не обращай внимания // ScenarioBuilder applicationMMBLT = scenario("applicationMMBLT") // .during(calculateDurationUntilEndOfDay()).on( // .during(Duration.ofMinutes(10)).on( // exec(session -> { // long startTime = session.getLong("startTime"); // if (System.currentTimeMillis() - startTime > calculateDurationUntilEndOfDay().toMillis()) { // return session.markAsFailed(); // } // return session; // }) // .exec(MmbStrategy.applicationStrategy()) // );

  32. Assistant

    Код, который вы представили, использует метод during для управления продолжительностью выполнения сценария Gatling. Давайте рассмотрим, что делает этот код и проверим, правильно ли он используется.

    Ваш код:

    // ScenarioBuilder applicationMMBLT = scenario("applicationMMBLT")
    //         .during(calculateDurationUntilEndOfDay()).on( // .during(Duration.ofMinutes(10)).on(
    //                 exec(session -> {
    //                     long startTime = session.getLong("startTime");
    //                     if (System.currentTimeMillis() - startTime > calculateDurationUntilEndOfDay().toMillis()) {
    //                         return session.markAsFailed();
    //                     }
    //                     return session;
    //                 })
    //                         .exec(MmbStrategy.applicationStrategy())
    //         );
    

    Пояснения и проверка:

    1. during(calculateDurationUntilEndOfDay()): Вы используете метод calculateDurationUntilEndOfDay(), чтобы установить длительность, на протяжении которой будет выполняться сценарий. Этот метод должен возвращать объект типа Duration.

    2. Логика exec:

      • Вы получаете startTime из session. Убедитесь, что startTime действительно сохраняется в сессии до вызова этого сценария, иначе это вызовет NullPointerException.
      • Логика if проверяет, если текущее время (System.currentTimeMillis()) минус startTime превышает рассчитанное длительность в миллисекундах, то сессия помечена как неудачная с помощью метода session.markAsFailed().
      • Однако эта проверка внутри блока exec не обязательна в случае, если вы используете during с правильной длительностью, потому что during сам автоматически прекратит выполнение по истечении времени.
    3. Комментарий: Методы, которые вы закомментировали, показывают, что ранее вы использовали фиксированное значение Duration.ofMinutes(10). Основное изменение, которое вы должны учитывать, это обеспечение правильной работы вашего метода calculateDurationUntilEndOfDay.

    Рекомендации:

    • Убедитесь, что calculateDurationUntilEndOfDay() работает корректно и возвращает ожидаемое значение Duration.
    • Если вы полагаетесь на startTime в сессии, убедитесь, что он установлен до вызова этого сценария.
    • Возможно, нет необходимости вручную проверять время выполнения внутри exec, если используется метод during.

    Если все эти моменты учтены, ваш код должен работать корректно в рамках заявленной логики.

  33. User

    этот код написан неверно. сделай функцию передачи запросов таким же точно образом как в PackageLT. мне надо чтобы запросы отправлялись на сервер точно так же как тут, потом когда время заканчивается выполняется скрипт питон, а потом заново запустить запросы и так несколько раз package ru.sber.pprb.mars.spr.lt.gatling.test;

    import ru.sber.pprb.mars.spr.lt.config.OttConfigProperties; import ru.sber.pprb.mars.spr.lt.gatling.scenario.*; import io.gatling.app.Gatling; import io.gatling.core.config.GatlingPropertiesBuilder; import lombok.extern.slf4j.Slf4j; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; import ru.sber.pprb.mars.spr.lt.services.OTTService;

    import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is;

    @Slf4j @SpringBootTest(classes = {OttConfigProperties.class}) @EnableAutoConfiguration public class PackageLT { @Autowired OttConfigProperties ottConfigProperties;

    final GatlingPropertiesBuilder properties = new GatlingPropertiesBuilder()
            .resourcesDirectory("./src/main/resources")
            .resultsDirectory("./target/gatling");
    

    @Test public void appMMBLoadTesting() { log.info("Запуск разового прогона скриптов"); OrchestratorStrategy.test = "debug"; OrchestratorStrategy.strategy="applicationMMB"; OrchestratorStrategy.repeatFile="result\1715699813726\repeat.csv"; OrchestratorStrategy.ottService = new OTTService(ottConfigProperties); log.info("Параметры запуска: ott-{}", ottConfigProperties.isEnabled()); runSimulation(OrchestratorStrategy.class.getName()); }

    void runSimulation(String simulationClass) { properties.simulationClass(simulationClass); int statusCode = Gatling.fromMap(properties.build()); String error = statusCode == 2 ? "AssertionsFailed" : "InvalidArguments"; assertThat("Результат теста не успешный (" + error + ") ", statusCode, is(0)); }

  34. Assistant

    Для реализации функционала, где выполняется нагрузочное тестирование (сценарии Gatling), затем выполняется Python-скрипт, и это повторяется несколько раз, вы можете создать класс, который будет управлять этой логикой. Мы будем использовать подход, где основная логика реализована с использованием классов Spring и JUnit для управления тестированием и конфигурацией через Gatling. Давайте посмотрим, как это можно сделать.

    Реализация:

    1. Создайте класс LoadTestExecutor: Этот класс будет управлять циклом выполнения тестов и скриптов.

    2. Используйте метод runSimulation для запуска каждого тестового прогона.

    3. Используйте ProcessBuilder для запуска Python-скрипта.

    Вот как может выглядеть ваша реализация:

    package ru.sber.pprb.mars.spr.lt.gatling.test;
    
    import ru.sber.pprb.mars.spr.lt.config.OttConfigProperties;
    import ru.sber.pprb.mars.spr.lt.gatling.scenario.OrchestratorStrategy;
    import io.gatling.app.Gatling;
    import io.gatling.core.config.GatlingPropertiesBuilder;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.boot.test.context.SpringBootTest;
    import ru.sber.pprb.mars.spr.lt.services.OTTService;
    
    import java.io.IOException;
    import java.time.LocalTime;
    import java.util.concurrent.TimeUnit;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.is;
    
    @Slf4j
    @SpringBootTest(classes = {OttConfigProperties.class})
    @EnableAutoConfiguration
    public class LoadTestExecutor {
    
        private static final String PYTHON_SCRIPT_PATH = "C:\\Users\\22240938\\Desktop\\пакеты\\PYTHON_Project\\generate_requests.py";
        private static final int ITERATIONS = 3; // Set the number of iterations
        
        @Autowired
        OttConfigProperties ottConfigProperties;
    
        final GatlingPropertiesBuilder properties = new GatlingPropertiesBuilder()
            .resourcesDirectory("./src/main/resources")
            .resultsDirectory("./target/gatling");
    
        @Test
        public void appMMBLoadTesting() {
            log.info("Запуск разового прогона скриптов");
            
            for (int i = 0; i < ITERATIONS; i++) {
                log.info("Запуск итерации тестирования: " + (i + 1));
                runGatlingSimulation();
                log.info("Тестирование завершено. Запуск Python скрипта.");
                runPythonScript();
            }
        }
    
        private void runGatlingSimulation() {
            OrchestratorStrategy.test = "debug";
            OrchestratorStrategy.strategy = "applicationMMB";
            OrchestratorStrategy.repeatFile = "result\\1715699813726\\repeat.csv";
            OrchestratorStrategy.ottService = new OTTService(ottConfigProperties);
            log.info("Параметры запуска: ott-{}", ottConfigProperties.isEnabled());
            runSimulation(OrchestratorStrategy.class.getName());
        }
    
        private void runSimulation(String simulationClass) {
            properties.simulationClass(simulationClass);
            int statusCode = Gatling.fromMap(properties.build());
            String error = statusCode == 2 ? "AssertionsFailed" : "InvalidArguments";
            assertThat("Результат теста не успешный (" + error + ") ", statusCode, is(0));
        }
    
        private void runPythonScript() {
            try {
                ProcessBuilder processBuilder = new ProcessBuilder("python", PYTHON_SCRIPT_PATH);
                Process process = processBuilder.start();
                int exitCode = process.waitFor();
                if (exitCode != 0) {
                    log.error("Python script execution failed with exit code: " + exitCode);
                } else {
                    log.info("Python script executed successfully.");
                }
            } catch (IOException | InterruptedException e) {
                log.error("Failed to execute Python script", e);
            }
        }
    }
    

    Объяснения:

    • Циклический запуск: Код запускает цикл из заданного числа итераций (ITERATIONS), где каждая итерация состоит из выполнения сценария нагрузочного тестирования и выполнения Python-скрипта.

    • Gatling Simulation: В методе runGatlingSimulation, настраиваются параметры OrchestratorStrategy и запускается симуляция с помощью метода runSimulation.

    • Python Script Execution: Метод runPythonScript используется для выполнения внешнего Python-скрипта через ProcessBuilder.

    Эта архитектура позволяет удобно развернуть сценарии для многократного тестирования с интеркалиброванными Python-скриптами. Вы можете изменить путь к Python-скрипту и добавить любые специфические конфигурации в зависимости от вашего сценария.

  35. User

    объясни подробно функцию appMMBLoadTesting

  36. Assistant

    Функция appMMBLoadTesting в данном контексте используется для выполнения нагрузки на основные компоненты системы с использованием Gatling, затем запускает Python-скрипт, и этот процесс повторяется несколько раз. Давайте разберем ее более подробно.

    Компоненты функции appMMBLoadTesting:

    1. Аннотация @Test:

      • Это аннотация JUnit, которая указывает, что метод appMMBLoadTesting является тестовым. JUnit автоматически обнаружит и выполнит этот метод при запуске тестов.
    2. Инициализация контекста и конфигурации:

      • Функция использует @Autowired для инъекции зависимости OttConfigProperties. Это позволяет загружать все необходимые конфигурации для OrchestratorStrategy и других компонентов, использующих OttConfig.
    3. Логирование начала работы:

      • log.info("Запуск разового прогона скриптов"); — это лог-сообщение, которое сообщает о начале процесса тестирования.
    4. Цикл выполнения (for loop):

      • Цикл for (int i = 0; i < ITERATIONS; i++) определяет количество раз, которое тест и связанный скрипт Python будут запущены. Здесь ITERATIONS задает количество воспроизведений (интераций) полного процесса.
      • Внутри цикла после каждого итерации ведется логирование через log.info, чтобы отследить текущий номер итерации.
    5. Запуск сценария Gatling:

      • Метод runGatlingSimulation() внутри каждой итерации используется для конфигурирования и запуска тестового сценария Gatling.
      • Он устанавливает параметры для OrchestratorStrategy, включая тестовый режим, стратегию и файл повторов. Эти параметры определяют, какие именно сценарии и конфигурации запускаются.
    6. Запуск Python-скрипта:

      • После завершения тестовой нагрузки функция runPythonScript() активирует запуск внешнего Python-скрипта. Это делается для выполнения каких-то дополнительных задач (предположительно, данных манипуляций), необходимых после тестов.
      • В случае ошибки при выполнении скрипта, выводится ошибка через логирование.
    7. Завершение одной итерации:

      • После выполнения скрипта итерация завершена, и цикл начинается снова, если это не последний прогон.

    Основные задачи функции:

    • Пакетное тестирование и манипуляция данными: appMMBLoadTesting автоматизирует нагрузочное тестирование процессов через Gatling, а затем и манипуляцию данными или анализ с использованием Python, повторяя это несколько раз для консистентности и глубокой проверки.

    • Интеграция и настройки: Она интегрирует различные компоненты — от конфигураций Spring, настройки Gatling, до выполнения Python-скрипта — для полноценного тестового покрытия.

    Функция служит шаблоном для надежного и повторяющегося выполнения тестов и дополнительных действий, последовательно связывая их в единую автоматизированную последовательность.