Sadmin/vector
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: ж/д слой + cant_swim в скоринг + профили вне модели

Browse Source 
Определение специфических рекомендаций (матрица профилей §8):

1. Ж/д слой (закрыт мёртвый railway ×2.5 у РАС):
   - /api/v1/water/{case_id} отдаёт railway=rail как LineString
     (без service/industrial/military веток), кэш общий v2;
   - railway_warning «перекрыть/проверить немедленно» по профилям;
   - SearchMap: Polyline слой ж/д (тёмно-красный), счётчики 💧/🚂.

2. cant_swim → профиль не_умеет_плавать (water ×3.0, без изменения
   радиуса, critical_warning «обследовать водоёмы НЕМЕДЛЕННО»):
   - раньше чекбокс влиял только на текст, в скоринге был пробел;
   - derive в analyze._derive_profiles — работает и для closed_cases.

3. unmodeled_profiles: ДЦП/слабое зрение/слух — честная пометка
   «вне поведенческой модели» с пояснением (vector_tasks B12:
   профили без аналога не выдавать за учтённые); блок на фронте
   в карточке здоровья.

Площадь воды: сферический эксцесс, проверен на квадрате 53° (744017 м²
vs 743272 точного). Тесты: 202 passed (новый test_cant_swim_profile).
This commit is contained in:
Viktor Antropov
2026-09-09 13:12:55 +03:00
parent 98e8e58023
commit f20080305d
2069 changed files with 803865 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.venv-test/lib/python3.12/site-packages/pygments/lexers/tact.py
+303
View File
@@ -0,0 +1,303 @@
"""
pygments.lexers.tact
~~~~~~~~~~~~~~~~~~~~
Lexers for Tact.
:copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
from pygments.lexer import RegexLexer, include, bygroups, words
from pygments.token import Comment, Operator, Keyword, Name, String, \
Number, Whitespace, Punctuation
__all__ = ['TactLexer']
class TactLexer(RegexLexer):
"""For Tact source code."""
name = 'Tact'
aliases = ['tact']
filenames = ['*.tact']
url = "https://tact-lang.org"
version_added = '2.18'
tokens = {
'root': [
(r'\s+', Whitespace),
(r'[.;(),\[\]{}]', Punctuation),
(r'\?|!!', Operator),
include('comments'),
include('import-in'),
include('struct-in'),
include('contract-or-trait-in'),
include('annotation-in'),
include('fun-declaration-in'),
include('const-declaration-in'),
include('statements'),
],
'import-in': [
(r'((?<=\.\.\.)|(?<![.$]))\b(import)\b(\s*)', bygroups(Punctuation, Keyword, Whitespace), 'import'),
],
'import': [
(r';', Punctuation, '#pop'),
include('comments'),
include('string-in'),
(r'\s+', Whitespace),
],
'struct-in': [
(r'((?<=\.\.\.)|(?<![.$]))\b(struct|message)\b', bygroups(Punctuation, Keyword), 'struct'),
],
'struct': [
include('comments'),
include('struct-header'),
include('struct-body-in'),
(r'\s+', Whitespace),
],
'struct-header': [
include('comments'),
(r'\b\w+', Name.Class),
(r'(\()((?:\b0[xX])[0-9a-fA-F][0-9a-fA-F_]*\b)(\))', bygroups(Punctuation, Number.Hex, Punctuation)),
(r'(\()((?:\b[0-9]+\b))(\))', bygroups(Punctuation, Number.Integer, Punctuation)),
],
'struct-body-in': [
(r'\{', Punctuation, 'struct-body'),
],
'struct-body': [
(r'\}', Punctuation, '#pop:2'),
include('comments'),
include('field-declaration-in'),
],
'contract-or-trait-in': [
(r'((?<=\.\.\.)|(?<![.$]))\b(contract|trait)\b', Keyword, 'contract-or-trait'),
],
'contract-or-trait': [
include('comments'),
(r'with', Keyword),
(r'\b\w+', Name.Class),
include('contract-or-trait-body-in'),
(r'\s+', Whitespace),
(r',', Punctuation),
],
'contract-or-trait-body-in': [
(r'\{', Punctuation, 'contract-or-trait-body'),
],
'contract-or-trait-body': [
(r'\}', Punctuation, '#pop:2'),
include('comments'),
include('init-declaration-in'),
include('receive-declaration-in'),
include('bounce-declaration-in'),
include('fun-declaration-in'),
include('const-declaration-in'),
include('field-declaration-in'),
(r'\s+', Whitespace),
],
'field-declaration-in': [
(r'\b\w+', Name.Property, 'field-declaration'),
],
'field-declaration': [
(r';', Punctuation, '#pop'),
include('comments'),
include('type-annotation-in'),
include('variable-init-in'),
],
'const-declaration-in': [
(r'(?=\b(?:(?:get|native|extends|mutates|virtual|override|inline|abstract)\s*)*const\b)', Keyword, 'const-declaration'),
],
'const-declaration': [
(r'(;)', Punctuation, '#pop'),
(r'const', Keyword),
(words(('get', 'native', 'extends', 'mutates', 'virtual', 'override', 'inline', 'abstract'), suffix=r'\b'), Keyword),
(r'\b\w+\b', Name.Constant),
include('comments'),
include('type-annotation-in'),
include('variable-init-in'),
(r'\s+', Whitespace),
],
'init-declaration-in': [
(r'(init)', Keyword, 'init-declaration')
],
'init-declaration': [
(r'(?<=\})', Punctuation, '#pop'),
include('comments'),
include('fun-arguments-in'),
include('block-declaration-in'),
(r'\s+', Whitespace),
],
'receive-declaration-in': [
(r'(receive|exernal)', Keyword, 'receive-declaration')
],
'receive-declaration': [
(r'(?<=\})', Punctuation, '#pop'),
include('comments'),
include('fun-arguments-in'),
include('block-declaration-in'),
],
'bounce-declaration-in': [
(r'(bounced)', Keyword, 'bounce-declaration')
],
'bounce-declaration': [
(r'(?<=\})', Punctuation, '#pop'),
include('comments'),
include('fun-arguments-in'),
include('block-declaration-in'),
],
'fun-declaration-in': [
(r'(?=\b(?:(?:get|native|extends|mutates|virtual|override|inline|abstract)\s*)*fun\b)', Keyword, 'fun-declaration')
],
'fun-declaration': [
(r'(?<=\}|\;)', Punctuation, '#pop'),
(r'fun', Keyword),
(r'\b(get|native|extends|mutates|virtual|override|inline|abstract)\b', Keyword),
(r'\b[\w]+', Name.Function),
include('fun-declaration-body'),
(r'[,;]', Punctuation),
],
'fun-declaration-body': [
include('comments'),
include('fun-arguments-in'),
include('type-annotation-in'),
include('block-declaration-in'),
(r'\s+', Whitespace),
],
'fun-arguments-in': [
(r'\(', Punctuation, 'fun-arguments'),
],
'fun-arguments': [
(r'\)', Punctuation, '#pop'),
include('comments'),
include('string-in'),
include('type-annotation-in'),
(r'(self)|(\b[\w]+\b)', bygroups(Name.Variable.Instance, Name.Variable)),
(r',', Punctuation),
(r'\s+', Whitespace),
],
'block-declaration-in': [
(r'\{', Punctuation, 'block-declaration')
],
'block-declaration': [
(r'\}', Punctuation, '#pop'),
include('statements'),
],
'statements': [
include('comments'),
include('block-declaration-in'),
include('expressions'),
],
'annotation-in': [
(r'(@)(\w+)(\()', bygroups(Keyword.Pseudo, Keyword, Punctuation), 'annotation')
],
'annotation': [
(r'\)', Punctuation, '#pop'),
include('annotation-argument'),
(r'\s+', Whitespace),
],
'annotation-argument': [
(r'\w+', Name.Function.Magic),
],
'expressions': [
include('comments'),
include('type-annotation-in'),
include('keywords'),
include('numeric'),
include('string-in'),
include('variable'),
include('function-call'),
include('struct-init-in'),
],
'struct-init-in': [
(r'(\b\w+)(\s*)(\{)', bygroups(Name.Class, Whitespace, Punctuation), 'struct-init')
],
'struct-init': [
(r'(\})', Punctuation, '#pop'),
include('comments'),
include('struct-property-in'),
(r'\s+', Whitespace),
(r',', Punctuation),
],
'struct-property-in': [
(r'(\b[\w]+)(\s*)(:)', bygroups(Name.Property, Whitespace, Punctuation), 'struct-property')
],
'struct-property': [
(r'(?=\}|\,)', Punctuation, '#pop'),
include('comments'),
include('expressions'),
(r'\s+', Whitespace),
],
'variable-init-in': [
(r'(=)', Operator, 'variable-init')
],
'variable-init': [
(r'(?=\}|\{|\,|\;)',Punctuation, '#pop'),
include('comments'),
include('expressions'),
(r'\s+', Whitespace),
],
'type-annotation-in': [
(r'(:)(\s+)', bygroups(Punctuation, Whitespace), 'type-annotation')
],
'type-annotation': [
(r'(?=\{|\;|\=|\,|\))', Punctuation, '#pop'),
include('comments'),
include('type-as-in'),
include('type-generic-in'),
(r'\?', Operator),
(r'\b\w+', Keyword.Type),
(r'\s+', Whitespace),
],
'type-generic-in': [
(r'<', Punctuation, 'type-generic'),
],
'type-generic': [
(r'>', Punctuation, '#pop'),
include('comments'),
include('type-as-in'),
(r'\b\w+', Keyword.Type),
(r'\s+', Whitespace),
(r',', Punctuation),
],
'type-as-in': [
(r'\b(as)(\s+)', bygroups(Keyword, Whitespace), 'type-as'),
],
'type-as': [
(r'(?=\{|\;|\=|\,|\)|\>)', Punctuation, '#pop'),
include('comments'),
(r'\b\w+', Keyword.Type),
(r'\s+', Whitespace),
],
'keywords': [
(words(('if', 'else', 'while', 'do', 'until', 'repeat', 'return', 'extends', 'mutates', 'virtual', 'override', 'inline', 'native', 'let', 'const', 'fun', 'self', 'is', 'initOf', 'map', 'bounced', 'get', 'as'), prefix=r'\b', suffix=r'\b'), Keyword),
(r'(<=>|>=|<=|!=|==|\^>>|~>>|>>|<<|\/%|\^%|~%|\^\/|~\/|\+=|-=|\*=|\/=|~\/=|\^\/=|%=|\^%=|<<=|>>=|~>>=|\^>>=|&=|\|=|\^=|\^|=|~|\/|%|-|\*|\+|>|<|&|\||:|\?)', Operator),
(words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
],
'string-in': [
(r'"', String, 'string'),
],
'string': [
(r'"', String, '#pop'),
(r'\\.', String.Escape),
(r'[^\\"]+', String.Double),
],
'numeric': [
(r'(?:\b0[xX])[0-9a-fA-F][0-9a-fA-F_]*\b', Number.Hex),
(r'(?:\b[0-9]+\b)', Number.Integer),
],
'comments': [
(r'//.*', Comment.Single),
(r'/\*', Comment.Multiline, 'comments-multiline'),
],
'comments-multiline': [
(r'\*/', Comment.Multiline, '#pop'),
(r'[^*]+', Comment.Multiline),
(r'[*]', Comment.Multiline),
],
'variable': [
(r'\b\w+\b(?!\s*\()(?!\s*\{)', Name.Variable)
],
'function-call': [
(r'\b\w+\b(?=\s*\()(?!\s*\{)', Name.Function)
],
}