from starlette.middleware.cors import CORSMiddleware
import uvicorn, aiohttp, asyncio
from io import BytesIO
from fastai import *
from fastai.vision import *
export_file_url = 'https://drive.google.com/uc?export=download&id=1h0WxhZgoyC-ZdYD_xFmY0ATWpWCiIftB'
export_file_name = 'export.pkl'
classes = ['football','hockey','rugby']
path = Path(__file__).parent
app = Starlette()
app.add_middleware(CORSMiddleware, allow_origins=['*'], allow_headers=['X-Requested-With', 'Content-Type'])
app.mount('/static', StaticFiles(directory='app/static'))
async def download_file(url, dest):
if dest.exists(): return
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
data = await response.read()
with open(dest, 'wb') as f: f.write(data)
async def setup_learner():
await download_file(export_file_url, path/export_file_name)
try:
learn = load_learner(path, export_file_name)
return learn
except RuntimeError as e:
if len(e.args) > 0 and 'CPU-only machine' in e.args[0]:
export_file_url = 'https://drive.google.com/u/0/uc?id=1WYfn_ABdsy1yOKGuCbcThVCWSQmFSFWT&export=download'
export_file_name = 'export.pkl'
classes = [
'deskchairs', 'directorchairs', 'ladderbackchairs', 'stools',
'widsorchairs'
]
path = Path(__file__).parent
templates = Jinja2Templates(directory=str('app/templates'))
app = Starlette()
app.add_middleware(CORSMiddleware,
allow_origins=['*'],
allow_headers=['X-Requested-With', 'Content-Type'])
app.mount('/static', StaticFiles(directory='app/static'))
app.mount('/templates', StaticFiles(directory='app/templates'))
async def download_file(url, dest):
if dest.exists(): return
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
data = await response.read()
with open(dest, 'wb') as f:
f.write(data)
async def setup_learner():
await download_file(export_file_url, path / export_file_name)
try:
dest='dbDir',
default='/tmp/traveler-integrated',
help=
'Directory where the bundled data is already / will be stored (default: /tmp/traveler-integrated)'
)
parser.add_argument(
'-s',
'--debug',
dest='debug',
action='store_true',
help='Store additional information for debugging source files, etc.')
args = parser.parse_args()
db = DataStore(args.dbDir, args.debug)
app = FastAPI(title=__name__, description='This is a test', version='0.1.0')
app.mount('/static', StaticFiles(directory='static'), name='static')
def checkDatasetExistence(label):
if label not in db:
raise HTTPException(status_code=404, detail='Dataset not found')
def checkDatasetHasIntervals(label):
if 'intervals' not in db[label] or 'intervalIndexes' not in db[label]:
raise HTTPException(
status_code=404,
detail='Dataset does not contain indexed interval data')
def iterUploadFile(text):
import os
from fastapi import Request
import uvicorn
from fastapi import FastAPI
from starlette.staticfiles import StaticFiles
from repository.database import initialize_database
from web.order_controller import order_router
from web.payment_controller import stripe_router
from config import orders_ip, orders_port, consul_port, consul_ip
from starlette_exporter import PrometheusMiddleware, handle_metrics
app = FastAPI()
#static_dir = str(os.path.abspath(os.path.join(__file__, "..")))
app.mount("/frontend", StaticFiles(directory="frontend"), name="frontend")
app.add_middleware(PrometheusMiddleware)
app.add_route("/metrics", handle_metrics)
app.include_router(
stripe_router,
tags=["stripe payments"],
responses={404: {
"description": "Not found"
}},
)
app.include_router(
order_router,
tags=["order"],
yield db
finally:
db.close()
models.Base.metadata.create_all(bind=engine)
import uuid
from pathlib import Path
import time
#from fastapi.staticfiles import StaticFiles
from starlette.staticfiles import StaticFiles
import os
from os.path import dirname, abspath, join
import shutil
router.mount("/static", StaticFiles(directory="static"), name="static")
dirname = dirname(dirname(abspath(__file__)))
images_path = join(dirname, '/static')
@router.post("/vidographer/")
def create_videographer(
desc:str,name:str,file_pro: UploadFile= File(...), file_cover: UploadFile= File(...), db: Session = Depends(get_db)
):
extension_pro = file_pro.filename.split(".")[-1] in ("jpg", "jpeg", "png")
if not extension_pro:
return "Image must be jpg or png format!"
suffix_pro = Path(file_pro.filename).suffix
filename_pro = time.strftime( str(uuid.uuid4().hex) + "%Y%m%d-%H%M%S" + suffix_pro )
with open("static/"+filename_pro, "wb") as image:
shutil.copyfileobj(file_pro.file, image)
import uvicorn
from fastapi import FastAPI
from starlette.staticfiles import StaticFiles
from src.app.routes.users import router as users_router
api = FastAPI(title='Authentication Service', version='0.1')
api.mount("/static", StaticFiles(directory='src/static'), name='static')
api.include_router(users_router)
if __name__ == '__main__':
uvicorn.run(api, host='127.0.0.1', port=8000)
import os
from fastapi import FastAPI, HTTPException
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.staticfiles import StaticFiles
from .. import constants
from .routes import router
app = FastAPI(title="API docs of ReArq")
app.mount(
"/static",
StaticFiles(directory=os.path.join(constants.BASE_DIR, "rearq", "server", "static")),
name="static",
)
app.include_router(router)
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
return JSONResponse(status_code=exc.status_code, content={"msg": exc.detail},)
def configure_routing():
# Opt in making fastAPI pick the 'static' dir to use it
api.mount('/static', StaticFiles(directory='static'), name='static')
# Setup routers
api.include_router(home.router)
api.include_router(weather_api.router)