Дмитрий Шицков

Прежде чем всё это усложнять описанным вами способом, необходимо определиться с ожидаемыми количествами. Насколько много всего будет переменных, насколько много может быть этих объектов, какие ожидаются частоты этих ваших обращений.
Ещё нужно определиться как вы планируете редактировать наборы изменяемых переменных. Запишете прямо в БД руками, или нужно делать API для редактирования списков?
Вы собираетесь скрипт запускать при каждом поступлении новой порции данных? Может правильнее запустить его на ожидание порций из пайпа? Или АПИ сделать поверх http.

По существу вопроса. Минус хранимых процедур в том, что это код, который хранится вместе с данными. Нужно делать отдельные специфические "приседания", чтобы правильно деплоить и обновлять такой код, хранить его в системе контроля версий, мигрировать от версии к версии...
Быстродействие в обоих случаях будет зависеть от конкретных действий, которые вы будете каждый раз повторять при "обращениях". Однако при наличии "бутылочного горлышка" в этом месте при реализации через хранимые процедуры вы уже мало что там можете сделать. А вот в коде на питоне можно при необходимости добавить воркеров и таски на длительные операции передавать им через очередь.

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

Это все конечно очень хорошо, но в репе лежат симлинки вместо файлов. Так что пока оценка -10/10 - достигнут предельный радиус кривизны рук.

что значит "текстовый файл передаётся нормально"? Ты первые 2048 байт при приёме выбрасываешь же.

да никак, эта проблема решается постпарсерами. Вы отдаете им логи, а они неторопливо разрешают ip в fqdn

от 4760000 до 4809999

_893047[6-9]XXXX
_8930480XXXX

6500000 до 8999999

_89306[5-9]XXXXX
_8930[78]XXXXXX

Вот скрипт, который у меня периодически генерирует новый список экстеншинов региональных операторов для Asterisk в ael-формате.
https://github.com/Rsa97/Other/blob/main/asterisk/...

Для мониторинга нужно делать запрос к самому игровому серверу, используя valve a2s протокол. На python есть несколько библиотек, реализующих этот протокол: python-valve, python-a2s
Пример python-value:

import valve.source.a2s

SERVER_ADDRESS = (..., ...)

with valve.source.a2s.ServerQuerier(SERVER_ADDRESS) as server:
    info = server.info()
    players = server.players()

print("{player_count}/{max_players} {server_name}".format(**info))
for player in sorted(players["players"], key=lambda p: p["score"], reverse=True):
    print("{score} {name}".format(**player))

Пример python-a2s:

>>> import a2s
>>> address = ("stomping.kinofnemu.net", 27015)
>>> a2s.info(address)
SourceInfo(protocol=17, server_name=" 24/7 Dustbowl :: Nemu's Stomping Ground", map_name='cp_dustbowl',
folder='tf', game='Team Fortress', app_id=440, player_count=31, max_players=33, bot_count=21,
server_type='d', platform='l', password_protected=False, vac_enabled=True, version='5579073',
edf=177, port=27015, steam_id=85568392920040090, stv_port=None, stv_name=None,
keywords='brutus,celt,couch,cp,dustbowl,increased_maxplayers,nemu,nocrits,nodmgspread,pony,replays,vanilla',
game_id=440, ping=0.253798684978392)

>>> a2s.players(address)
[Player(index=0, name='Brutus', score=34, duration=836.4749145507812),
 Player(index=0, name='RageQuit', score=6, duration=1080.8099365234375),
 Player(index=0, name="Screamin' Eagles", score=1, duration=439.8598327636719)]

>>> a2s.rules(address)
{'coop': '0', 'deathmatch': '1', 'decalfrequency': '10', 'metamod_version': '1.10.7-devV',
 'mp_allowNPCs': '1', 'mp_autocrosshair': '1', 'mp_autoteambalance': '0', 'mp_disable_respawn_times': '0',
 'mp_fadetoblack': '0'}

