import re import sqlite3 from contextlib import closing from typing import Dict, List, Union import responder from requests_html import HTML, HTMLSession from responder.models import Request, Response api = responder.API(cors=True, cors_params={'allow_origins': ['http://localhost:3001']}) session = HTMLSession() DB_PATH = 'database.db' DB_UPDATE_FLG = True def get_docs_list_impl() -> List[Dict[str, Union[str, int]]]: # 話の一覧を取得する docs_list: List[Dict[str, Union[str, int]]] = [] for year in range(2017, 2030): page = session.get( f'https://dc.watch.impress.co.jp/docs/comic/clinic/index{year}.html' ) if not page.ok: break html: HTML = page.html temp_list: List[Dict[str, Union[str, int]]] = [] for row in html.find('li.item.comic.clinic'): title = row.find('p.title > a', first=True).text doc_url: str = row.find('p.title > a', first=True).attrs['href'] doc_id = re.sub(r'.*?(\d+)\.html', r'\1', doc_url)
import responder from kce.crawler import Fetcher from kce.mail import sendMail api = responder.API(version="0.1") f = Fetcher() @api.route("/") def default(req, resp): resp.text = "OK" @api.route("/latest/arxiv/{subject}") def get_latest(req, resp, *, subject): papers = f.arxiv(subject) resp.media = papers @api.route("/message") class MessageService: async def on_post(self, req, resp): json = await req.media(format="json") if set(['email', 'name', 'message']).issubset(json.keys()): self.fromaddr = json['email'] self.fromname = json['name'] self.msg = json['message'] if self.fromaddr and self.fromname and self.msg:
import responder from marshmallow import fields class EmptyString(fields.Field): def encode(field, options): return '' app = responder.API() @app.route("/") async def index(req, resp): resp.text = EmptyString() @app.route('/user/{id}') async def user_info(req, resp, *, id): resp.text = id @app.route('/user') async def user(req, resp): if req.method == 'post': resp.text = EmptyString()
import responder import requests import asyncio api = responder.API(title="Dinghy Ping", version="1.0", openapi="3.0.0", docs_route="/docs") @api.route("/dinghy") def dinghy_html(req, resp): resp.content = api.template('ping_input.html') @api.route("/dinghy/ping/domains") async def ping_multiple_domains(req, resp): """ Async process to test multiple domains and return JSON with results Post request data example { "domains": [ { "protocol": "https", "domain": "google.com" }, { "protocol": "https", "domain": "microsoft.com" } ] } Return results { "domains": [
# app.py import os import responder from starlette.exceptions import HTTPException from tortoise import Tortoise from tortoise.exceptions import DoesNotExist, OperationalError from models import User, Group, Person api = responder.API(secret_key=os.urandom(64)) debug = True @api.on_event("shutdown") async def close_db_connection(): await Tortoise.close_connections() @api.on_event("startup") async def init_db(): """ Initialize the database :return: """ await Tortoise.init(db_url="sqlite://persons.db", modules={"models": ["models"]}) @api.route("/api/v1.0/users") async def get_users(req, resp): """
import responder import graphene from flask import Flask app = Flask(__name__) @app.route("/") def hello_world(): return "Hello, World from flask!" api = responder.API(enable_hsts=False) api.mount("/hello", app) import time @api.route("/") def hello(req, resp): # resp.status = responder.status.ok @api.background.task def sleep(s=10): # time.sleep(s) print("slept!") sleep() resp.content = api.template("test.html")
import responder cors_params = { 'allow_origins': '*', 'allow_methods': '*', } api = responder.API(cors=True, cors_params=cors_params)
import responder from models.date_selects import DateSelects api = responder.API(static_dir='./static') api.add_route("/", static=True) @api.route("/api/date-select/{date}") class DateSelectsAPI: def on_get(self, req, resp, *, date): model = DateSelects() dateSelects = model.get_all() resp.headers = {"Content-Type": "application/json; charset=utf-8"} resp.media = {"dateSelects": dateSelects} def on_post(self, req, resp, *, date): model = DateSelects() ret = model.add_data(date) # 返す値を設定する resp.headers = {"Content-Type": "application/json; charset=utf-8"} resp.media = {"status": ret} def on_delete(self, req, resp, *, date): model = DateSelects() ret = model.delete_data(date) # 返す値を設定する
# set empty name list & empty encoding list sample_names = [] sample_face_encoding_list = np.random.random( (len(sample_images), 128)).astype('float32') # get sample encoding for i, filename in enumerate(sample_images): face_encoding = cal_face_encoding(os.path.join(SAMPLE_IMAGE_DIR, filename)) sample_face_encoding_list[i] = face_encoding sample_names.append(os.path.splitext(filename)[0]) print("setup samples done") api = responder.API( openapi='3.0.0', # OpenAPI version docs_route= '/docs', # endpoint for interactive documentation by swagger UI. if None, this is not available. ) @api.route("/") async def view(req, resp): resp.media = {'success': True} @api.route("/recognizer") async def recognizer(req, resp): if req.method == 'get': # return form to upload an image you want to recognize # resp.status_code = 404 resp.content = api.template('recognizer.html',
import responder import time api = responder.API( allowed_hosts=["*"], # set allowed hosts secret_key='test', # set secret_key # enable_hsts=True, # redirect http to https, # cors=True, # config for cors # cors_params={ # 'allow_origins': ['https://example.org', 'https://www.example.org'] # } ) # define pre-response process @api.route(before_request=True) def prepare_response(req, resp): resp.headers["X-Pizza"] = "42" # standard api @api.route("/") def hello_world(req, resp): resp.text = "hello world!" # get key parameter @api.route("/route/{who}") def hello_world_key(req, resp, *args, who): resp.text = f"hello world, {who}!"
import responder from services.api.deadman_switch_api import DeadmanSwitchHealth api = responder.API( title = "Deadman Switch Board", version = "0.1.0" ) api.add_route("/health", DeadmanSwitchHealth) if __name__ == '__main__': api.run()
import os import json import responder import numpy as np from bpemb import BPEmb env = os.environ DEBUG = env['DEBUG'] in ['1', 'True', 'true'] LANG = env['LANG'] DIM = int(env['DIM']) VS = int(env['VS']) api = responder.API(debug=DEBUG) bpemb = BPEmb(lang=LANG, dim=DIM, vs=VS) def get_subwords(text): return bpemb.encode(text) def get_emb(text): vectors = bpemb.embed(text) return np.mean(vectors, axis=0).tolist() def get_subwords_and_emb(text): subwords = get_subwords(text) emb = get_emb(text) return dict(subwords=subwords, embedding=emb)
import responder api = responder.API(allowed_hosts=["*"], secret_key='test') @api.route(before_request=True) def pre_authentication(req, resp): """ authentication: the followings requests is valid, - static file - login view - correct session is equiped Others is redirected to login view """ # pass static file if req.url.path.startswith('/static/'): return # pass login elif req.url.path == '/login': return # pass having valid userid in session elif req.session.get('UserId', False) == 'user': return # login is necessary api.redirect(resp, f"/login?next='{req.url.path}'")
import responder import json api = responder.API(templates_dir='./static') #ホームにアクセスするとReactのviewが表示される @api.route("/") def index(req, resp): resp.html = api.template('index.html') @api.route("/{file}/json") def json_file(req, resp, *, file): with open('static/data/' + file + '.json', encoding="utf-8_sig") as f: data = json.load(f) resp.media = data if __name__ == '__main__': api.run()
import responder from marshmallow import Schema, fields import flask_sampler openapi_params = { "title": "Sample API", "openapi": "3.0.0", "version": "1.0", "docs_route": "/docs" } api = responder.API(**openapi_params) @api.route("/") def index(req, resp): resp.text = "hello responder" @api.schema("Echo") class EchoSchema(Schema): message = fields.Str() @api.route("/echo/{word}") class Echo(): """ test docs --- get: description: echo back word. parameters:
def api(): return responder.API(debug=False, allowed_hosts=[";"])
class UserInput(Model): word = CharField() frumfletta = ForeignKeyField(Frumfletta) count = IntegerField(default=0) class Meta: database = db db.connect() db.create_tables([UserInput, Frumfletta]) #beygingarlýsing bin = BIN_Compressed() # setting the header parameters in the constructor api = responder.API(cors=True, cors_params={'allow_origins': ['*']}) API_URL = 'http://nidhoggur.rhi.hi.is/ordanet-api/api' RANDOM_ENDPOINT = 'skyldheiti/handahof/' RELATED_ENDPOINT = 'skyldheiti/' @api.route('/skyldflettur') def get_word(req, resp): while True: word = requests.get( f'{API_URL}/{RANDOM_ENDPOINT}').json()['results'][0]['frumfletta'] if ' ' not in word: break payload = {'frumfletta': word} result_list = requests.get(f'{API_URL}/{RELATED_ENDPOINT}',
# -*- coding: utf-8 -*- """Define the responder api instance.""" import os import responder package_dir = os.path.dirname(os.path.abspath(__file__)) static_dir = os.path.join(package_dir, "static") template_dir = os.path.join(package_dir, "templates") api = responder.API( static_dir=static_dir, templates_dir=template_dir, debug=True, )
from io import BytesIO import responder from fastai.vision import load_learner, open_image MODEL_PATH = "./models" MODEL_NAME = "bclass_v1_006.pkl" print(f"Loading learner with model {MODEL_NAME}") learner = load_learner(MODEL_PATH, MODEL_NAME) api = responder.API(static_dir="./client/build", static_route="/") api.add_route("/", static=True) @api.route("/predict") class Prediction: async def on_post(self, req, resp): formData = await req.media(format="files") img = open_image(BytesIO(formData['file']['content'])) _, _, losses = learner.predict(img) resp.media = { "predictions": sorted(zip(learner.data.classes, map(float, losses)), key=lambda p: p[1], reverse=True) } api.run()
import responder import os from uuid import uuid4 from blockchain import Blockchain node_identifier = str(uuid4()).replace('-', '') blockchain = Blockchain() api = responder.API( templates_dir='templates', static_dir='static', static_route='/static', secret_key=os.urandom(24) ) class TransactionController: async def on_post(self, req, resp): data = await req.media() required = ['sender', 'recipient', 'amount'] if not all(data.get('{}'.format(key)) for key in required): resp.status_code = 400 index = blockchain.new_transaction(data.get('sender'),data.get('recipient'),data.get('amount')) response = {'message':f'トランザクションはブロック{index}に追加されました'} resp.media = response class MineController: async def on_get(self, req, resp): last_block = blockchain.last_block last_proof = last_block['proof'] proof = blockchain.proof_of_work(last_proof)
TAIL_LINES_DEFAULT = 100 LOGS_PREVIEW_LENGTH = 1000 TEMPLATE_DIR = 'dinghy_ping/views/templates/' STATIC_DIR = 'dinghy_ping/views/static/' def to_pretty_json(value): return json.dumps(value, sort_keys=True, indent=4, separators=(',', ': ')) api = responder.API( title="Dinghy Ping", templates_dir=TEMPLATE_DIR, static_dir=STATIC_DIR, version="1.0", openapi="3.0.0", docs_route="/docs" ) api.jinja_env.filters['tojson_pretty'] = to_pretty_json """ For local mac docker image creation and testing, switch to host.docker.internal """ redis_host = os.getenv("REDIS_HOST", default="127.0.0.1") """ Dinghy Ping Host name used for web socket connection to collect logs """ dinghy_ping_host = os.getenv(
from io import BytesIO import responder import aiohttp from fastai import * from fastai.vision import * # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # EXPORT_FILE_URL = 'https://www.dropbox.com/s/cot6bbu4w4dteei/trained_learner_allicroc.pkl?raw=1' EXPORT_FILE_NAME = 'trained_learner_allicroc.pkl' # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # api = responder.API(cors=True) path = Path(__file__).parent # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # # First download the pickled model from url and then unpickle it: async def download_file(url, dest): if dest.exists(): return async with aiohttp.ClientSession() as sess: async with sess.get(url) as resp: data = await resp.read() with open(dest, 'wb') as f: f.write(data)
description = "knp-sandbox" terms_of_service = "use your own risk" contact = { "name": "@seiketkm", "url": "https://twitter.com/seiketkm", } license = { "name": "MIT", "url": "", } api = responder.API(title="knp-sandbox", version="1.0", openapi="3.0.2", docs_route='/docs', description=description, terms_of_service=terms_of_service, contact=contact, license=license) @api.schema("KnpRequest") class KnpRequest(Schema): text = fields.Str(required=True, default="望遠鏡で泳ぐ少女を見た。", example="望遠鏡で泳ぐ少女を見た。") @api.schema("KnpResult") class KnpResult(Schema): all = fields.Str(
import os import responder api = responder.API(enable_hsts=True) @api.route("/") def route(req, resp): resp.text = "hello, world!" api.run(port=int(os.environ["PORT"]))
def api(): return responder.API()
import responder import reprlib import aioboto3 import asyncio import twitter import aiohttp from typing import List from dataclasses import dataclass from face_detector import FaceDetector from container import FileImage, FileImages api = responder.API(cors=True, cors_params={ 'allow_origins': ['*'], 'allow_methods': ['*'], 'allow_headers': ['*'], }) @api.route("/") async def file_api(req, resp): data = await req.media(format='files') # データ生成 file_images_list = [] for key, value in data.items(): file_image = FileImage(key, value['content'], {}) file_images_list.append(file_image) file_images = FileImages(file_images_list)
"name": "Configure", "url": "/configure/", "id": "configure" }, { "name": "Status", "url": "/status/", "id": "status" }, ] VALID_PAGES = [x['id'] for x in MENU] + ["provision"] api = responder.API( static_dir="{}/static".format(ROOT), static_route="/static/{}".format(SNAP_REVISION), templates_dir="{}/templates".format(ROOT), ) @api.route("/") async def index(req, resp): if req.headers.get('TOKEN') == SECRET_TOKEN: resp.html = api.template('index.html', menu=MENU, current="/", page="index", static_hash=SNAP_REVISION) else: resp.text = "Error: You need to provide a correct TOKEN"
import responder from gql.schema import schema api = responder.API(static_dir="build") api.add_route("/graphql", schema) api.add_route("/", static=True) if __name__ == "__main__": api.run(address="0.0.0.0", port=5000)
from logging import Logger from settingstree import Settings import responder from starlette.websockets import WebSocketDisconnect, WebSocket, WebSocketState from chain import ProcessingChain, WebFunctionDoesNotExistException from json.decoder import JSONDecodeError from threading import Thread, Lock from collections import defaultdict import sys import asyncio log = Logger(__name__) settings = Settings() responder_api = responder.API() PlatformProcessingChain = ProcessingChain.get_platform_specific_chain() processing_chain = PlatformProcessingChain(settings) if not processing_chain: log.error('Your platform is currently not supported.') sys.exit(1) # Load settings after chain initialized tree. settings.load() # TODO: move this somewhere else class ProcessingThread(Thread): # TODO: move these to instance namespace? lock = Lock() ap_active = False
def create_server(services): api = responder.API(cors=True) edge_resouce.add_route(api, services) return api