dream

1
#!/usr/bin/env python
2

3
import logging
4
import time
5
import os
6
import random
7

8
from flask import Flask, request, jsonify
9
from healthcheck import HealthCheck
10
import sentry_sdk
11
from sentry_sdk.integrations.logging import ignore_logger
12

13

14
import common.dialogflow_framework.utils.dialogflow as dialogflow_utils
15
import common.dialogflow_framework.programy.text_preprocessing as text_utils
16
import dialogflows.main as main_dialogflow
17
import test_server
18

19
ignore_logger("root")
20

21
sentry_sdk.init(os.getenv("SENTRY_DSN"))
22
SERVICE_NAME = os.getenv("SERVICE_NAME")
23
SERVICE_PORT = int(os.getenv("SERVICE_PORT"))
24
RANDOM_SEED = int(os.getenv("RANDOM_SEED", 2718))
25

26
logging.basicConfig(format="%(asctime)s - %(pathname)s - %(lineno)d - %(levelname)s - %(message)s", level=logging.INFO)
27
logger = logging.getLogger(__name__)
28

29

30
app = Flask(__name__)
31
health = HealthCheck(app, "/healthcheck")
32
logging.getLogger("werkzeug").setLevel("WARNING")
33

34
DF = main_dialogflow.composite_dialogflow
35

36

37
def handler(requested_data, random_seed=None):
38
    st_time = time.time()
39
    dialog_batch = requested_data.get("dialog_batch", [])
40
    human_utter_index_batch = requested_data.get("human_utter_index_batch", [0] * len(dialog_batch))
41
    state_batch = requested_data.get(f"{SERVICE_NAME}_state_batch", [{}] * len(dialog_batch))
42
    dff_shared_state_batch = requested_data.get(f"dff_shared_state_batch", [{}] * len(dialog_batch))
43
    entities_batch = requested_data.get("entities_batch", [{}] * len(dialog_batch))
44
    used_links_batch = requested_data.get("used_links_batch", [{}] * len(dialog_batch))
45
    age_group_batch = requested_data.get("age_group_batch", [""] * len(dialog_batch))
46
    disliked_skills_batch = requested_data.get("disliked_skills_batch", [{}] * len(dialog_batch))
47
    clarification_request_flag_batch = requested_data.get(
48
        "clarification_request_flag_batch", [False] * len(dialog_batch)
49
    )
50
    random_seed = requested_data.get("random_seed", random_seed)  # for tests
51

52
    responses = []
53
    for (
54
        human_utter_index,
55
        dialog,
56
        state,
57
        dff_shared_state,
58
        entities,
59
        used_links,
60
        age_group,
61
        disliked_skills,
62
        clarification_request_flag,
63
    ) in zip(
64
        human_utter_index_batch,
65
        dialog_batch,
66
        state_batch,
67
        dff_shared_state_batch,
68
        entities_batch,
69
        used_links_batch,
70
        age_group_batch,
71
        disliked_skills_batch,
72
        clarification_request_flag_batch,
73
    ):
74
        try:
75
            # for tests
76
            if random_seed:
77
                random.seed(int(random_seed))
78

79
            text = dialog["human_utterances"][-1]["text"]
80
            text = text_utils.clean_text(text)
81

82
            dialogflow_utils.load_into_dialogflow(
83
                DF,
84
                human_utter_index,
85
                dialog,
86
                state,
87
                dff_shared_state,
88
                entities,
89
                used_links,
90
                age_group,
91
                disliked_skills,
92
                clarification_request_flag,
93
            )
94
            text, confidence, can_continue = dialogflow_utils.run_turn(DF, text)
95
            (
96
                state,
97
                dff_shared_state,
98
                used_links,
99
                age_group,
100
                disliked_skills,
101
                response_parts,
102
            ) = dialogflow_utils.get_dialog_state(DF)
103

104
            human_attr = {
105
                f"{SERVICE_NAME}_state": state,
106
                "dff_shared_state": dff_shared_state,
107
                "used_links": used_links,
108
                "age_group": age_group,
109
                "disliked_skills": disliked_skills,
110
            }
111
            hype_attr = {"can_continue": can_continue}
112
            if response_parts:
113
                hype_attr["response_parts"] = response_parts
114

115
            responses.append((text, confidence, human_attr, {}, hype_attr))
116
        except Exception as exc:
117
            sentry_sdk.capture_exception(exc)
118
            logger.exception(exc)
119
            responses.append(("", 0.0, {}, {}, {}))
120

121
    total_time = time.time() - st_time
122
    logger.info(f"{SERVICE_NAME} exec time = {total_time:.3f}s")
123
    return responses
124

125

126
try:
127
    test_server.run_test(handler)
128
    logger.info("test query processed")
129
except Exception as exc:
130
    sentry_sdk.capture_exception(exc)
131
    logger.exception(exc)
132
    raise exc
133

134
logger.info(f"{SERVICE_NAME} is loaded and ready")
135

136

137
@app.route("/respond", methods=["POST"])
138
def respond():
139
    # import common.test_utils as t_utils; t_utils.save_to_test(request.json,"tests/lets_talk_in.json",indent=4)  # TEST
140
    # responses = handler(request.json, RANDOM_SEED)  # TEST
141
    # import common.test_utils as t_utils; t_utils.save_to_test(responses,"tests/lets_talk_out.json",indent=4)  # TEST
142
    responses = handler(request.json)
143
    return jsonify(responses)
144

145

146
if __name__ == "__main__":
147
    app.run(debug=False, host="0.0.0.0", port=SERVICE_PORT)
148