async def generate(
self,
template_name: Text,
tracker: DialogueStateTracker,
output_channel: Text,
**kwargs: Any,
) -> Optional[Dict[Text, Any]]:
"""Generate a response for the requested template."""
filled_slots = tracker.current_slot_values()
fallback_language_slot = tracker.slots.get("fallback_language")
fallback_language = (fallback_language_slot.initial_value
if fallback_language_slot else None)
language = tracker.latest_message.metadata.get(
"language") or fallback_language
if "fallback_language" in kwargs:
del kwargs["fallback_language"]
message = self.generate_from_slots(
template_name,
filled_slots,
output_channel,
**kwargs,
language=language,
fallback_language=fallback_language,
)
if "language" in message:
del message["language"]
rewrite_url(message, self.url_substitution_patterns)
metadata = message.pop("metadata", {}) or {}
for key in metadata:
message[key] = metadata[key]
return message
async def generate(
self,
utter_action: Text,
tracker: DialogueStateTracker,
output_channel: Text,
**kwargs: Any,
) -> Optional[Dict[Text, Any]]:
"""Generate a response for the requested utter action."""
filled_slots = tracker.current_slot_values()
return self.generate_from_slots(utter_action, filled_slots,
output_channel, **kwargs)
async def generate(
self,
template_name: Text,
tracker: DialogueStateTracker,
output_channel: Text,
**kwargs: Any,
) -> List[Dict[Text, Any]]:
fallback_language_slot = tracker.slots.get("fallback_language")
fallback_language = (fallback_language_slot.initial_value
if fallback_language_slot else None)
language = tracker.latest_message.metadata.get(
"language") or fallback_language
body = nlg_request_format(
template_name,
tracker,
output_channel,
**kwargs,
language=language,
projectId=os.environ.get("BF_PROJECT_ID"),
)
logger.debug("Requesting NLG for {} from {}."
"".format(template_name, self.nlg_endpoint.url))
try:
if "graphql" in self.nlg_endpoint.url:
from sgqlc.endpoint.http import HTTPEndpoint
logging.getLogger("sgqlc.endpoint.http").setLevel(
logging.WARNING)
api_key = os.environ.get("API_KEY")
headers = [{"Authorization": api_key}] if api_key else []
response = HTTPEndpoint(self.nlg_endpoint.url,
*headers)(NLG_QUERY, body)
if response.get("errors"):
raise urllib.error.URLError(", ".join(
[e.get("message") for e in response.get("errors")]))
response = response.get("data", {}).get("getResponse", {})
rewrite_url(response, self.url_substitution_patterns)
if "customText" in response:
response["text"] = response.pop("customText")
if "customImage" in response:
response["image"] = response.pop("customImage")
if "customQuickReplies" in response:
response["quick_replies"] = response.pop(
"customQuickReplies")
if "customButtons" in response:
response["buttons"] = response.pop("customButtons")
if "customElements" in response:
response["elements"] = response.pop("customElements")
if "customAttachment" in response:
response["attachment"] = response.pop("customAttachment")
metadata = response.pop("metadata", {}) or {}
for key in metadata:
response[key] = metadata[key]
keys_to_interpolate = [
"text",
"image",
"custom",
"buttons",
"attachment",
"quick_replies",
]
for key in keys_to_interpolate:
if key in response:
response[key] = interpolate(
response[key], tracker.current_slot_values())
else:
response = await self.nlg_endpoint.request(
method="post", json=body, timeout=DEFAULT_REQUEST_TIMEOUT)
response = response[
0] # legacy route, use first message in seq
except urllib.error.URLError as e:
message = e.reason
logger.error(
f"NLG web endpoint at {self.nlg_endpoint.url} returned errors: {message}"
)
return {"text": template_name}
if self.validate_response(response):
return response
else:
logger.error(
f"NLG web endpoint at {self.nlg_endpoint.url} returned an invalid response."
)
return {"text": template_name}
