Robin robinsingh1

Microservice Bots

What they are and why you should use them

Introduction

Recently more and more chatbots appear, the overall chatbot market grows and the platform for it grows as well. Today we are taking a close look at what benefits creating a microservice chatbot on Discord - (a communication platform mainly targeted at gamers) would provide.

The concepts and ideas explained in this whitepaper are geared towards bots with a bigger userbase where the limits of a usual bot style appear with a greater effect

Information about Discord itself

(If you are already proficient with the Discord API and the way a normal bot works, you may skip ahead to The Concept)

The Problem

The documentation for how to deploy a pipeline with extra, non-PyPi, pure Python packages on GCP is missing some detail. This gist shows how to package and deploy an external pure-Python, non-PyPi dependency to a managed dataflow pipeline on GCP.

TL;DR: You external package needs to be a python (source/binary) distro properly packaged and shipped alongside your pipeline. It is not enough to only specify a tar file with a setup.py.

Preparing the External Package

Your external package must have a proper setup.py. What follow is an example setup.py for our ETL package. This is used to package version 1.1.1 of the etl library. The library requires 3 native PyPi packages to run. These are specified in the install_requires field. This package also ships with custom external JSON data, declared in the package_data section. Last, the setuptools.find_packages function searches for all available packages and returns that

Building a Maintainable, Agile Architecture for Realtime, Transactional Apps

A maintainable application architecture requires that the UI only contain the rendering logic and execute queries and mutations against the underlying data model on the server. A maintainable architecture must not contain any logic for composing "app state" on the client as that would necessarily embed business logic in the client. App state should be persisted to the database and the client projection of it should be composed in the mid tier, and refreshed as mutations occur on the server (and after network interruption) for a highly interactive, realtime UX.

With GraphQL we are able to define an easy-to-change application-level data schema on the server that captures the types and relationships in our data, and wiring it to data sources via resolvers that leverage our db's own query language (or data-oriented, uniform service APIs) to resolve client-specified "queries" and "mutations" against the schema.

We use GraphQL to dyn

	# NOTE:
	# You can find an updated, more robust and feature-rich implementation
	# in Zeno Build
	# - Zeno Build: https://github.com/zeno-ml/zeno-build/
	# - Implementation: https://github.com/zeno-ml/zeno-build/blob/main/zeno_build/models/providers/openai_utils.py

	import openai
	import asyncio
	from typing import Any

	"""
	stable diffusion dreaming
	creates hypnotic moving videos by smoothly walking randomly through the sample space

	example way to run this script:

	$ python stablediffusionwalk.py --prompt "blueberry spaghetti" --name blueberry

	to stitch together the images, e.g.:
	$ ffmpeg -r 10 -f image2 -s 512x512 -i blueberry/frame%06d.jpg -vcodec libx264 -crf 10 -pix_fmt yuv420p blueberry.mp4

	div, body, html, table {
	-webkit-overflow-scrolling: touch;
	}


	@media only screen and (max-width: 600px) {
	.presentation-header-container {
	display: none;
	}

	// Copyright (c) 2018 ml5
	//
	// This software is released under the MIT License.
	// https://opensource.org/licenses/MIT

	/* ===
	ml5 Example
	PoseNet example using p5.js
	=== */

	import argparse
	import deepspeech as ds
	import numpy as np
	import shlex
	import subprocess
	import sys

	parser = argparse.ArgumentParser(description='DeepSpeech speech-to-text from microphone')
	parser.add_argument('--model', required=True,
	help='Path to the model (protocol buffer binary file)')

	#!/usr/bin/env ruby

	# A sneaky wrapper around Rubocop that allows you to run it only against
	# the recent changes, as opposed to the whole project. It lets you
	# enforce the style guide for new/modified code only, as opposed to
	# having to restyle everything or adding cops incrementally. It relies
	# on git to figure out which files to check.
	#
	# Here are some options you can pass in addition to the ones in rubocop:
	#

	import tensorflow as tf
	import numpy as np
	import os

	import zconfig
	import utils


	class RBM(object):