from random import random
from lazy import lazy
from typing import List, Optional, Dict, Any
import core.logging.logger_constants as log_const
from core.logging.logger_utils import log
from core.model.factory import build_factory, list_factory, factory
from core.model.registered import Registered
from core.basic_models.operators.operators import Operator
from core.text_preprocessing.base import BaseTextPreprocessingResult
from core.model.base_user import BaseUser
from core.unified_template.unified_template import UnifiedTemplate
requirements = Registered()
requirement_factory = build_factory(requirements)
class Requirement:
# should_process_message compatible
def __init__(self,
items: Dict[str, Any],
id: Optional[str] = None) -> None:
items = items or {}
self.items = items
self.version = items.get("version", -1)
self.id = id
def _log_params(self):
return {
log_const.KEY_NAME: log_const.REQUIREMENT_CHECK_VALUE,
import core.logging.logger_constants as log_const
from core.basic_models.actions.basic_actions import Action
from core.basic_models.actions.command import Command
from core.basic_models.requirement.basic_requirements import Requirement
from core.model.factory import build_factory, list_factory
from core.model.factory import factory
from core.model.registered import Registered
from core.logging.logger_utils import log
import scenarios.logging.logger_constants as scenarios_log_const
scenarios = Registered()
scenario_factory = build_factory(scenarios)
class BaseScenario:
EMPTY_ANSWER_KEY = "default_empty_answer"
def __init__(self, items, id):
self._actions = items.get("actions")
self._availabe_requirement = items.get("availabe_requirement")
self._default_empty_answer = {"type": "external", "action": self.EMPTY_ANSWER_KEY}
self._empty_answer = items.get("empty_answer", self._default_empty_answer)
self.id = id
self.root_id = items.get("root_id", self.id)
self.scenario_description = items.get("scenario_description", "")
self.switched_off = items.get("switched_off", False)
self.version = items.get("version", -1)
# coding: utf-8
from lazy import lazy
from core.model.factory import ordered_dict_factory, build_factory
from core.model.registered import Registered
from scenarios.scenario_models.field.field_descriptions.field_description import FieldDescription
form_descriptions = Registered()
form_description_factory = build_factory(form_descriptions)
class BaseFormDescription:
DEFAULT_FORM_LIFETIME = 1 * 24 * 60 * 60
def __init__(self, items, id):
self.id = id
self.valid = items.get("valid", False)
self.lifetime = items.get("lifetime", self.DEFAULT_FORM_LIFETIME)
self.version = items.get("version", -1)
self.form_description = items.get("form_description", "")
class FormDescription(BaseFormDescription):
def __init__(self, items, id):
super(FormDescription, self).__init__(items, id)
self._fields = items["fields"]
@lazy
@ordered_dict_factory(FieldDescription)
def fields(self):
# coding: utf-8
from core.model.factory import build_factory
from core.model.registered import Registered
from core.monitoring.monitoring import monitoring
from core.utils.rerunable import Rerunable
db_adapters = Registered()
db_adapter_factory = build_factory(db_adapters)
class DBAdapterException(Exception):
pass
class DBAdapter(Rerunable):
IS_ASYNC = False
def __init__(self, config=None):
super(DBAdapter, self).__init__(config)
self._client = None
def _on_prepare(self):
raise NotImplementedError
def connect(self):
raise NotImplementedError
def _open(self, filename, *args, **kwargs):
raise NotImplementedError
def _save(self, id, data):
from core.model.factory import build_factory
from core.model.factory import list_factory
from core.model.registered import Registered
from core.utils.pickle_copy import pickle_deepcopy
from core.unified_template.unified_template import UnifiedTemplate
from core.text_preprocessing.preprocessing_result import TextPreprocessingResult
from core.model.factory import factory
from core.logging.logger_utils import log
from core.utils.exception_handlers import exc_handler
import scenarios.logging.logger_constants as log_const
from scenarios.user.user_model import User
field_filler_description = Registered()
field_filler_factory = build_factory(field_filler_description)
class FieldFillerDescription:
def __init__(self,
items: Optional[Dict[str, Any]],
id: Optional[str] = None) -> None:
items = items or {}
self.id = id
self.version = items.get("version", -1)
def _log_params(self):
return {
log_const.KEY_NAME: log_const.FILLER_EXTRACT_VALUE,
"filler": self.__class__.__name__
}
from typing import Dict, Any, NamedTuple, Union, List, TYPE_CHECKING
from core.model.factory import build_factory
from core.model.registered import Registered
if TYPE_CHECKING:
from scenarios.scenario_models.history import Event
formatters = Registered()
formatters_factory = build_factory(formatters)
class EventFormatter:
def __init__(self, *args, **kwargs):
pass
def format(
self,
events: List['Event']) -> List[Union[NamedTuple, Dict[str, Any]]]:
raise NotImplementedError
class HistoryEventFormatter(EventFormatter):
def format(self, events: List['Event']) -> List[Dict[str, Any]]:
result = []
for no, event in enumerate(events):
formatted_event = self._format_event(event)
formatted_event["no"] = no + 1
result.append(formatted_event)
return result
from core.model.factory import build_factory from core.model.registered import Registered vectorizers = Registered() vectorizer_factory = build_factory(vectorizers)
# coding: utf-8
from datetime import datetime
import time
from pythonjsonlogger import jsonlogger
from core.model.factory import build_factory
from core.model.registered import Registered
loggers_formatter = Registered()
loggers_formatter_factory = build_factory(loggers_formatter)
class SmartKitJsonFormatter(jsonlogger.JsonFormatter):
VERSION = 0
DEV_TEAM = "NA"
APPLICATION_NAME = "NA"
def add_fields(self, log_record, record, message_dict):
super(SmartKitJsonFormatter, self).add_fields(log_record, record,
message_dict)
dt = datetime.fromtimestamp(record.created)
st = dt.strftime("%Y-%m-%dT%H:%M:%S")
log_record['timestamp'] = "%s.%06d" % (st, record.msecs * 1000)
log_record['version'] = self.VERSION
log_record['team'] = self.DEV_TEAM
log_record['application'] = self.APPLICATION_NAME
if isinstance(record.args, dict):
log_record['args'] = record.args
# coding: utf-8
from typing import Union, Any, Dict, List, Optional
from core.basic_models.operators.comparators import MoreComparator, LessComparator, MoreOrEqualComparator, \
LessOrEqualComparator, EqualComparator, NotEqualComparator, InComparator, Comparator
from core.model.factory import build_factory, list_factory
from core.model.registered import Registered
operators = Registered()
operator_factory = build_factory(operators)
class Operator:
def __init__(self, items: Optional[Dict[str, Any]]) -> None:
pass
def compare(self, value: Any) -> bool:
raise NotImplementedError
class CompositeOperator(Operator):
operators: List[Operator]
def __init__(self, items: Optional[Dict[str, Any]]) -> None:
super(CompositeOperator, self).__init__(items)
self._operators: Dict[str, Any] = items["operators"]
self.operators = self.build_operators()
@list_factory(Operator)
def build_operators(self):
from lazy import lazy
from typing import Union, Dict, List, Any, Optional
import core.logging.logger_constants as log_const
from core.logging.logger_utils import log
from core.basic_models.requirement.basic_requirements import Requirement
from core.text_preprocessing.base import BaseTextPreprocessingResult
from core.model.base_user import BaseUser
from core.basic_models.actions.command import Command
from core.model.factory import build_factory, factory, list_factory
from core.model.registered import Registered
actions = Registered()
action_factory = build_factory(actions)
class Action:
version: Optional[int]
id: Optional[str]
def __init__(self, items: Dict[str, Any], id: Optional[str] = None):
items = items or {}
self.id = id
self.version = items.get("version", -1)
def run(self, user: BaseUser, text_preprocessing_result: BaseTextPreprocessingResult,
params: Optional[Dict[str, Union[str, float, int]]] = None) -> Optional[List[Command]]:
raise NotImplementedError
from abc import ABC, abstractmethod
from typing import Any, Dict, Optional, Union, List
import numpy as np
from lazy import lazy
from timeout_decorator import timeout_decorator
import core.basic_models.classifiers.classifiers_constants as cls_const
from core.model.factory import build_factory
from core.model.registered import Registered
from core.text_preprocessing.base import BaseTextPreprocessingResult
from core.utils.exception_handlers import exc_handler
classifiers = Registered()
classifier_factory = build_factory(classifiers)
class Classifier(ABC):
"""Базовый класс для сущности Классификатор."""
CLASSIFIER_TYPE = None
def __init__(self,
settings: Dict[str, Any],
id: Optional[str] = None) -> None:
self.id = id
self.settings = settings if settings else {}
self.version = settings.get("version", -1)
self.threshold = self.settings.get("threshold", 0)
self.intents = self.settings.get("intents", [])
from core.model.factory import build_factory
from core.model.registered import Registered
from core.utils.exception_handlers import exc_handler
import timeout_decorator
requests_registered = Registered()
request_factory = build_factory(requests_registered)
class BaseRequest:
BLOCKING_TIMEOUT = 0.2
DEFAULT_ENABLED = True
def __init__(self, items, id=None):
self.values = items
self.timeout = items.get("timeout")
self._timeout_wrap = timeout_decorator.timeout(
self.timeout or self.BLOCKING_TIMEOUT)
self._enabled = items.get(
"enabled", self.DEFAULT_ENABLED
) if items is not None else self.DEFAULT_ENABLED
@property
def group_key(self):
return None
def check_enabled(self):
return self._enabled
def update_empty_items(self, items):
pass
# coding: utf-8
from lazy import lazy
from core.basic_models.actions.basic_actions import Action
from core.basic_models.requirement.basic_requirements import Requirement
from core.model.factory import factory, list_factory, build_factory
from core.model.registered import Registered
from scenarios.scenario_models.field.field_filler_description import FieldFillerDescription
from scenarios.scenario_models.field_validator.field_validator import FieldValidator
field_descriptions = Registered()
field_description_factory = build_factory(field_descriptions)
class BasicFieldDescription:
DEFAULT_AVAILABLE_VALUE = True
def __init__(self, items, id):
self.id = id
self.name = id
self.type = items.get("type")
self._required = items.get("required", False)
self._filler = items.get("filler")
self.default_value = items.get("default_value")
self.available = items.get("available", self.DEFAULT_AVAILABLE_VALUE)
self._requests = items.get("requests", [])
self._on_filled_actions = items.get("on_filled_actions", [])
self._requirement = items.get("requirement")
self._field_validator = items.get("field_validator")
self.need_save_context = items.get("need_save_context", False)
# coding: utf-8
from typing import Dict, List, Optional, Any, Set
from core.basic_models.operators.operators import Operator
from core.model.factory import factory, build_factory, list_factory
from core.model.registered import Registered
field_requirements = Registered()
field_requirement_factory = build_factory(field_requirements)
class FieldRequirement:
def __init__(self, items: Optional[Dict[str, Any]]) -> None:
pass
def check(self, field_value: str, params: Dict[str, Any] = None) -> bool:
return True
class CompositeFieldRequirement(FieldRequirement):
requirements: List[FieldRequirement]
def __init__(self, items: Optional[Dict[str, Any]]) -> None:
super(CompositeFieldRequirement, self).__init__(items)
self._requirements: List[Dict[str, Any]] = items["requirements"]
self.requirements = self.build_requirements()
@list_factory(FieldRequirement)
def build_requirements(self):
return self._requirements
# coding: utf-8
from typing import Iterable, Dict, Any, Optional
from core.model.factory import build_factory
from core.model.registered import Registered
comparators = Registered()
comparator_factory = build_factory(comparators)
class Comparator:
def __init__(self, items: Optional[Dict[str, Any]]) -> None:
pass
def compare(self, left: Any, right: Any) -> bool:
raise NotImplementedError
class MoreComparator(Comparator):
def compare(self, left: int, right: int) -> bool:
return left > right
class LessComparator(Comparator):
def compare(self, left: int, right: int) -> bool:
return left < right
class MoreOrEqualComparator(Comparator):
def compare(self, left: int, right: int) -> bool:
from typing import Dict, Any, Optional
from core.basic_models.requirement.basic_requirements import Requirement
from core.model.factory import build_factory, factory
from core.model.registered import Registered
answer_items = Registered()
items_factory = build_factory(answer_items)
ANSWER_TO_USER = "******"
class SdkAnswerItem:
version: Optional[int]
id: Optional[str]
requirement: Requirement
def __init__(self, items: Dict[str, Any], id: Optional[str] = None):
items = items or {}
self.id = id
self.version = items.get("version", -1)
self._requirement = items.get("requirement", None)
self.requirement = self.build_requirement()
def render(self, nodes: Dict[str, Any]):
return {}
@factory(Requirement)
def build_requirement(self):
return self._requirement
