def test_repository(self): registered_repositories = Registered() obj = object() registered_repositories["test"] = obj self.assertEqual(registered_repositories["test"], obj) obj1 = object() registered_repositories["test"] = obj1 self.assertEqual(registered_repositories["test"], obj1)
def __init__(self, **kwargs): self.registered_repositories = Registered() self.repositories = [] self.source = kwargs.get("source")
import core.logging.logger_constants as core_log_const from core.text_preprocessing.base import BaseTextPreprocessingResult 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,
# 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.registered import Registered vectorizers = Registered() vectorizer_factory = build_factory(vectorizers)
# 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:
import time from core.model.registered import Registered from scenarios.scenario_models.field.field import field_model_factory from scenarios.scenario_models.field.fields import Fields form_models = Registered() def form_model_factory(value, description, user): _type = type(description) model = form_models[_type] return model(value, description, user) class BaseForm: def __init__(self, items, description, user): items = items or {} self.description = description self._valid = self.description.valid self._user = user self.remove_time = items.get("remove_time") def touch(self): lifetime = self.description.lifetime if lifetime: self.remove_time = int(time.time()) + lifetime def check_expired(self): return time.time() >= self.remove_time if self.remove_time else False
# 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 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
import pickle import sys 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)
import random 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 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)
from core.model.registered import Registered from smart_kit.message.smartapp_to_message import SmartAppToMessage to_messages = Registered() def get_to_message(command_name): default = SmartAppToMessage return to_messages.get(command_name, default)
# 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 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 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", "")
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
# coding: utf-8 from typing import Dict, Callable from core.descriptions.lazy_descriptions import LazyDescriptions from core.model.registered import Registered from core.repositories.base_repository import BaseRepository registered_description_factories = Registered() def default_description_factory(x): return x class Descriptions: def __init__(self, registered_repositories: Dict[str, BaseRepository]) -> None: self.registered_repositories: Dict[ str, BaseRepository] = registered_repositories self._descriptions: Dict[str, LazyDescriptions] = {} def __getitem__(self, key: str) -> LazyDescriptions: description_item: LazyDescriptions = self._descriptions.get(key) if description_item is None: repository: BaseRepository = self.registered_repositories[key] factory: Callable = registered_description_factories.get( key, default_description_factory) description_item = factory(repository.data) self._descriptions[key] = description_item return description_item
# coding: utf-8 from core.logging.logger_utils import log from core.model.registered import Registered import scenarios.logging.logger_constants as log_const field_models = Registered() def field_model_factory(description, raw_data, user, lifetime): _type = type(description) model = field_models[_type] instance = model(description, raw_data, user, lifetime) return instance class Field: def __init__(self, description, items, user, lifetime): items = items or {} self.description = description self._value = items.get("value") self._available = items.get("available", self.description.available) self._user = user self._lifetime = lifetime def check_can_be_filled(self, text_preprocessing_result, user): return (self.description.requirement.check( text_preprocessing_result, user) and self.description.filler.run( user, text_preprocessing_result) is not None) def fill(self, origin_value): filled = False
# coding: utf-8 import hashlib 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):
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