async def handler(request):
async def streaming(response):
while True:
body = await request.stream.get()
if body is None:
break
body = body.decode('utf-8').replace('1', 'A')
await response.write(body)
return stream(streaming)
async def put(request):
assert isinstance(request.stream, asyncio.Queue)
async def streaming(response):
while True:
body = await request.stream.get()
if body is None:
break
response.write(body.decode('utf-8'))
return stream(streaming)
async def put(request):
assert isinstance(request.stream, StreamBuffer)
async def streaming(response):
while True:
body = await request.stream.read()
if body is None:
break
await response.write(body.decode("utf-8"))
return stream(streaming)
async def post(request, id):
assert isinstance(request.stream, asyncio.Queue)
async def streaming(response):
while True:
body = await request.stream.get()
if body is None:
break
await response.write(body.decode("utf-8"))
await asyncio.sleep(1.0)
# at this point client is already disconnected
app.still_serving_cancelled_request = True
return stream(streaming)
async def test(request):
response = stream(sample_streaming_fn, content_type="text/csv")
response.cookies["test"] = "modified"
response.cookies["test"] = "pass"
return response
async def test(request):
return stream(sample_streaming_fn, content_type='text/csv')
async def as_csv(self, request, name, hash, **kwargs):
stream = request.args.get("_stream")
if stream:
# Some quick sanity checks
if not self.ds.config["allow_csv_stream"]:
raise DatasetteError("CSV streaming is disabled", status=400)
if request.args.get("_next"):
raise DatasetteError(
"_next not allowed for CSV streaming", status=400
)
kwargs["_size"] = "max"
# Fetch the first page
try:
response_or_template_contexts = await self.data(
request, name, hash, **kwargs
)
if isinstance(response_or_template_contexts, response.HTTPResponse):
return response_or_template_contexts
else:
data, extra_template_data, templates = response_or_template_contexts
except (sqlite3.OperationalError, InvalidSql) as e:
raise DatasetteError(str(e), title="Invalid SQL", status=400)
except (sqlite3.OperationalError) as e:
raise DatasetteError(str(e))
except DatasetteError:
raise
# Convert rows and columns to CSV
headings = data["columns"]
# if there are expanded_columns we need to add additional headings
expanded_columns = set(data.get("expanded_columns") or [])
if expanded_columns:
headings = []
for column in data["columns"]:
headings.append(column)
if column in expanded_columns:
headings.append("{}_label".format(column))
async def stream_fn(r):
nonlocal data
writer = csv.writer(LimitedWriter(r, self.ds.config["max_csv_mb"]))
first = True
next = None
while first or (next and stream):
try:
if next:
kwargs["_next"] = next
if not first:
data, extra_template_data, templates = await self.data(
request, name, hash, **kwargs
)
if first:
writer.writerow(headings)
first = False
next = data.get("next")
for row in data["rows"]:
if not expanded_columns:
# Simple path
writer.writerow(row)
else:
# Look for {"value": "label": } dicts and expand
new_row = []
for cell in row:
if isinstance(cell, dict):
new_row.append(cell["value"])
new_row.append(cell["label"])
else:
new_row.append(cell)
writer.writerow(new_row)
except Exception as e:
print('caught this', e)
r.write(str(e))
return
content_type = "text/plain; charset=utf-8"
headers = {}
if self.ds.cors:
headers["Access-Control-Allow-Origin"] = "*"
if request.args.get("_dl", None):
content_type = "text/csv; charset=utf-8"
disposition = 'attachment; filename="{}.csv"'.format(
kwargs.get('table', name)
)
headers["Content-Disposition"] = disposition
return response.stream(
stream_fn,
headers=headers,
content_type=content_type
)
async def streaming(request):
async def streaming_fn(response):
response.write('foo')
response.write('bar')
return stream(streaming_fn)
async def async_handler_exception(request, exception):
return stream(
sample_streaming_fn,
content_type="text/csv",
)
async def camera_stream(request):
camera = Camera(320, 240, 10)
# camera = Camera()
return response.stream(
camera.stream,
content_type='multipart/x-mixed-replace; boundary=frame')
async def blueprint_route(request):
async def streaming_fn(response):
response.write("foo")
return stream(streaming_fn)
async def streaming(request):
async def streaming_fn(response):
response.write("foo")
response.write("bar")
return stream(streaming_fn)
async def index(request):
async def streaming_fn(response):
response.write('foo')
response.write('bar')
return response.stream(streaming_fn, content_type='text/plain')
async def test(request):
return stream(
sample_streaming_fn,
headers={"Content-Length": "7"},
content_type="text/csv",
)
async def test(request):
async def sample_streaming_fn(response):
response.write('foo,')
response.write('bar')
return stream(sample_streaming_fn, content_type='text/csv')
async def random_bytes(request, count):
assert count >= 0
return response.stream(
send_bytes(count),
content_type='application/octet-stream'
)
async def test(request):
return stream(sample_streaming_fn, content_type='text/csv')
async def receive(request: Request):
## extract required data
print(request.form)
sender_id = await self._extract_sender(request)
input_channel = self._extract_platform(request)
text = self._extract_message(request)
attachment = self._extract_attachment(request)
if attachment != None:
text = attachment
should_use_stream = rasa.utils.endpoints.bool_arg(request,
"stream",
default=False)
## sends message in to rasa core
if should_use_stream:
return response.stream(
self.stream_response(on_new_message, text, sender_id),
content_type="text/event-stream",
)
else:
collector = CollectingOutputChannel()
print('1st collector.message')
print(collector.messages)
print(type(collector.messages))
# noinspection PyBroadException
try:
await on_new_message(
UserMessage(text,
collector,
sender_id,
input_channel=input_channel))
print('2nd after await onnewmessage collector.message')
print(collector.messages)
print(type(collector.messages))
message_received_is = collector.messages[0]
text = message_received_is.get("text")
print(text)
recipient_id = message_received_is.get("recipient_id")
message = {
"success":
1,
"message": [{
"message": {
"template": {
"elements": {
"title": text,
"says": "",
"visemes": ""
}
}
}
}],
"session":
sender_id
}
#
# message = {
# "success": 1,
# "message": text,
# "session": recipient_id
# }
print(
'#############printing message reply to talkk#################'
)
print(message)
return response.json(message)
except CancelledError:
logger.error("Message handling timed out for "
"user message '{}'.".format(text))
except Exception:
logger.exception("An exception occured while handling "
"user message '{}'.".format(text))
async def view(request):
return sanic_response.stream(
identifier.stream,
content_type='multipart/x-mixed-replace; boundary=frame')
async def index(request):
async def streaming_fn(response):
await response.write('foo')
await response.write('bar')
return response.stream(streaming_fn, content_type='text/plain')
async def stream_response(request):
async def sample_streaming_fn(response):
await response.write("foo,")
await response.write("bar")
return stream(sample_streaming_fn, content_type="text/csv")
