pre_data = cipher.read_from_file()
for task in pre_data:
tasks.create_task(body=task["body"],
column=task["column"],
sort_order=task["sort_order"],
user=task["user"],
modified=task["modified"])
except:
pass
return kanban
#Build the app
app = setup(db)
#Turn the flask app into a socketio app
socketio = SocketIO(app, async_mode=None, logger=True, engineio_logger=True)
#Event generator Thread
thread = Thread()
thread_stop_event = Event()
# Async job function
def randomTaskGenerator():
"""Generate random sayings for random people"""
with app.app_context():
print("Making random comments")
people = ["Arthur", "Marvin", "Ford", "Deep Thought"]
sayings = [
"Don't Panic.", "Space is big.", "Where's your towel?", "42",
"I don't know why I bother..."
from redis import Redis
from config import Config
app = Flask(__name__)
# Flask extensions
db = SQLAlchemy()
migrate = Migrate()
login = LoginManager()
login.login_view = 'auth.login'
login.login_message = _l('Please log in to access this page.')
# login.login_message = 'your msg'
mail = Mail()
bootstrap = Bootstrap()
moment = Moment()
socketio = SocketIO()
# for generate pot: pybabel extract -F babel.cfg -k _l -o messages.pot .
# for generate mo: pybabel init -i messages.pot -d app/translations -l <needed lang>
# for update mo: pybabel update -i messages.pot -d app/translations
# for compile po: pybabel compile -d app/translations
babel = Babel()
def create_app(config_class=Config):
_app = Flask(__name__)
_app.config.from_object(config_class)
db.init_app(_app)
migrate.init_app(_app, db)
login.init_app(_app)
from time import localtime, strftime
from flask import Flask, request, render_template, jsonify, redirect
from flask_socketio import SocketIO, join_room, leave_room, send
import sqlite3
import constants
app = Flask(__name__)
app.config["SECRET_KEY"] = "mysecret"
app.host = "localhost"
_socket_io = SocketIO(app)
ROOMS = ["common"]
# for getting data from members table
def select_element_members(column_name, value):
# connect to database
conn = sqlite3.connect('members.db')
cur = conn.cursor()
query_select_element_members = "SELECT * FROM members WHERE {}=\"{}\""
query_select_element_members = query_select_element_members.format(
column_name, value)
print(query_select_element_members)
result_select_element_members = cur.execute(query_select_element_members)
result_select_element_members = list(result_select_element_members)
return result_select_element_members
@app.route("/")
def home():
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
import logging
import time
from flask_socketio import SocketIO
DEFAULT_LOGGING_FORMAT = '[%(asctime)s][%(levelname)s]%(pathname)s@%(lineno)d: %(msg)s'
logging.basicConfig(level=logging.INFO, format=DEFAULT_LOGGING_FORMAT)
logger = logging.getLogger('trigger')
socketio = SocketIO(message_queue='redis://localhost/0',
channel='socketio-test')
ns_name = '/fanout'
ts = int(time.time() * 1000)
socketio.emit('my event', ts, namespace=ns_name)
socketio.emit('my event', ts, namespace=ns_name)
socketio.emit('my event', ts, namespace=ns_name)
socketio.emit('my event', 'quit', namespace=ns_name)
# Configure database
app.config['SQLALCHEMY_DATABASE_URI'] = ""
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
# Initialize login manager
login = LoginManager(app)
login.init_app(app)
@login.user_loader
def load_user(id):
return User.query.get(int(id))
socketio = SocketIO(app, async_mode=None, manage_session=False)
# keep track of the users, channels and the messages in each channel
channels = []
my_messages = {}
users = {}
@socketio.on("username")
def receive_username(username):
# pair usernames with session IDs
users[username] = request.sid
# execute when a message is sent
@socketio.on("room_message")
from app import flask_app
from flask_socketio import SocketIO
from game import init_game
flask_app.config.from_object('config')
socketio = SocketIO(flask_app)
init_game()
import events.user
import events.person
import events.house
import events.resource
"""
Main flask application
"""
from flask import Flask
from flask_session import Session
from flask_bootstrap import Bootstrap
from flask_socketio import SocketIO
from . import interactive
bootstrap = Bootstrap()
session = Session()
socketio = SocketIO(manage_sessions=False, engineio_logger=True)
class DefaultConfig:
SESSION_TYPE = 'redis'
def create_app(test_config=None):
app = Flask(__name__)
app.config.from_object(DefaultConfig)
if test_config:
app.config.from_mapping(test_config)
app.config[
'SECRET_KEY'] = b'\xd5\xfbz\xbbVX\xf9\xfe\xaa\x053\xedg\x8e\xa2;'
app.register_blueprint(interactive.bp)
session.init_app(app)
bootstrap.init_app(app)
"""
set everything up
"""
from flask import Flask
from flask_socketio import SocketIO, emit
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
import eventlet, os
basedir = os.path.abspath(os.path.dirname(__file__))
class Config(object):
SQLALCHEMY_DATABASE_URI = os.environ.get(
'DATABASE_URL') or 'sqlite:///' + os.path.join(basedir, 'app.db')
SQLALCHEMY_TRACK_MODIFICATIONS = False
app = Flask(__name__)
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
socketio = SocketIO(app, async_mode='eventlet')
from app import routes, beanjump, models, beansjump # , beansjumproute
def close_connection(exception):
db = getattr(g, '_database', None)
if db is not None:
db.close()
class ComplexEncoder(json.JSONEncoder):
def default(self, obj):
try:
if isinstance(obj, DBModel):
return obj.__dict__
elif isinstance(obj, ActorBase):
return obj.state()
elif isinstance(obj, SensorBase):
return obj.get_value()
elif hasattr(obj, "callback"):
return obj()
else:
return None
except TypeError as e:
pass
return None
app.json_encoder = ComplexEncoder
socketio = SocketIO(app, json=json, logging=False)
cbpi = CraftBeerPi(app, socketio)
print("Finished app_config")
app.logger.info("##########################################")
app.logger.info("### NEW STARTUP Version 3.0")
app.logger.info("##########################################")
import json
import flask
from flask_socketio import SocketIO, emit
from flask_socketio import join_room, leave_room
from flask import render_template, copy_current_request_context, request
from docker import DockerImage, DOWNLOADS_DIR
MAX_FILES_IN_DOWNLOAD_DIR = 3
application = flask.Flask(__name__)
application.debug = True
socketio = SocketIO(application, debug=True, async_mode="gevent")
@socketio.on('connect')
def test_message():
emit('set_sid', {'sid': request.sid})
@socketio.on('changed_sid')
def test_message():
emit('event', {'data': 'got it!'})
@application.route("/")
def index():
return render_template("index.html")
from flask import Flask, render_template
from flask_socketio import SocketIO, emit
import numpy as np
import requests
from datetime import datetime
from fbprophet import Prophet
import pandas as pd
from helper_v4 import forecastr, determine_timeframe, get_summary_stats, validate_model, preprocessing
import logging
import time
# Socket IO Flask App Setup
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, logger=False, engineio_logger=False)
# Suppress logs except for error: https://stackoverflow.com/questions/43487264/disabling-logger-in-flask-socket-io
logging.getLogger('socketio').setLevel(logging.ERROR)
logging.getLogger('engineio').setLevel(logging.ERROR)
logging.getLogger('geventwebsocket.handler').setLevel(logging.ERROR)
@app.after_request
def add_header(r):
"""
Add headers to both force latest IE rendering engine or Chrome Frame,
and also to cache the rendered page for 10 minutes.
"""
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
from collections import defaultdict
app = Flask(__name__, static_url_path="", static_folder="static")
res = mongoengine.connect(DATABASE_NAME,
host=HOST_IP,
port=PORT,
username=USERNAME,
password=PASSWORD,
authentication_source=AUTHENTICATION_SOURCE)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
app.secret_key = SECRET_KEY
# sess = Session()
# sess.init_app(app)
app.config['SECRET_KEY'] = SECRET_KEY
socket_app = SocketIO(app)
chat_target = defaultdict(list)
connected_id = set()
connected_listening_id = set()
offline_notification = dict()
@app.route('/')
def hello_world():
# access_token = session.get("email")
# if access_token is None:
return redirect("/index.html", code=302)
@app.route("/login", methods=['POST'])
def verify_login():
def create_server(test_config=None):
# Scoreboard Object and Data Store
# scoreboard = Scoreboard("SEOULAI")
# Basic Authentication
auth = HTTPBasicAuth()
@auth.get_password
def get_password(username):
if username == 'seoulAI':
return 'agent'
return None
@auth.error_handler
def unauthorized():
return make_response(jsonify({'error': 'Unauthorized access'}), 401)
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.static_url_path = '/static'
app.config.from_mapping(
SECRET_KEY='dev',
#DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite'),
)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
# Now let's create the websocket
socketio = SocketIO(app)
@app.errorhandler(BAD_REQUEST)
def bad_request(error):
return make_response(jsonify({'error': 'Bad request'}), BAD_REQUEST)
@app.errorhandler(NOT_FOUND)
def not_found(error):
return make_response(jsonify({'error': 'Not found'}), NOT_FOUND)
# Flask Service
@app.errorhandler(SERVER_ERROR)
def server_error(error):
return make_response(jsonify({'error': 'Server error'}), SERVER_ERROR)
@app.route('/move', methods=['GET'])
def move():
send_move()
return jsonify({'response': 'OK'})
@socketio.on('message')
def handle_message(message):
print('received message: ' + message)
@socketio.on('json')
def handle_json(json):
print('received json: ' + str(json))
def send_move():
# count is use to create some randomness on test moves
global count
count += 1
if (count == 4):
count = 0
socketio.emit('message', moves[count])
return app
# Point SQLAlchemy to your Heroku database
APP.config["SQLALCHEMY_DATABASE_URI"] = os.getenv("DATABASE_URL")
# Gets rid of a warning
APP.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
DB = SQLAlchemy(APP)
# IMPORTANT: This must be AFTER creating db variable to prevent
# circular import issues
import models # pylint: disable=C0413
DB.create_all()
CORS = CORS(APP, resources={r"/*": {"origins": "*"}})
NAMES = []
SOCKETIO = SocketIO(APP,
cors_allowed_origins="*",
json=json,
manage_session=False)
@APP.route("/", defaults={"filename": "index.html"})
@APP.route("/<path:filename>")
def index(filename):
"""Send a given data file to qutebrowser.
If a directory is requested, its index.html is sent.
"""
return send_from_directory("./build", filename)
# When a client connects from this Socket connection, this function is run
@SOCKETIO.on("connect")
def on_connect():
from firebase_admin import credentials, firestore
from flask_cors import CORS
import firebase_admin
import json, os
cred = credentials.Certificate(json.loads(os.environ["PROJECT_AUTH"]))
firebase_admin.initialize_app(cred)
fireClient = firestore.client()
from flask import Flask, render_template, session, redirect, request
from flask_socketio import SocketIO
socketio = SocketIO(logger=True)
from socraticos.blueprints import users, groups, chat, auth
def create_app():
app = Flask(__name__)
# TODO: CHANGE THIS!!!
app.secret_key = "DEVELOPMENT"
CORS(app)
app.register_blueprint(users.users, url_prefix="/users")
app.register_blueprint(groups.groups, url_prefix="/groups")
app.register_blueprint(auth.auth, url_prefix="/auth")
@app.before_request
def log_request_info():
app.logger.debug('JSON: %s', request.get_json())
# Redirect to API documentation
from flask_socketio import SocketIO, join_room
import threading
from glob import glob
from os.path import isfile, join, basename, splitext
from CGSserver.Game import Game
from CGSserver.Player import RegularPlayer
from CGSserver.Logger import Config
from CGSserver.Tournament import Tournament
from CGSserver.BaseClass import BaseClass
from CGSserver.Constants import mode
# flask object and socketIO ('threading' in debug/dev mode, but 'gevent' in prod)
flask = Flask("webserver")
if mode == 'prod':
socketio = SocketIO(flask, async_mode='gevent')
else:
socketio = SocketIO(flask, async_mode='threading')
# set the template paths so that in priority,
# it first looks in <gameName>/server/templates/ and then in CGS/server/templates
templatePaths = ['games/' + Game.getTheGameName() + '/server/templates/', 'CGSserver/templates/']
def runWebServer(host, port):
"""
Run the webserver
"""
# add a custom jinja loader
my_loader = ChoiceLoader([flask.jinja_loader, FileSystemLoader(templatePaths), ])
flask.jinja_loader = my_loader
from flask import Flask, escape, request, render_template, jsonify, send_from_directory
from flask_socketio import SocketIO
import os, sys, time
from instant_rst.rst import html_body
from instant_rst import settings, util
app = Flask(__name__,
static_folder=settings.FLASK_STATIC_FOLDER,
template_folder=settings.FLASK_TEMPLATE_FOLDER)
app.config['SECRET_KEY'] = settings.SECRET
sock = SocketIO(app)
# ROUTE
@app.route('/', methods=['GET'])
def index_get():
_file = request.args.get('rst', '')
if os.path.isfile(_file):
with open(_file, 'r') as _fo:
_doc = html_body(_fo.read())
return render_template('index.html', HTML=_doc)
else:
return render_template('index.html')
@app.route('/', methods=['POST', 'PUT'])
def index_post():
print(str(request.form))
from flask import Flask, request, redirect
from flask_socketio import SocketIO, send, emit, join_room, leave_room, close_room
import json, random, datetime, argparse
# for socketio
import eventlet
eventlet.monkey_patch()
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode='eventlet', cors_allowed_origins="*")
sessions = {} # indexed by session name
@socketio.on('message')
def handleMessage(msg):
print(datetime.datetime.now(), 'Message: ' + msg)
send(msg, broadcast=True)
@socketio.on('check session name event')
def handleCheckName(json):
name = json['name']
#print("checking ",name,name in sessions)
if name in sessions:
emit('check session name response', "exists")
else:
emit('check session name response', "free")
from flask import Flask, jsonify
from flask_socketio import SocketIO, send
app = Flask(__name__)
app.config['SECRET_KEY'] = 'mysecret'
socketIo = SocketIO(app, cors_allowed_origins="*")
app.debug = True
app.host = 'localhost'
@app.route("/")
def index():
return "Hello"
@socketIo.on("message")
def handleMessage(msg):
print(msg)
send(msg, broadcast=True)
return None
if __name__ == '__main__':
socketIo.run(app)
from .websocket.totem_socket import Totem_Socket
from .websocket.user_socket import User_Socket
from .websocket.stream_socket import Stream_Socket
from .api.user_routes import user_routes
from .api.session_routes import session_routes
from .api.totem_routes import totem_routes
from .api.totem_skin_routes import totem_skin_routes
from .api.emote_routes import emote_routes
from .api.bot_routes import bot_routes
app = Flask(__name__)
login_manager = LoginManager()
socketio = SocketIO(app,
cors_allowed_origins='http://localhost:3000',
logger=True,
engineio_logger=True)
app.config.from_object(Config)
login_manager.init_app(app)
db.init_app(app)
socketio.on_namespace(Totem_Socket('/ws/totem'))
socketio.on_namespace(User_Socket('/ws/user'))
socketio.on_namespace(Stream_Socket('/ws/stream'))
app.register_blueprint(user_routes, url_prefix='/api/users')
app.register_blueprint(session_routes, url_prefix='/api/session')
app.register_blueprint(totem_routes, url_prefix='/api/totems')
app.register_blueprint(totem_skin_routes, url_prefix='/api/totem_skins')
app.register_blueprint(emote_routes, url_prefix='/api/emotes')
app.register_blueprint(bot_routes, url_prefix='/api/bots')
# activate eventlet import eventlet eventlet.monkey_patch() from flask import Flask from flask_socketio import SocketIO app = Flask(__name__) app.secret_key = 'development key' socketio = SocketIO(async_mode='eventlet', engineio_logger=False) socketio.init_app(app) from reddstackapi import views
def __init__(self):
SOK.socket_ref = SocketIO(cors_allowed_origins="*")
from apis.entity_handler import *
from apis.transcode_handler import *
################################################################################
################ Initialize and Setup ###########################
################################################################################
app = Flask(__name__)
app.config['SECRET_KEY'] = 'my super secret key'.encode('utf8')
cors = CORS(app)
app.config['CORS_HEADERS'] = 'Content-Type'
socketio = SocketIO(app,
async_mode="gevent",
cors_allowed_origins='*',
logger=True,
engineio_logger=True)
config = {}
ui = {}
################################################################################
################ Setup default language ###########################
################################################################################
with open(r'./i18n.yml') as file:
# The FullLoader parameter handles the conversion from YAML
# scalar values to Python the dictionary format
i18n = yaml.load(file, Loader=yaml.FullLoader)
print("i18n: ", i18n, flush=True)
################################################################################
from flask_socketio import SocketIO
import requests
# from logging.config import fileConfig
# import logging
from Controllers.EvaluatorController import EvaluatorController
# fileConfig('logging.conf')
# log = logging.getLogger(__name__)
from Modules.Concepts.ComplexNetwork import ComplexNetwork
app = Flask(__name__, static_folder='')
app.config['SECRET_KEY'] = '@server-secret'
# socketio = SocketIO(app, allow_upgrades=True, engineio_logger=log, logger=log)
socketio = SocketIO(app, allow_upgrades=True)
complex_network = ComplexNetwork()
evaluator_controller = EvaluatorController(complex_network=complex_network)
class Socket:
"""
Class used to emit answer to specific client
"""
def __init__(self, sid):
self.sid = sid
self.connected = True
# Emits data to a socket's unique room
def emit(self, event, data):
print('going to emit to', self.sid)
def create_app():
app = Flask(__name__)
app.config.from_object(CONFIG_CLASS)
init_logging()
socketio = SocketIO(app, cors_allowed_origins="*")
if os.getenv("FLASK_ENV") == "development":
app = register_teardown_request(app)
# read directory mount based config into Flask config
try:
conf_data = get_user_conf()
app.config.update(conf_data)
except Exception:
app.logger.warning("Failed to load config.json")
app.config["ORCHEST_REPO_TAG"] = get_repo_tag()
# create thread for non-cpu bound background tasks, e.g. requests
scheduler = BackgroundScheduler(
job_defaults={
# Infinite amount of grace time, so that if a task cannot be
# instantly executed (e.g. if the webserver is busy) then it
# will eventually be.
"misfire_grace_time": 2**31,
"coalesce": False,
# So that the same job can be in the queue an infinite
# amount of times, e.g. for concurrent requests issuing the
# same tasks.
"max_instances": 2**31,
})
app.config["SCHEDULER"] = scheduler
scheduler.start()
app.logger.info("Flask CONFIG: %s" % app.config)
# Create the database if it does not exist yet. Roughly equal to a
# "CREATE DATABASE IF NOT EXISTS <db_name>" call.
if not database_exists(app.config["SQLALCHEMY_DATABASE_URI"]):
create_database(app.config["SQLALCHEMY_DATABASE_URI"])
db.init_app(app)
ma.init_app(app)
# necessary for migration
Migrate().init_app(app, db)
with app.app_context():
# Alembic does not support calling upgrade() concurrently
if not is_werkzeug_parent():
# Upgrade to the latest revision. This also takes care of
# bringing an "empty" db (no tables) on par.
try:
upgrade()
except Exception as e:
logging.error("Failed to run upgrade() %s [%s]" % (e, type(e)))
initialize_default_datasources(db, app)
# Telemetry
if not app.config["TELEMETRY_DISABLED"]:
# initialize posthog
posthog.api_key = base64.b64decode(
app.config["POSTHOG_API_KEY"]).decode()
posthog.host = app.config["POSTHOG_HOST"]
# send a ping now
analytics_ping(app)
# and every 15 minutes
scheduler.add_job(
analytics_ping,
"interval",
minutes=app.config["TELEMETRY_INTERVAL"],
args=[app],
)
# static file serving
@app.route("/public/<path:path>")
def send_files(path):
return send_from_directory("../static", path)
register_views(app, db)
register_orchest_api_views(app, db)
register_background_tasks_view(app, db)
register_socketio_broadcast(db, socketio)
register_analytics_views(app, db)
processes = []
if not is_werkzeug_parent():
file_dir = os.path.dirname(os.path.realpath(__file__))
# log_streamer process
log_streamer_process = Popen(
["python3", "-m", "scripts.log_streamer"],
cwd=os.path.join(file_dir, ".."),
stderr=subprocess.STDOUT,
)
app.logger.info("Started log_streamer.py")
processes.append(log_streamer_process)
return app, socketio, processes
import json
import requests
from flask import Flask, render_template, session, request, \
copy_current_request_context
from flask_socketio import SocketIO, emit, join_room, leave_room, \
close_room, rooms, disconnect
# Set this variable to "threading", "eventlet" or "gevent" to test the
# different async modes, or leave it set to None for the application to choose
# the best option based on installed packages.
async_mode = None
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode=async_mode, message_queue='amqp://')
@app.route('/')
def index():
return render_template('index.html', async_mode=socketio.async_mode)
@app.route('/send', methods=['POST'])
def send_msg():
data = request.get_json()
print(data)
message = data.get('message', 'Empty response!')
socketio.emit('my_event', {'data': message}, namespace='/test')
return {'message': message, 'code': 0}
from threading import Lock
from flask import Flask, render_template
from flask_socketio import SocketIO, emit
from astropy.coordinates import solar_system_ephemeris, get_body_barycentric
from astropy.time import Time, TimeDelta
SCALE = 100000
solar_system_ephemeris.set('jpl')
app = Flask(__name__)
socketio = SocketIO(app)
thread = None
thread_lock = Lock()
def tick():
count = 0
while True:
t = Time.now() + TimeDelta(86400 * count, format='sec')
mercury = get_body_barycentric('Mercury', t)
venus = get_body_barycentric('Venus', t)
earth = get_body_barycentric('Earth', t)
mars = get_body_barycentric('Mars', t)
jupiter = get_body_barycentric('Jupiter', t)
socketio.emit(
'tick', {
'mercury': {
'x': round(mercury.x.value / SCALE, 2),
from flask import Flask, render_template, session, request
from flask_socketio import SocketIO, emit, join_room, leave_room, \
close_room, rooms, disconnect
import math
import time
from example import TestThread
async_mode = None
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode=async_mode)
thread = None
def background_thread():
"""Example of how to send server generated events to clients."""
tt = TestThread()
tt.setDaemon(True)
tt.start()
count = 0
while True:
count += 1
socketio.sleep(0.1)
val = tt.getData()
print("val")
print(val)
socketio.emit('my_response', {
'data': val,
'count': count,
'type': 'sin'
},
from flask import Flask
from flask_cors import CORS
from flask_socketio import SocketIO
from flask_migrate import Migrate
app = Flask(__name__)
CORS(app)
app.config.from_object('config')
socketio = SocketIO(app, cors_allowed_origins='*')
from flask import Flask, render_template
from flask_socketio import SocketIO, emit
from canary.analysis import Analysis
from canary.tweets import TweetStream
from canary.crypto import Ticker
BUY_SELL_THRESHOLD = 0.15
app = Flask(__name__, static_folder="web/public", static_url_path="")
socketio = SocketIO(app, async_mode="threading")
bitcoin = Analysis("BTC")
etherium = Analysis("ETH")
def emit_tweet(crypto):
def f(tweet):
delta = crypto.process_tweet(tweet)
if delta == -1:
return -1
payload = {
"tweet": {
"text": tweet.text,
"followers": tweet.followers,
"name": tweet.name,
"full_name": tweet.full_name,
"img": tweet.img
},
"sentiment": crypto.get_value(),
"delta": delta
}
