common/forms/task/BaseTaskForm.php - dev - v.bolshakov/AIEcosystem-Testing

common/forms/task/BaseTaskForm.php
282 строки7 KB
Developer
Initial commit
03 авг 2026, 17:43
03 авг 2026, 17:437433917
<?php

namespace common\forms\task;

use common\forms\base\BaseModel;
use common\jobs\AiJobRequest;
use common\kdf\KSystem;
use common\models\Request;
use common\models\RequestBatch;
use common\models\RequestSegment;
use common\models\TextSegment;
use TikToken\Encoder;
use Yii;
use yii\base\InvalidConfigException;

/**
 * Базовая форма запроса
 *
 * @author Dmitry E. Semenov <sde.tomsk@gmail.com>
 * @copyright Self (c) 2024
 */
abstract class BaseTaskForm extends BaseModel
{
    /**
     * Идентификатор пользователя
     * @var null
     */
    public $user_id = null;

    /**
     * user task ID
     * @var string
     */
    public $task_id = null;

    /**
     * user subject-area ID
     * @var string
     */
    public $subject_area_id = null;

    /**
     * Source language
     * @var string
     */
    public $source_language_id = null;

    /**
     * Translation language
     * @var string
     */
    public $target_language_id = null;

    /**
     * @var null
     */
    public $system_id = KSystem::MEMOQ;

    /**
     * The source text for the work
     * @var array
     */
    public $text = [];

    /**
     * Дополнительный массив опций
     * @var array
     */
    public $options = [];

    /**
     * Время выполнения
     * @var null
     */
    private $start_at = null;

    /**
     * Класс запроса к AI
     * @var null
     */
    protected $request_class = null;

    /**
     * Режим отладки
     * @var int
     */
    protected $is_debug = 0;

    /**
     * Количество токенов
     * @var int
     */
    private $tokens = 0;

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [
            [['subject_area_id', 'source_language_id', 'target_language_id'], 'default', 'value' => -1],
            [['task_id', 'subject_area_id', 'source_language_id', 'target_language_id'], 'required'],
            [
                [
                    'task_id',
                    'user_id',
                    'subject_area_id',
                    'source_language_id',
                    'target_language_id',
                ],
                'number'
            ],
            [
                [
                    'text'
                ],
                'safe'
            ],
        ];
    }

    /**
     * @inheritdoc
     */
    protected function doSave()
    {
        $r = new Request([
            'user_id'            => $this->user_id,
            'task_id'            => $this->task_id,
            'subject_area_id'    => $this->subject_area_id,
            'source_language_id' => $this->source_language_id,
            'target_language_id' => $this->target_language_id,
            'system_id'          => $this->system_id,
            'is_debug'           => (int)$this->is_debug
        ]);

        if (!$r->save()) {
            $this->addErrors($r->errors);

            return false;
        }

        $result = [];
        $batch_index = 1;
        $token_limit = $r->getModelLimit();
        $s_token_split = 0;
        $this->tokens = 0;

        // формируем batch массив
        foreach ((array)$this->text as $index => $item) {

            $encoder = new Encoder();
            $tokens = $encoder->encode($item);
            $token_count = count($tokens);
            $token_split = ceil($token_count * 0.7);
            $this->tokens += $token_count;

            if (($s_token_split + $token_split) >= $token_limit) {
                $s_token_split = 0;
                $batch_index++;
            }

            $result[$batch_index][] = [
                'index'       => $index,
                'segment'     => $item,
                'token_count' => $token_count,
                'token_split' => $token_split
            ];

            $s_token_split += $token_split;
        }

        foreach ($result as $index => $batch) {
            $rb = new RequestBatch([
                'request_id'  => $r->id,
                'batch_index' => $index,
            ]);

            if (!$rb->save()) {
                $this->addErrors($rb->errors);

                return false;
            }

            $s_token_count = 0;

            foreach ($batch as $row) {
                $segment = new TextSegment([
                    'segment' => $row['segment'],
                ]);

                if (!$segment->save()) {
                    $this->addErrors($segment->errors);

                    return false;
                }

                $rs = new RequestSegment([
                    'request_id'    => $r->id,
                    'batch_id'      => $rb->id,
                    'segment_index' => $row['index'],
                    'token_count'   => $row['token_count'],
                    'segment_id'    => $segment->id
                ]);

                if (!$rs->save()) {
                    $this->addErrors($rs->errors);

                    return false;
                }
                $s_token_count += $rs->token_count;
            }
            $rb->updateAttributes([
                'token_count' => $s_token_count
            ]);
        }

        $this->model = $r;

        return true;
    }

    /**
     * @inheritdoc
     */
    protected function beforeSave()
    {
        $this->start_at = microtime(true);

        return parent::beforeSave(); // TODO: Change the autogenerated stub
    }

    /**
     * @inheritdoc
     */
    protected function afterSave($result)
    {
        parent::afterSave($result); // TODO: Change the autogenerated stub

        if ($result) {

            if (!$this->request_class) {
                throw new InvalidConfigException(Yii::t('app', 'Request class required'));
            }

            /** @var Request $request */
            $request = $this->model;

            $job = new AiJobRequest([
                'request_id'    => $request->id,
                'options'       => $this->options,
                'request_class' => $this->request_class
            ]);

            /** @var \common\components\Queue $queue */
            $queue = Yii::$app->queue;
            $queue_id = $queue->push($job);

            // Общее время выполнения
            $done = microtime(true) - $this->start_at;

            Request::updateAll([
                'time_spent' => $done,
                'queue_id'   => $queue_id
            ], [
                'id' => $request->id
            ]);

            $this->model = [];

            $time_wait = ($this->tokens / 40) + 10;

            $this->model['id'] = $request->guid;
            $this->model['time_spent'] = $done;
            $this->model['time_wait'] = $time_wait;

            if (YII_DEBUG) {
                $this->model['queue_id'] = $queue_id;
            }
        }
    }
}