os.makedirs(out_dir)
for _, _, subfiles in tf.io.gfile.walk(os.path.join(
root, dir_name)):
for subfile_name in subfiles:
temp_file = open(os.path.join(out_dir, subfile_name), "wb")
remote_file = tf.io.gfile.GFile(os.path.join(
root, dir_name, subfile_name),
mode="rb")
temp_file.write(remote_file.read())
remote_file.close()
temp_file.close()
app = FastAPI()
app.mount("/static",
StaticFiles(directory="classifier/web/static"),
name="static")
templates = Jinja2Templates(directory="classifier/web/templates")
download_model()
def preprocess_img(img: bytes):
input_img = BytesIO(base64.urlsafe_b64decode(img))
# Reading image and resing to nn input
input_img = Image.open(input_img).resize((32, 32))
# Converting to np.array and removing alpha channel
input_img = np.array(input_img)[:, :, :3]
# Negate image
input_img = tf.keras.applications.mobilenet_v2.preprocess_input(input_img)
return tf.expand_dims(input_img, axis=0)
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Author : xinfa.jiang # @File : config.py import os from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates root_path = os.path.dirname(__file__) web_path = os.path.join(root_path, 'web') logs_path = os.path.join(root_path, 'logs') s_path = os.path.join(web_path, 'static') statics = StaticFiles(directory=s_path) templates = Jinja2Templates(directory=os.path.join(web_path, 'templates')) python_path = 'python3 ' count_day = os.path.join(logs_path, 'count_day.txt') count_view_code = os.path.join(logs_path, 'count_view_code.txt')
from fastapi import FastAPI
from fastapi.staticfiles import StaticFiles
from starlette.middleware.cors import CORSMiddleware
from .api_v1.api import api_router
from .config import settings
app = FastAPI(title=settings.PROJECT_NAME,
openapi_url=f"{settings.API_V1_STR}/openapi.json")
app.mount("/static", StaticFiles(directory="static"), name="static")
app.add_middleware(
CORSMiddleware,
allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
allow_credentials=True,
allow_methods=["GET", "POST"],
)
@app.get("/", tags=["/"])
async def home():
return {"msg": "Hello World"}
app.include_router(api_router, prefix=settings.API_V1_STR)
from fastapi import FastAPI,File,UploadFile
from fastapi.staticfiles import StaticFiles
from typing import List
from passlib.context import CryptContext
pwd_context = CryptContext(schemes=["bcrypt"],deprecated="auto")
app = FastAPI(
docs_url="/api/v2/docs",
redoc_url="/api/v2/redocs",
title="小程序核心接口",
description="小程序用户接口、支付接口等",
openapi_url="/api/v2/openapi.json",
)
app.mount("/Upload", StaticFiles(directory="Upload"), name="Upload")
@app.on_event("startup")
async def startup():
await database.connect()
@app.on_event("shutdown")
async def shutdown():
await database.disconnect()
@app.get("/",tags=["默认页"])
async def index():
return 'Hello World!'
@app.get("/users",response_model=List[mdUser.UserList],tags=["用户接口"])
async def find_all_users():
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
import base64
from Crypto.Hash import SHA1, SHA256, SHA512, MD5
from Crypto.Cipher import AES, PKCS1_OAEP, ChaCha20
from Crypto.Signature import pkcs1_15
from Crypto.PublicKey import RSA
from Crypto.Random import get_random_bytes
default_string_encoding = 'utf-8'
parent_dir_path = os.path.dirname(os.path.realpath(__file__))
app = FastAPI()
app.mount("/static", StaticFiles(directory=parent_dir_path + "/static"), name="static")
def encode_base64_string(message: str, string_encoding: str = default_string_encoding):
message_bytes = message.encode(string_encoding)
return encode_base64_bytes(message_bytes)
def encode_base64_bytes(message: bytes):
base64_bytes = base64.b64encode(message)
base64_hex = base64_bytes.hex()
base64_ascii = base64_bytes.decode('ascii')
return base64_bytes, base64_hex, base64_ascii
def hash(file, hash_buffer):
logger = logging.getLogger(__name__)
app = FastAPI()
if RUNNING_LOCALHOST:
origins = ['http://localhost:5000', 'http://localhost']
app.add_middleware(CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=['*'],
allow_headers=['*'])
logger.info('Running localhost, allowing CORSMiddleware with origins '
'localhost:5000')
app.mount('/data',
StaticFiles(directory=FASTAPI_DATA_DIR.as_posix()),
name='data')
STATUS = ServiceStatus(service_type=ROLE, status='booting')
HEALTH: Optional[HealthStatus] = None
def _set_health_status():
# Todo: run async when you get a grip on aiohttp
global HEALTH
try:
res = requests.get(f'{SERVICE_URLS["unsigned"]}/health')
unsigned_health = res.json().get('status', 'offline') if \
res.status_code == 200 else 'offline'
except (ConnectionError, AttributeError):
unsigned_health = 'offline'
<form action="/uploadfiles/" enctype="multipart/form-data" method="post">
<input name="files" type="file" multiple>
<input type="submit">
</form>
</body>
"""
return HTMLResponse(content=content)
# Serve static files
# $ pip install aiofiles
from fastapi.staticfiles import StaticFiles
app.mount( # An independent application is mounted, and is responsible to handling sub-paths
"/static", # URL
StaticFiles(directory="static"), # serve files from here
name="static", # internal name for referencing
)
# Report errors
@app.get(
"/item-by-id/{item_id}",
# Predefined responses for certain error codes
responses={
404: {
"description": "Not found"
},
})
async def get_item_by_id(item_id: str):
items = {"foo": "The Foo Wrestlers"}
#sio.attach(app)
def background_task():
print("background task")
@sio.on('disconnect')
def test_disconnect(sid):
print('Client disconnected')
@app.get("/hello")
def root():
return {"message": "Hello World"}
app.mount("/static", StaticFiles(directory="viewer"), name="static")
app.mount("/data", StaticFiles(directory="data"), name="data")
app.mount('/', socket_app)
#@app.get("/viewer", response_class=HTMLResponse)
#async def index():
# with open('viewer/index.html') as f:
# return f.read()
@sio.on('run')
async def handle_join(sid, *args, **kwargs):
print("JOINING")
await sample.run(sio)
import uvicorn
import json
from fastapi import FastAPI, Request, Response
from fastapi.responses import StreamingResponse, HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from oedatamodel_api.oep_connector import get_scenario_from_oep, ScenarioNotFoundError
from oedatamodel_api import mapping_custom, formatting
from oedatamodel_api.settings import ROOT_DIR
app = FastAPI()
app.mount(
'/static', StaticFiles(directory=ROOT_DIR / "oedatamodel_api" / 'static'), name='static',
)
templates = Jinja2Templates(directory=ROOT_DIR / "oedatamodel_api" / 'templates')
@app.get('/')
def index(request: Request) -> Response:
return templates.TemplateResponse('index.html', {'request': request})
def prepare_response(raw_json, mapping, output_format):
try:
mapped_data = mapping_custom.apply_custom_mapping(raw_json, mapping)
except Exception as e:
return HTMLResponse(str(e))
import json
from fastapi import FastAPI
from fastapi.staticfiles import StaticFiles
from starlette.responses import FileResponse # Use this to serve a public/index.html
from simplekv.memory.redisstore import RedisStore
from simplekv.fs import FilesystemStore
import redis
from config import REDIS_HOST, REDIS_PORT, REDIS_DB, REDIS_PASS, IS_DEBUG, PORT
import uvicorn
from wordcookies import game
# init FastAPI
app = FastAPI()
app.mount("/public", StaticFiles(directory="./public"), name="public")
# init cache
# TODO: move to constant
text_domain = "wordcookies"
if REDIS_HOST == "":
cache_path = "./cache"
print("cache storage: file, inside %s" % cache_path)
store = FilesystemStore(cache_path)
else:
print("cache storage: Redis, host %s" % REDIS_HOST)
store = RedisStore(
redis.StrictRedis(REDIS_HOST, REDIS_PORT, REDIS_DB, REDIS_PASS))
@app.get("/")
def read_index():
return FileResponse("./public/index.html")
from .rule import show_rule_vis
from .lime_viz import LimeViz
from .feature_selection import FeatureSelection
from .value_selection import ValueSelection
import uuid
import logging
logging.basicConfig(format='%(asctime)s %(message)s',filename='participants_access.log', level=logging.INFO)
limeviz = LimeViz()
fs = FeatureSelection()
vs = ValueSelection()
app = FastAPI()
app.mount("/embedded", StaticFiles(directory="app/embedded/dist/embedded",html =True), name="embedded")
@app.get("/")
def read_root():
return {"Hello": "World"}
@app.get("/rule")
def read_root():
return FileResponse(show_rule_vis())
@app.post("/fs")
async def read_root(request: Request):
body = await request.json()
logging.info(",reqId:"+str(request.state.requestId)+","+str(request.query_params)+",url="+str(request.url)+",body="+str(body))
print("hello")
from fastai.callback.all import *
from io import BytesIO
from fastapi import FastAPI, File, Form, UploadFile
from fastapi.responses import HTMLResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.middleware.cors import CORSMiddleware
import json
# import all additional Learner functions
from utils import *
#from utils import CutMixEdit
app = FastAPI()
app.add_middleware(CORSMiddleware, allow_origins=['*'],allow_headers=["*"])
app.mount('/static', StaticFiles(directory='app/static'), name="static")
path = Path(__file__).parent
export_file_url = 'https://storage.googleapis.com/fastai-export-bucket/v1-xresnet18-80epoch-standard-cutmix%2Bmixup.pkl' # google cloud bucket
export_file_name = 'export.pkl'
# with open('app/classes.txt', 'r') as f:
# classes = ast.literal_eval(f.read())
async def download_file(url, dest):
print("Attempting pkl file download")
print("url:", url)
print("dest:", dest)
"""Fast-API Module for SEPIA STT Server"""
from fastapi import FastAPI, Response, WebSocket, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.responses import RedirectResponse
from launch import settings, SERVER_NAME, SERVER_VERSION
from http_api import HttpApiEndpoint, SettingsRequest
from socket_api import WebsocketApiEndpoint
# App
app = FastAPI()
app.mount("/www", StaticFiles(directory="www"))
# CORS setup
app.add_middleware(CORSMiddleware,
allow_origins=settings.cors_origins,
allow_credentials=True,
allow_headers=["*"],
allow_methods=["*"])
http_endpoint = HttpApiEndpoint()
socket_endpoint = WebsocketApiEndpoint()
@app.get("/")
async def get():
"""Redirect to web interface or docs page"""
return RedirectResponse(url='www/index.html')
from datetime import timedelta
from os import access
from fastapi import FastAPI, Depends
from fastapi.staticfiles import StaticFiles
import petgram.db as db
from petgram.api import home, ping, users
app = FastAPI()
app.mount("/frontend/static", StaticFiles(directory="frontend/static"))
@app.on_event("startup")
async def startup():
await db.database.connect()
@app.on_event("shutdown")
async def shutdown():
await db.database.disconnect()
# ow whenever you want your user to be logged in to use a route, you can simply use your LoginManager instance as a dependency.
# @app.get('/protected')
# def protected_route(user=Depends(manager)):
# ...
# user_id = await crud.post(payload)
# response_object = {
# "id": user_id,
"""
firstPage = fr"https://www.handspeak.com/word/search/app/app-dictionary.php"
firstResult = BeautifulSoup(
await textPOST(firstPage, {"query": query}),
'html.parser'
)
source = firstResult.find("a")
if source is not None:
url = source["href"]
secondPage = "https://www.handspeak.com" + url
secondResult = BeautifulSoup(
await textGET(secondPage),
'html.parser'
)
if secondResult is not None:
video_url = secondResult.find("video")["src"]
mean = secondResult.find_all("p")[1].text
return searchTemplate.render(
website = "HandSpeak",
url = secondPage,
sign = escape_string(query).upper(),
video = "https://www.handspeak.com" + video_url,
meaning = mean,
icon = "https://www.handspeak.com/favicon.ico"
)
"""
return searchErr
app.mount("/", StaticFiles(directory="public_html"), name="static")
import uvicorn
from fastapi import BackgroundTasks, FastAPI, File, UploadFile, Form, Query
from fastapi.staticfiles import StaticFiles
import uuid
import logging
import pandas as pd
from definitions import CSV_DIRECTORY
from api import GeocodeTask
app = FastAPI()
task = GeocodeTask()
logger = logging.getLogger(__name__)
app.mount("/csv", StaticFiles(directory=CSV_DIRECTORY), name="csv")
@app.post("/run")
async def geo_encode(background_tasks: BackgroundTasks, csv_file: UploadFile = File(...),
columns: str = Form(...)):
if task.in_progress():
return {'success': False, 'error': 'There is not finished task. Please wait until it will be finished.'}
try:
if csv_file and columns:
input_dataframe = pd.read_csv(csv_file.file, delimiter=";")
input_columns = columns.split(',')
else:
raise ValueError('Please, provide input data as a form-data')
task_id = uuid.uuid4()
background_tasks.add_task(task.run, input_dataframe, input_columns, task_id)
from decouple import config
from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
from pydantic import BaseModel
app = FastAPI(debug=True)
app.mount('/assets', StaticFiles(directory='assets'), name='assets')
templates = Jinja2Templates(directory='templates')
class HackedUser(BaseModel):
username: str
password: str
conf = ConnectionConfig(MAIL_FROM="*****@*****.**",
MAIL_USERNAME=config('MAIL_USERNAME'),
MAIL_PASSWORD=config('MAIL_PASSWORD'),
MAIL_PORT=config('MAIL_PORT'),
MAIL_SERVER=config('MAIL_SERVER'),
MAIL_TLS=True,
MAIL_SSL=False,
USE_CREDENTIALS=True)
@app.get("/", response_class=HTMLResponse)
async def root(request: Request):
context = {'request': request}
# We want to be flexible in our localhost demo so we'll set
# very open CORS policies.
origins = [
"http://localhost",
"http://*****:*****@app.get("/", response_class=HTMLResponse)
def index():
from .routers import setup_router, tags_metadata
from .exception import setup_exception_handler
from .csrf import csrf_provider
from .sql.core import init_db
from .sql.orm import orm_metadata
app = FastAPI(
title="Simple Member System Implementation by FastAPI",
description=("Simple Member System Implementation "
"(source: https://github.com/ShenTengTu/py_sms_impl) ."),
version=__version__,
docs_url="/api-doc",
redoc_url=None,
openapi_tags=tags_metadata,
)
app.mount("/static", StaticFiles(directory=str(path_static)), name="static")
@app.on_event("startup")
async def startup_event():
load_translations("en_US", "zh_TW", domain="py_sms_impl")
init_db(orm_metadata())
setup_exception_handler(app)
setup_middleware(app)
setup_router(app)
@app.get("/", tags=["Page"], response_class=TemplateResponseClass)
async def root(request: Request):
news,
ships,
systems,
)
Base.metadata.create_all(bind=engine)
app = FastAPI(
title="ED-API",
description="An API for Elite Dangerous 🌌.",
version=__version__,
)
@app.exception_handler(Exception)
def exception_callback(*args: Any, **kwargs: Any) -> JSONResponse:
"""Register an exception callback for default exceptions."""
return JSONResponse({"detail": "Unhandled error"}, status_code=500)
app.include_router(commodities.router)
app.include_router(community_goals.router)
app.include_router(galnet.router)
app.include_router(health.router)
app.include_router(news.router)
app.include_router(ships.router)
app.include_router(systems.router)
app.mount(f"/{STATIC_PATH}",
StaticFiles(directory=STATIC_PATH),
name=STATIC_PATH)
from pydantic import BaseModel
from book import BookObject
app = FastAPI()
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.mount("/data/books/img",
StaticFiles(directory="../data/books/img"),
name="static")
class Book(BaseModel):
progress: Optional[int] = None
isbn: str
tip: Optional[str] = None
title: Optional[str] = None
author: Optional[str] = None
page: Optional[str] = None
def name_get(user: str):
return '../data/user/' + user + '.json'
from fastapi.staticfiles import StaticFiles
from starlette.responses import FileResponse
from pydantic import BaseModel
import uvicorn
import src.core.multi_game_manager as game_mgr
frontend = "xterm"
if os.path.exists(f"{frontend}_frontend"):
public_dir = f"{frontend}_frontend/build"
else:
public_dir = f"../{frontend}_frontend/build"
app = FastAPI()
app.mount("/static", StaticFiles(directory=f"{public_dir}/static"), 'static')
class StartRequest(BaseModel):
user: str
game: str
password: str
class UpdateRequest(BaseModel):
session_id: str
command: str
@app.get("/api/.*", status_code=404)
def invalid_api():
def setup():
os.makedirs(STATIC_FILES_DIR, exist_ok=True)
os.makedirs(USER_IMAGES_DIR, exist_ok=True)
load_dotenv()
max_image_size = int(os.getenv("MAX_IMAGE_SIZE"))
return {"max_image_size": max_image_size}
setup_config = setup()
app = FastAPI()
app.mount(STATIC_FILES_DIR,
StaticFiles(directory=STATIC_FILES_DIR),
name="static")
templates = Jinja2Templates(directory=TEMPLATES_DIR)
generator = PreTrainSystem.load_from_checkpoint(
PRETRAINED_MODEL_CHECKPOINT_PATH).generator
# device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
device = torch.device("cpu")
generator.to(device)
@app.get("/")
@app.get("/index")
async def index(request: Request):
return templates.TemplateResponse("index.html", {"request": request})
from fastapi import FastAPI, Request
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel
app = FastAPI()
app.mount('/static', StaticFiles(directory='../ui/dist'))
templates = Jinja2Templates(directory='../ui')
class Item(BaseModel):
name: str
description: str
@app.get('/', response_model=Item)
async def index(request: Request):
item = Item(name='123', description='234')
return templates.TemplateResponse('index.html', {'request': request, 'item': item})
from fastapi import FastAPI, Request, UploadFile, Form, File
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import uvicorn
from fastpreprocess.process import *
import os
filedetail = None
fastprocess = None
process = None
app = FastAPI()
path = str(__file__)
app.mount("/static",
StaticFiles(directory=path[:-11] + 'static'),
name='static')
templates = Jinja2Templates(directory=path[:-11] + 'template')
#____________________________________________________________________________________________________________________________________
@app.get('/')
async def home(requset: Request):
return process_data(requset)
@app.get('/index')
async def index(request: Request):
return templates.TemplateResponse('Index.html',
context={
'request': request,
await database.disconnect()
@fastapi_users.on_after_register()
def on_after_register(user: User, request: Request):
print(f"User {user.id} has registered.")
@fastapi_users.on_after_forgot_password()
def on_after_forgot_password(user: User, token: str, request: Request):
print(f"User {user.id} has forgot their password. Reset token: {token}")
app.mount(
"/static",
StaticFiles(directory=pkg_resources.resource_filename(__name__, 'static')),
name="static")
@app.get("/", include_in_schema=False)
def root():
return FileResponse(
pkg_resources.resource_filename(__name__, '/static/index.html'))
@app.get("/organizations/{reload}/")
async def get_organizations(reload: bool):
org = fetch_organizations(reload)
return json.loads(org)
connection=app.db,
)
try:
await shortened.create(code)
except aiosqlite.IntegrityError:
raise HTTPException(400, "Too many links are using this length - Please increase.")
return {"url": f"https://{host}/{code}", "code": code}
@app.delete("/v/{code}")
async def delete_vanity_code(code: str, token: str):
"""Deletes a shortened URL."""
async with app.db.execute(
"""
SELECT source, token FROM short WHERE serve=?
""",
(code,),
) as cursor:
source = await cursor.fetchone()
if not source:
raise HTTPException(404, "Invalid code.")
_, key = source
if key != token:
raise HTTPException(401, "Unauthorized")
await app.db.execute("DELETE FROM short WHERE serve=?", (code,))
await app.db.commit()
return JSONResponse({}, 204)
app.mount("/", StaticFiles(directory="./static", html=True))
from fastapi import FastAPI
from app.api.v2 import api_router
from fastapi.staticfiles import StaticFiles
from fastapi.middleware.cors import CORSMiddleware
from typing import Any, Dict, List, Optional, Union
from pydantic import AnyHttpUrl, BaseSettings, EmailStr, HttpUrl, PostgresDsn, validator
from app.config.setting import settings
app = FastAPI()
app.mount("/images",
StaticFiles(directory="uploaded/images", html=True),
name="images")
# Set all CORS enabled origins
if settings.BACKEND_CORS_ORIGINS:
print("Cors settings : ", settings.BACKEND_CORS_ORIGINS)
app.add_middleware(
CORSMiddleware,
allow_origins=[
str(origin) for origin in settings.BACKEND_CORS_ORIGINS
],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
else:
print("No cors settings")
# app.include_router(api_router, prefix="/api/v1")
app.include_router(api_router, prefix="/api/v2")
from fastapi import FastAPI, Request,Body
import uvicorn
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from router import user
app = FastAPI()
app.include_router(
user.router,
prefix='/users',
tags= ['users'],
responses={
401: {'description': 'error'}
}
)
app.mount('/static', StaticFiles(directory='static'), name='static')
templates = Jinja2Templates(directory='templates')
@app.get('/index')
async def index(request: Request):
return templates.TemplateResponse('index.html', context={'request':request})
if __name__ == "__main__":
uvicorn.run("app:app", debug=True)
import datetime
import numpy as np
app = FastAPI()
origins = ["http://localhost:3000", "http://gasp.databake.nl"]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.mount("/dashboard", StaticFiles(directory="dashboard"), name="dashboard")
class ServerState:
def __init__(self):
dataset = "HELSINKI_100x100m_3mo.nc4"
xds = xr.open_dataset(dataset)
self.oldestTimestamp = xds.time.values.min()
self.newestTimestamp = xds.time.values.max()
self.diffdays = self.indays(self.newestTimestamp -
self.oldestTimestamp)
self.timestampfmt = '%Y-%m-%dT%H:%M:%S.%f'
self.timerange = lambda t: (t - np.timedelta64(2, 'h'), t + np.
timedelta64(8, 'h'))
self.ranges = json.load(open("ranges.json", "r"))
self.g = Grid(xds.lat.values, xds.lon.values)
