Exemple #1
0
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"],
Exemple #5
0
        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)
Exemple #6
0
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)
Exemple #7
0
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)