confbridge.conf

[admin_menu]
...
*#=dialplan_exec(conf-invite,s,1)

extensions.conf

[conf-invite]
exten => s,1,Answer
same => n,Read(NUMBER,vm-enter-num-to-call)
same => n,Originate(SIP/${NUMBER},exten,conf-invite,conference,1)

exten => conference,1,Answer
same => n,ConfBridge(conference,bridge,simple-user,user_menu)

Это решается другим способом. Можно сделать готовый комплект конфигов (не только для vim), который в одну команду заливать на любой новый сервер (например, с помощью ansible). Круче vim всё равно мало что есть (пользуясь случаем, передаю большой привет emacs).

Можно вот так делать:
content = pathlib.Path('file').read_bytes()
В таком случае всё правильно закроется.
Вообще нужно стараться уже современные методы работы с файлами и путями использовать, а не доисторические.

Вы, кстати, самозакрывающуюся читалку и сами сделать можете:

def readfromfile(filename, mode='t'):
    assert mode in {'b', 't'}
    with open(filename, mode=mode) as f:
        return f.read()

Но зачем, когда есть замечательный pathlib в третьем питоне из коробки?

Ну и еще добавлю про незакрытие файлов.
В продакшн коде, который планирует жить долго, конечно нужно всё правильно закрывать, но если это у вас мелкий одноразовый скрипт, который не открывает миллионов файлов, то вполне можно забить на его закрытие. По завершении процесса (интерпретатора) все его дескрипторы будут высвобождены.

https://www.qt.io/

Может, загружается какой-нибудь крипто-майнер или что-то другое вычислительно тяжелое скриптами JS.
Может также потребляет много памяти.
Можно проверить в htop/top.

Есть не очень красивый вариант, но если нужно быстро решить задачу - можно использовать.
Если у вас нагрузка небольшая - можно его использовать на постоянной основе.
Если же нагрузка огромная - тогда надо иначе делать.
Только везде, где символ `_` надо сделать обработку ошибок.

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type TemplateCategory struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

type Template struct {
    Name         string            `json:"name"`
    CategoryInfo *TemplateCategory `json:"category_info"`
}

func (t *Template) UnmarshalJSON(b []byte) error {
    var result map[string]interface{}
    if err := json.Unmarshal(b, &result); err != nil {
        return err
    }

    if t == nil {
        t = &Template{}
    }
    t.Name, _ = result[`name`].(string)

    categoryInfo, isMap := result[`category_info`].(map[string]interface{})
    if isMap {
        t.CategoryInfo = &TemplateCategory{}
        t.CategoryInfo.ID, _ = categoryInfo[`id`].(int)
        t.CategoryInfo.Name, _ = categoryInfo[`name`].(string)
    }

    return nil
}

func main() {
    json1 := []byte(`{
        "name": "Мой шаблон",
        "category_info": {
            "id": 109,
            "name": "Тест"
        }
    }`)

    json2 := []byte(`{
        "name": "Мой шаблон",
        "category_info": []
    }`)

    var data1 Template
    err := json.Unmarshal(json1, &data1)
    if err != nil {
        log.Fatalf(`json1: %s`, err)
    }

    var data2 Template
    err = json.Unmarshal(json2, &data2)
    if err != nil {
        log.Fatalf(`json2: %s`, err)
    }

    fmt.Printf("data1: %+v\n", data1)
    fmt.Printf("data1.CategoryInfo: %+v\n\n", data1.CategoryInfo)

    fmt.Printf("\n\ndata2: %+v\n", data2)
    fmt.Printf("data2.CategoryInfo: %+v\n\n", data2.CategoryInfo)
}

Вывод:
data1: {Name:Мой шаблон CategoryInfo:0xc00000c0c0}
data1.CategoryInfo: &{ID:0 Name:Тест}

data2: {Name:Мой шаблон CategoryInfo:}
data2.CategoryInfo: