Vorkout/core
4
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat: all models

Browse Source
This commit is contained in:
TheNoxium
2025-09-26 14:59:59 +05:00
parent 5bae8b41b2
commit 8e01072ff6
26 changed files with 1464 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
nodes/vork_node_callback.py
View File

@@ -1,18 +1,73 @@
from typing import Dict, Any
import requests
import json
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_callback_models import (
CallbackNodeData,
CallbackNodeLinks,
CallbackNodeCoreSchema,
CallbackNodeCoreSchemaData
)
class VorkNodeCallback(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла callback
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_callback"
return "CALLBACK"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Callback
"""
return get_form_descriptor("CALLBACK")
def validate(self) -> bool:
return True
def validate(self) -> CallbackNodeCoreSchema:
"""
Валидирует данные узла callback и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
node_data = CallbackNodeCoreSchemaData(
then_port_number=0
)
# Создаем схему с валидированными данными
return CallbackNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Callback node validation error: {e}")
raise
def validate_data(self) -> CallbackNodeData:
"""
Валидирует данные узла callback
"""
return CallbackNodeData(**self.data)
def validate_links(self) -> CallbackNodeLinks:
"""
Валидирует связи узла callback
"""
return CallbackNodeLinks(**self.links)
def process(self, context):
pass

65
nodes/vork_node_each.py
View File

@@ -1,18 +1,73 @@
from typing import Dict, Any
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_each_models import (
EachNodeData,
EachNodeLinks,
EachNodeCoreSchema,
EachNodeCoreSchemaData
)
class VorkNodeEach(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла each
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_each"
return "EACH"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Each
"""
return get_form_descriptor("EACH")
def validate(self) -> bool:
return True
def validate(self) -> EachNodeCoreSchema:
"""
Валидирует данные узла each и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
# Создаем данные портов (аналогично if)
node_data = EachNodeCoreSchemaData(
then_port_number=0,
else_port_number=1,
)
# Создаем схему с валидированными данными
return EachNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Each node validation error: {e}")
raise
def validate_data(self) -> EachNodeData:
"""
Валидирует данные узла each
"""
return EachNodeData(**self.data)
def validate_links(self) -> EachNodeLinks:
"""
Валидирует связи узла each
"""
return EachNodeLinks(**self.links)
def process(self, context):
pass

17
nodes/vork_node_if.py
View File

@@ -1,11 +1,11 @@
from typing import Dict, Any
from typing import Any, Dict
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_if_models import (
IfNodeData,
IfNodeLinks,
IfNodeCoreSchema,
IfNodeCoreSchemaData,
IfNodeDescriptor
IfNodeCoreSchemaData
)
@@ -16,8 +16,11 @@ class VorkNodeIf(VorkNode):
return "IF"
@classmethod
def form(cls) -> IfNodeDescriptor:
return IfNodeDescriptor()
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла IF
"""
return get_form_descriptor("IF")
def validate(self) -> IfNodeCoreSchema:
"""
@@ -58,5 +61,5 @@ class VorkNodeIf(VorkNode):
return IfNodeLinks(**self.links)
def process(self, context: Any) -> bool:
return True
def process(self, context):
pass

65
nodes/vork_node_listen.py
View File

@@ -1,25 +1,72 @@
from typing import Dict, Any
from core import VorkNode
# from model_nodes.node_listen_models import (
# ListenNodeData,
# ListenNodeLinks,
# ListenNodePSNodeCore,
# ListenNodeSettingsDataCore
# )
from core.form_descriptors import get_form_descriptor
from model_nodes.node_listen_models import (
ListenNodeData,
ListenNodeLinks,
ListenNodeCoreSchema,
ListenNodeCoreSchemaData
)
class VorkNodeListen(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла listen
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "LISTEN"
@classmethod
def form(cls) -> Dict[str, Any]:
return cls.get_schema()
"""
Возвращает статический дескриптор формы для узла Listen
"""
return get_form_descriptor("LISTEN")
def validate(self) -> bool:
return True
def validate(self) -> ListenNodeCoreSchema:
"""
Валидирует данные узла listen и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
node_data = ListenNodeCoreSchemaData(
then_port_number=0,
is_start=validated_data.is_start
)
# Создаем схему с валидированными данными
return ListenNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Listen node validation error: {e}")
raise
def validate_data(self) -> ListenNodeData:
"""
Валидирует данные узла listen
"""
return ListenNodeData(**self.data)
def validate_links(self) -> ListenNodeLinks:
"""
Валидирует связи узла listen
"""
return ListenNodeLinks(**self.links)
def process(self, context):
pass

67
nodes/vork_node_run.py
View File

@@ -1,18 +1,75 @@
from typing import Dict, Any
import json
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_run_models import (
RunNodeData,
RunNodeLinks,
RunNodeCoreSchema,
RunNodeCoreSchemaData
)
class VorkNodeRun(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла run
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_run"
return "RUN"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Run
"""
return get_form_descriptor("RUN")
def validate(self) -> bool:
return True
def validate(self) -> RunNodeCoreSchema:
"""
Валидирует данные узла run и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
node_data = RunNodeCoreSchemaData(
then_port_number=0
)
# Создаем схему с валидированными данными
return RunNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Run node validation error: {e}")
raise
def validate_data(self) -> RunNodeData:
"""
Валидирует данные узла run
"""
return RunNodeData(**self.data)
def validate_links(self) -> RunNodeLinks:
"""
Валидирует связи узла run
"""
return RunNodeLinks(**self.links)
def process(self, context):
"""
Обрабатывает логику узла run - выполнение встроенной задачи
"""
pass

64
nodes/vork_node_set.py
View File

@@ -1,18 +1,72 @@
from typing import Dict, Any
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_set_models import (
SetNodeData,
SetNodeLinks,
SetNodeCoreSchema,
SetNodeCoreSchemaData
)
class VorkNodeSet(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла set
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_set"
return "SET"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Set
"""
return get_form_descriptor("SET")
def validate(self) -> bool:
return True
def validate(self) -> SetNodeCoreSchema:
"""
Валидирует данные узла set и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
# Создаем данные портов
node_data = SetNodeCoreSchemaData(
then_port_number=0,
)
# Создаем схему с валидированными данными
return SetNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Set node validation error: {e}")
raise
def validate_data(self) -> SetNodeData:
"""
Валидирует данные узла set
"""
return SetNodeData(**self.data)
def validate_links(self) -> SetNodeLinks:
"""
Валидирует связи узла set
"""
return SetNodeLinks(**self.links)
def process(self, context):
pass

65
nodes/vork_node_switch.py
View File

@@ -1,18 +1,73 @@
from typing import Dict, Any
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_switch_models import (
SwitchNodeData,
SwitchNodeLinks,
SwitchNodeCoreSchema,
SwitchNodeCoreSchemaData
)
class VorkNodeSwitch(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла switch
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_switch"
return "SWITCH"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Switch
"""
return get_form_descriptor("SWITCH")
def validate(self) -> bool:
return True
def validate(self) -> SwitchNodeCoreSchema:
"""
Валидирует данные узла switch и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
# Создаем данные портов (default=0, case_1=1)
node_data = SwitchNodeCoreSchemaData(
default_port_number=0,
case_1_port_number=1,
)
# Создаем схему с валидированными данными
return SwitchNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Switch node validation error: {e}")
raise
def validate_data(self) -> SwitchNodeData:
"""
Валидирует данные узла switch
"""
return SwitchNodeData(**self.data)
def validate_links(self) -> SwitchNodeLinks:
"""
Валидирует связи узла switch
"""
return SwitchNodeLinks(**self.links)
def process(self, context):
pass

63
nodes/vork_node_trigger.py
View File

@@ -1,18 +1,71 @@
from typing import Dict, Any
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_trigger_models import (
TriggerNodeData,
TriggerNodeLinks,
TriggerNodeCoreSchema,
TriggerNodeCoreSchemaData
)
class VorkNodeTrigger(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла trigger
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_trigger"
return "TRIGGER"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Trigger
"""
return get_form_descriptor("TRIGGER")
def validate(self) -> bool:
return True
def validate(self) -> TriggerNodeCoreSchema:
"""
Валидирует данные узла trigger и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
node_data = TriggerNodeCoreSchemaData(
then_port_number=0
)
# Создаем схему с валидированными данными
return TriggerNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Trigger node validation error: {e}")
raise
def validate_data(self) -> TriggerNodeData:
"""
Валидирует данные узла trigger
"""
return TriggerNodeData(**self.data)
def validate_links(self) -> TriggerNodeLinks:
"""
Валидирует связи узла trigger
"""
return TriggerNodeLinks(**self.links)
def process(self, context):
pass

64
nodes/vork_node_wait.py
View File

@@ -1,18 +1,72 @@
from typing import Dict, Any
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_wait_models import (
WaitNodeData,
WaitNodeLinks,
WaitNodeCoreSchema,
WaitNodeCoreSchemaData
)
class VorkNodeWait(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла wait
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_wait"
return "WAIT"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла Wait
"""
return get_form_descriptor("WAIT")
def validate(self) -> bool:
return True
def validate(self) -> WaitNodeCoreSchema:
"""
Валидирует данные узла wait и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
# Создаем данные портов
node_data = WaitNodeCoreSchemaData(
then_port_number=0,
)
# Создаем схему с валидированными данными
return WaitNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"Wait node validation error: {e}")
raise
def validate_data(self) -> WaitNodeData:
"""
Валидирует данные узла wait
"""
return WaitNodeData(**self.data)
def validate_links(self) -> WaitNodeLinks:
"""
Валидирует связи узла wait
"""
return WaitNodeLinks(**self.links)
def process(self, context):
pass

65
nodes/vork_node_while.py
View File

@@ -1,18 +1,73 @@
from typing import Dict, Any
from core import VorkNode
from core.form_descriptors import get_form_descriptor
from model_nodes.node_while_models import (
WhileNodeData,
WhileNodeLinks,
WhileNodeCoreSchema,
WhileNodeCoreSchemaData
)
class VorkNodeWhile(VorkNode):
def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
"""
Инициализация узла while
"""
super().__init__(data, links or {})
@property
def id(self) -> str:
return "node_while"
return "WHILE"
@classmethod
def form(cls):
pass
def form(cls) -> Dict[str, Any]:
"""
Возвращает статический дескриптор формы для узла While
"""
return get_form_descriptor("WHILE")
def validate(self) -> bool:
return True
def validate(self) -> WhileNodeCoreSchema:
"""
Валидирует данные узла while и возвращает схему
"""
try:
# Валидируем данные узла
validated_data = self.validate_data()
# Валидируем связи узла
validated_links = self.validate_links()
# Создаем данные портов (аналогично if)
node_data = WhileNodeCoreSchemaData(
then_port_number=0,
else_port_number=1,
)
# Создаем схему с валидированными данными
return WhileNodeCoreSchema(
ps_id=validated_data.ps_id,
node_type=validated_data.node_type,
parent_id=validated_links.parent_id,
parent_port_number=validated_links.parent_port_number,
data=node_data
)
except Exception as e:
print(f"While node validation error: {e}")
raise
def validate_data(self) -> WhileNodeData:
"""
Валидирует данные узла while
"""
return WhileNodeData(**self.data)
def validate_links(self) -> WhileNodeLinks:
"""
Валидирует связи узла while
"""
return WhileNodeLinks(**self.links)
def process(self, context):
pass