from rio_tiler.utils import render from rio_tiler.colormap import get_colormap from rio_tiler.profiles import img_profiles from starlette.requests import Request from starlette.responses import Response, HTMLResponse from starlette.templating import Jinja2Templates from starlette.middleware.cors import CORSMiddleware from starlette.middleware.gzip import GZipMiddleware from fastapi import FastAPI, Query import uvicorn dir = os.path.dirname(__file__) templates = Jinja2Templates(directory=f"{dir}/templates") _postprocess_tile = partial(run_in_threadpool, postprocess_tile) _render = partial(run_in_threadpool, render) class viz(object): """Creates a very minimal slippy map tile server using fastAPI + Uvicorn.""" def __init__( self, raster, token: str = None, port: int = 8080, host: str = "127.0.0.1", style: str = "satellite", ):
import os from urllib.parse import urlencode import httpbin from asgiref.wsgi import WsgiToAsgi from starlette.applications import Starlette from starlette.responses import PlainTextResponse, Response from starlette.staticfiles import StaticFiles from starlette.templating import Jinja2Templates from starlette.websockets import WebSocketDisconnect ROOT = os.path.dirname(__file__) LOGS_PATH = os.path.join(ROOT, "htdocs", "logs") QVIS_URL = "https://qvis.edm.uhasselt.be/" templates = Jinja2Templates(directory=os.path.join(ROOT, "templates")) app = Starlette() # list of all connections established over the runtime list_of_connections = [] @app.websocket_route("/ws") async def ws(websocket): """ WebSocket echo endpoint. """ if "chat" in websocket.scope["subprotocols"]: subprotocol = "chat" else: subprotocol = None await websocket.accept(subprotocol=subprotocol)
from typing import Any, Dict from covid_api import version from covid_api.api.api_v1.api import api_router from covid_api.core import config from covid_api.db.memcache import CacheLayer from fastapi import FastAPI from starlette.middleware.cors import CORSMiddleware from starlette.middleware.gzip import GZipMiddleware from starlette.requests import Request from starlette.responses import HTMLResponse from starlette.templating import Jinja2Templates templates = Jinja2Templates(directory="covid_api/templates") if config.MEMCACHE_HOST and not config.DISABLE_CACHE: kwargs: Dict[str, Any] = { k: v for k, v in zip( ["port", "user", "password"], [ config.MEMCACHE_PORT, config.MEMCACHE_USERNAME, config.MEMCACHE_PASSWORD ], ) if v } cache = CacheLayer(config.MEMCACHE_HOST, **kwargs) else: cache = None
from starlette.requests import Request from starlette.templating import Jinja2Templates from services.report_service import get_reports import fastapi router = fastapi.APIRouter() templates = Jinja2Templates('templates') @router.get('/', include_in_schema=False) async def index(request: Request): events = await get_reports() data = {'request': request, 'events': events} return templates.TemplateResponse('home/index.html', data) @router.get('/favicon.ico', include_in_schema=False) def favicon(): return fastapi.responses.RedirectResponse(url='/static/img/favicon.ico')
from pathlib import Path from aopi_index_builder import get_context from starlette.templating import Jinja2Templates context = get_context() plugin_dir = Path(__file__).parent templates_dir = plugin_dir / "templates" templates = Jinja2Templates(directory=templates_dir)
import asyncio import os from starlette.applications import Starlette from starlette.templating import Jinja2Templates import uvicorn import processor from video import Video app = Starlette() templates = Jinja2Templates(directory='src/templates') VIDEOS_DIR = 'videos' @app.route('/') def homepage(request): return templates.TemplateResponse( 'index.html', { 'request': request, 'videos': os.listdir(VIDEOS_DIR) } ) @app.websocket_route("/ws") async def video_stream(ws):
import fastai from fastai.vision import * from fastai.callbacks import * from fastai.utils.mem import * import asyncio, aiohttp from starlette.applications import Starlette from starlette.responses import HTMLResponse from starlette.staticfiles import StaticFiles from starlette.middleware.cors import CORSMiddleware from starlette.templating import Jinja2Templates ## INITIALIZING SERVER templates = Jinja2Templates(directory='app/templates') app = Starlette() app.add_middleware(CORSMiddleware, allow_origins=['*'], allow_headers=['X-Requested-With', 'Content-Type']) app.mount('/static', StaticFiles(directory='app/static')) ## INITIALIZING UNET path = Path(__file__).parent #app/ export_file_url = 'https://www.dropbox.com/s/gkjx36g2sbd0x6v/export.pkl?raw=1' export_file_name = 'export.pkl' async def download_file(url, dest):
import uvicorn from starlette.applications import Starlette from starlette.responses import JSONResponse, RedirectResponse from starlette.routing import Route, Mount from starlette.templating import Jinja2Templates from starlette.staticfiles import StaticFiles from fastai.vision import * # Cell ON_JUPY = os.environ['_'].split('/')[-1].lower() == 'jupyter' static_dir = Path('pokedexr/static') if ON_JUPY else Path('static') # Cell templates = Jinja2Templates(directory=static_dir / 'templates') static_files = StaticFiles(directory=static_dir) data_files = pathlib.Path(static_dir / 'data') # Cell print('Initialising Learner...') learn = load_learner(data_files, 'export.pkl') with open(data_files / 'cards.pkl', 'rb') as f: cards = pickle.load(f) # Cell # Cell async def home(request): return templates.TemplateResponse('index.html', {'request': request})
from pathlib import Path from typing import Any from fastapi import APIRouter, Request from starlette.responses import FileResponse from starlette.templating import Jinja2Templates from trees.url import base_url router = APIRouter() templetes = Jinja2Templates(directory='trees/templates') @router.get('/') async def get_main_page(req: Request): return templetes.TemplateResponse("main-page.html", { "request": req, "base_url": base_url }) @router.get('/report') async def get_report_page(req: Request): return templetes.TemplateResponse("report.html", { "request": req, "base_url": base_url }) @router.get('/volunteers') async def get_volunteers_page(req: Request): return templetes.TemplateResponse("volunteers.html", {
from fastapi import Request from sqlalchemy.orm import Session from starlette.templating import Jinja2Templates from repository import crud from repository.crud import db_breaker, get_order_by_id from repository.database import get_db from service.order_creation_service import create_and_save_order from repository.crud import get_paid_order_by_user_and_product from service.service_models import Order order_router = APIRouter() templates = Jinja2Templates(directory="frontend") @order_router.get("/orders", response_model=List[Order], summary="Fetch all orders", description="Fetches all of the orders.") def get_orders(db: Session = Depends(get_db)): return crud.get_orders(db, limit=100) @order_router.get("/create-order") def create_order(product_id: str, quantity: int, request: Request, db: Session = Depends(get_db)):
from fastapi_users import FastAPIUsers from fastapi_users.authentication import JWTAuthentication, CookieAuthentication from fastapi_users import models from starlette.templating import Jinja2Templates from src.models import user_db, UserDB, User SECRET_KEY = "^-r+qb5+fs7c#7%7j7_6)tvf%nnd4a41_2jm3gg9zp4v%x+h-@" templates = Jinja2Templates(directory="src/templates") auth_backends = [ JWTAuthentication(secret=SECRET_KEY, lifetime_seconds=6000), CookieAuthentication(secret=SECRET_KEY, lifetime_seconds=6000), ] fastapi_users = FastAPIUsers( user_db, auth_backends, User, models.BaseUserCreate, models.BaseUserUpdate, UserDB, SECRET_KEY )
pattern = re.compile(r'\w{4,20}') # 任意の4~20の英数字を示す正規表現 pattern_pw = re.compile(r'\w{6,20}') # 任意の6~20の英数字を示す正規表現 pattern_mail = re.compile( r'^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$') # e-mailの正規表現 app = FastAPI( title="FastAPIでつくるtoDoアプリケーション", description="FastAPIチュートリアル:FastAPI(とstarlette)でシンプルなtoDoアプリを作りましょう.", version="0.9 beta", ) security = HTTPBasic() # new テンプレート関連の設定 (jinja2) templates = Jinja2Templates(directory="app/templates") jinja_env = templates.env # Jinja2.Environment : filterやglobalの設定用 def index(request: Request): return templates.TemplateResponse("index.html", {"request": request}) def admin(request: Request, credentials: HTTPBasicCredentials = Depends(security)): # Basic認証で受け取った情報 username = auth(credentials) password = hashlib.md5(credentials.password.encode()).hexdigest() # データベースからユーザ名が一致するデータを取得 user = db.session.query(User).filter(User.username == username).first()
result_dict['stocks_pct_chg_min'] = stocks_pct_chg_min result_dict['stocks_pct_chg_avg'] = stocks_pct_chg_avg result_dict['stocks_limit_count'] = stocks_limit_count df_groupby_industry_result = df_groupby_industry_result.append( result_dict, ignore_index=True) #print (index_code,len(df_groupby_industry_result)) index_code += 1 return df_groupby_industry_result #df = get_realtime_analysis_category_industry() #模板渲染 #app = FastAPI() # 挂载模版文件夹 tmp = Jinja2Templates(directory='./api/templates') #主面板 #行业 #三大产业分类数据 @router.get('/industry/three') async def get_three(request: Request): # async加了就支持异步 把Request赋值给request js_res = INLINE.render_js() css_res = INLINE.render_css() industry_dict = get_col_df('industry_three').to_dict('records') return tmp.TemplateResponse( 'industry_three.html', { 'request': request,
from starlette.responses import JSONResponse from starlette.templating import Jinja2Templates from operator import itemgetter from pathlib import Path from ydl_server.config import app_config, get_finished_path from ydl_server.logdb import JobsDB, Job, Actions, JobType from datetime import datetime import os import shutil templates = Jinja2Templates(directory=str(Path(__file__).parent / "templates")) async def front_index(request): context = { 'request': request, 'ydl_version': request.app.state.ydlhandler.get_ydl_version(), 'ydl_name': request.app.state.ydlhandler.ydl_module_name, 'ydl_website': request.app.state.ydlhandler.ydl_website, } return templates.TemplateResponse('index.html', context=context) async def front_logs(request): context = { 'request': request, 'ydl_version': request.app.state.ydlhandler.get_ydl_version(), 'ydl_name': request.app.state.ydlhandler.ydl_module_name, 'ydl_website': request.app.state.ydlhandler.ydl_website, }
from fastapi_admin.schemas import BulkIn from fastapi_admin.site import Site TORTOISE_ORM = { "connections": { "default": os.getenv("DATABASE_URL") }, "apps": { "models": { "models": ["examples.models"], "default_connection": "default" } }, } templates = Jinja2Templates(directory="examples/templates") @admin_app.post("/rest/{resource}/bulk/test_bulk") async def test_bulk(bulk_in: BulkIn, model=Depends(get_model)): qs = model.filter(pk__in=bulk_in.pk_list) pydantic = pydantic_queryset_creator(model) ret = await pydantic.from_queryset(qs) return ret.dict() @admin_app.get( "/home", ) async def home(): return {"html": templates.get_template("home.html").render()}
from fastapi import FastAPI from starlette.staticfiles import StaticFiles from starlette.templating import Jinja2Templates import logmuse import sys import uvicorn from ubiquerg import parse_registry_path app = FastAPI( title=PKG_NAME, description="a web interface and RESTful API for reference genome assets", version=server_v ) app.mount("/" + STATIC_DIRNAME, StaticFiles(directory=STATIC_PATH), name=STATIC_DIRNAME) templates = Jinja2Templates(directory=TEMPLATES_PATH) def main(): global rgc, _LOGGER parser = build_parser() args = parser.parse_args() if not args.command: parser.print_help() print("No subcommand given") sys.exit(1) logger_args = dict(name=PKG_NAME, fmt=LOG_FORMAT, level=5) if args.debug else dict(name=PKG_NAME, fmt=LOG_FORMAT) _LOGGER = logmuse.setup_logger(**logger_args) selected_cfg = select_genome_config(args.config) assert selected_cfg is not None, "You must provide a config file or set the {} environment variable".\ format("or ".join(CFG_ENV_VARS))
def create_application( database_url: str, secret_key: str, jwt_key: typing.Union[None, bytes, JWKRepr] = None, jwt_signature_algorithm: str = "RS256", jwt_signature_params: typing.Dict[str, str] = {}, jwt_encryption_algorithm: str = "RS256", jwt_encryption_params: typing.Dict[str, str] = {}, debug: bool = False, max_pool_workers: int = 10, jwt_ttl: timedelta = timedelta(seconds=3600), region: str = "ap-northeast-1", prepended_routes: typing.Iterable[BaseRoute] = [], ): from .views import admin as admin_views from .views import index as index_views from .views import oauth2 as oauth2_views from .views import pools as pools_views logging.basicConfig( level=logging.DEBUG if debug else logging.INFO, force=True, ) if max_pool_workers > 0: executor.executor = concurrent.futures.ThreadPoolExecutor( max_workers=max_pool_workers ) session_factory.configure( bind=sa.create_engine(database_url), ) if jwt_key is None: jwt_key = generate_jwk(jwt_encryption_algorithm) jwt_public_key = jwt_key if isinstance(jwt_key, dict): if "kid" not in jwt_key: jwt_key = dict(jwt_key) jwt_key["kid"] = generate_key(16) jwt_public_key = build_jwt_public_key_from_private_key(jwt_key) jwt_config = JWTConfiguration( key=jwt_key, public_key=jwt_public_key, signature_algorithm=jwt_signature_algorithm, signature_params=jwt_signature_params, encryption_algorithm=jwt_encryption_algorithm, encryption_params=jwt_encryption_params, issuer="", ttl=jwt_ttl, ) routes: typing.List[BaseRoute] = list(prepended_routes) routes += [ Mount( "/static", app=StaticFiles(directory=str(basedir / "static")), name="static", ), Mount( "/admin", name="admin", app=admin_views.routes, ), Mount( "/oauth2", name="oauth2", app=oauth2_views.routes, ), Route( "/logout", oauth2_views.LogoutEndpoint, ), Mount( "/{pool}", name="pools", app=apply_middlewares( pools_views.routes, middleware=[ Middleware(PoolDetectionMiddleware), Middleware( AuthenticationMiddleware, backend=SessionAuthenticationBackend() ), ], ), ), Mount("/", index_views.routes), ] app = Starlette( debug=debug, routes=routes, middleware=[ Middleware(RequestTimeMiddleware), Middleware(SQLAlchemyMiddleware), Middleware(SessionMiddleware, secret_key=secret_key), Middleware(TemplateShortcutMiddleware), ], on_shutdown=[ lambda: ( executor.executor.shutdown(wait=True) if executor.executor is not None else None ), ], ) app.state.jwt_config = jwt_config app.state.region = region app.state.templates = Jinja2Templates(directory=str(basedir / "templates")) app.state.kdf = PasswordHasher() app.state.uuidgen = lambda: str(uuid.uuid4()) return app
from fastai2.vision.all import * from io import BytesIO from starlette.applications import Starlette from starlette.middleware.cors import CORSMiddleware from starlette.responses import HTMLResponse, JSONResponse from starlette.staticfiles import StaticFiles from starlette.templating import Jinja2Templates from starlette.routing import Route import logging from app_utils import * classes = ['Saab_9000', 'Saab_900', 'Saab_9-3', 'Saab_9-5'] templates = Jinja2Templates(directory=str('app/templates')) app = Starlette(debug=True) 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')) logger = logging.getLogger() logger.setLevel(logging.DEBUG) loop = asyncio.get_event_loop() tasks = [asyncio.ensure_future(setup_learner())] learn = loop.run_until_complete(asyncio.gather(*tasks))[0] loop.close()
import logging from fastapi import FastAPI from starlette.requests import Request from starlette.websockets import WebSocket from starlette.responses import HTMLResponse from starlette.templating import Jinja2Templates import asyncio from database.db import Database from database.models import WikiMap from utils.wikigraph import WikipediaGraph app = FastAPI() TEMPLATES = Jinja2Templates(directory="../static/templates") """ var simulation = d3.forceSimulation(nodes) .force("charge", d3.forceManyBody()) .force("link", d3.forceLink(links)) .force("center", d3.forceCenter()); try { Graph.graphData({ nodes: [...nodes, ...newNodes], links: [...links, ...newLinks] }); } catch(ReferenceError) { Graph.graphData({
from helpdesk.config import ( NOTIFICATION_TITLE_PREFIX, WEBHOOK_URL, ADMIN_EMAIL_ADDRS, FROM_EMAIL_ADDR, SMTP_SERVER, SMTP_SERVER_PORT, SMTP_SSL, SMTP_CREDENTIALS, get_user_email, ) logger = logging.getLogger(__name__) _templates = Jinja2Templates(directory='templates/notification') class Notification: method = None def __init__(self, phase, ticket): self.phase = phase self.ticket = ticket async def send(self): raise NotImplementedError def render(self): import xml.etree.ElementTree as ET
from starlette.applications import Starlette from starlette.responses import JSONResponse, HTMLResponse from starlette.routing import Route, Mount from starlette.templating import Jinja2Templates from starlette.staticfiles import StaticFiles from products_data import products_data templates = Jinja2Templates(directory='templates') async def homepage(request): return templates.TemplateResponse('e_commerce.html', {'request': request}) async def products(request): return JSONResponse(products_data) app = Starlette(debug=True, routes=[ Route('/', homepage), Route('/products', products), Mount('/static', StaticFiles(directory='static'), name='static') ])
import fastapi from starlette.requests import Request from starlette.templating import Jinja2Templates router = fastapi.APIRouter() templates = Jinja2Templates("templates") @router.get("/") def index(request: Request): return templates.TemplateResponse("home/index.html", {"request": request}) @router.get("/favicon.ico") def favicon(): return fastapi.responses.RedirectResponse(url="/static/img/favicon.ico")
AGGRID_ENTERPRISE = config('AGGRID_ENTERPRISE', cast=bool, default=False) NO_INTERNET = config('NO_INTERNET', cast=bool, default=True) def create_component_file_list(): file_list = [] component_dir = os.path.join(STATIC_DIRECTORY, 'components') if os.path.isdir(component_dir): for file in os.listdir(component_dir): if fnmatch.fnmatch(file, '*.js'): file_list.append(f'/components/{file}') return file_list templates = Jinja2Templates(directory=TEMPLATES_DIRECTORY) component_file_list = create_component_file_list() template_options = { 'tailwind': TAILWIND, 'quasar': QUASAR, 'quasar_version': QUASAR_VERSION, 'highcharts': HIGHCHARTS, 'aggrid': AGGRID, 'aggrid_enterprise': AGGRID_ENTERPRISE, 'static_name': STATIC_NAME, 'component_file_list': component_file_list, 'no_internet': NO_INTERNET } logging.basicConfig(level=LOGGING_LEVEL,
from morecantile import tms from morecantile.models import TileMatrixSet from rasterio.crs import CRS from rio_tiler.colormap import cmap, parse_color from fastapi import HTTPException, Query from starlette.templating import Jinja2Templates try: from importlib.resources import files as resources_files # type: ignore except ImportError: # Try backported to PY<39 `importlib_resources`. from importlib_resources import files as resources_files # type: ignore templates = Jinja2Templates( directory=str(resources_files(__package__) / "templates")) # colors from https://daac.ornl.gov/ABOVE/guides/Annual_Landcover_ABoVE.html above_cmap = { 1: [58, 102, 24, 255], # Evergreen Forest 2: [100, 177, 41, 255], # Deciduous Forest 3: [177, 177, 41, 255], # Shrubland 4: [221, 203, 154, 255], # Herbaceous 5: [218, 203, 47, 255], # Sparely Vegetated 6: [177, 177, 177, 255], # Barren 7: [175, 255, 205, 255], # Fen 8: [239, 255, 192, 255], # Bog 9: [144, 255, 255, 255], # Shallows/Littoral 10: [29, 0, 250, 255], # Water } cmap = cmap.register({"above": above_cmap})
def test_template_response_requires_request(tmpdir): templates = Jinja2Templates(str(tmpdir)) with pytest.raises(ValueError): templates.TemplateResponse(None, {})
from titiler.ressources.enums import ( ImageMimeTypes, ImageType, MimeTypes, PixelSelectionMethod, ) from titiler.ressources.responses import ImgResponse, XMLResponse from fastapi import APIRouter, Depends, Path, Query from starlette.concurrency import run_in_threadpool from starlette.requests import Request from starlette.templating import Jinja2Templates router = APIRouter() templates = Jinja2Templates(directory="titiler/templates") def _read_tile(url: str, *args, **kwargs) -> Tuple[numpy.ndarray, numpy.ndarray]: """Read tile from an asset""" with COGReader(url) as cog: tile, mask = cog.tile(*args, **kwargs) return tile, mask def _read_point(asset: str, *args, **kwargs) -> List: """Read pixel value at a point from an asset""" with COGReader(asset) as cog: return cog.point(*args, **kwargs)
class CustomHeaderMiddleware(BaseHTTPMiddleware): def __init__(self, app, header_value='Example'): print('__init__') super().__init__(app) self.header_value = header_value async def dispatch(self, request, call_next): response = await call_next(request) response.headers['Custom'] = self.header_value return response asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) app = FastAPI() app.add_middleware(CustomHeaderMiddleware) templates = Jinja2Templates(directory="templates") def get_local_ip(): """ copy and paste from https://stackoverflow.com/questions/166506/finding-local-ip-addresses-using-pythons-stdlib """ if os.environ.get('CHAT_HOST_IP', False): return os.environ['CHAT_HOST_IP'] try: ip = [l for l in ( [ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.")][:1], [ [(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in
def __init__(self, enablePiCamera=False, stabilize=False, source=0, camera_num=0, y_tube=False, backend=0, colorspace=None, resolution=(640, 480), framerate=25, logging=False, time_delay=0, **options): # initialize global params self.__jpeg_quality = 90 # 90% quality self.__jpeg_optimize = 0 # optimization off self.__jpeg_progressive = 0 # jpeg will be baseline instead self.__frame_size_reduction = 20 # 20% reduction self.__logging = logging custom_data_location = "" # path to save data-files to custom location data_path = "" # path to WebGear data-files overwrite_default = False # reformat dictionary options = {str(k).strip(): v for k, v in options.items()} # assign values to global variables if specified and valid if options: if "frame_size_reduction" in options: value = options["frame_size_reduction"] if isinstance(value, (int, float)) and value >= 0 and value <= 90: self.__frame_size_reduction = value else: logger.warning( "Skipped invalid `frame_size_reduction` value!") del options["frame_size_reduction"] # clean if "frame_jpeg_quality" in options: value = options["frame_jpeg_quality"] if isinstance(value, (int, float)) and value >= 10 and value <= 95: self.__jpeg_quality = int(value) else: logger.warning( "Skipped invalid `frame_jpeg_quality` value!") del options["frame_jpeg_quality"] # clean if "frame_jpeg_optimize" in options: value = options["frame_jpeg_optimize"] if isinstance(value, bool): self.__jpeg_optimize = int(value) else: logger.warning( "Skipped invalid `frame_jpeg_optimize` value!") del options["frame_jpeg_optimize"] # clean if "frame_jpeg_progressive" in options: value = options["frame_jpeg_progressive"] if isinstance(value, bool): self.__jpeg_progressive = int(value) else: logger.warning( "Skipped invalid `frame_jpeg_progressive` value!") del options["frame_jpeg_progressive"] # clean if "custom_data_location" in options: value = options["custom_data_location"] if isinstance(value, str): assert os.access( value, os.W_OK ), "[WebGear:ERROR] :: Permission Denied!, cannot write WebGear data-files to '{}' directory!".format( value) assert os.path.isdir( os.path.abspath(value) ), "[WebGear:ERROR] :: `custom_data_location` value must be the path to a directory and not to a file!" custom_data_location = os.path.abspath(value) else: logger.warning( "Skipped invalid `custom_data_location` value!") del options["custom_data_location"] # clean if "overwrite_default_files" in options: value = options["overwrite_default_files"] if isinstance(value, bool): overwrite_default = value else: logger.warning( "Skipped invalid `overwrite_default_files` value!") del options["overwrite_default_files"] # clean # define stream with necessary params self.stream = VideoGear(enablePiCamera=enablePiCamera, stabilize=stabilize, source=source, camera_num=camera_num, y_tube=y_tube, backend=backend, colorspace=colorspace, resolution=resolution, framerate=framerate, logging=logging, time_delay=time_delay, **options) # check if custom certificates path is specified if custom_data_location: data_path = generate_webdata( custom_data_location, overwrite_default=overwrite_default, logging=logging, ) else: # otherwise generate suitable path from os.path import expanduser data_path = generate_webdata( os.path.join(expanduser("~"), ".vidgear"), overwrite_default=overwrite_default, logging=logging, ) # log it if self.__logging: logger.debug( "`{}` is the default location for saving WebGear data-files.". format(data_path)) if self.__logging: logger.debug( "Setting params:: Size Reduction:{}%, JPEG quality:{}%, JPEG optimizations:{}, JPEG progressive:{}" .format( self.__frame_size_reduction, self.__jpeg_quality, bool(self.__jpeg_optimize), bool(self.__jpeg_progressive), )) # define Jinja2 templates handler self.__templates = Jinja2Templates( directory="{}/templates".format(data_path)) # define custom exception handlers self.__exception_handlers = { 404: self.__not_found, 500: self.__server_error } # define routing tables self.routes = [ Route("/", endpoint=self.__homepage), Route("/video", endpoint=self.__video), Mount( "/static", app=StaticFiles(directory="{}/static".format(data_path)), name="static", ), ] # copying original routing tables for further validation self.__rt_org_copy = self.routes[:] # keeps check if producer loop should be running self.__isrunning = True
def __init__(self, enablePiCamera=False, stabilize=False, source=None, camera_num=0, stream_mode=False, backend=0, colorspace=None, resolution=(640, 480), framerate=25, logging=False, time_delay=0, **options): """ This constructor method initializes the object state and attributes of the WebGear_RTC class. Parameters: enablePiCamera (bool): provide access to PiGear(if True) or CamGear(if False) APIs respectively. stabilize (bool): enable access to Stabilizer Class for stabilizing frames. camera_num (int): selects the camera module index which will be used as Rpi source. resolution (tuple): sets the resolution (i.e. `(width,height)`) of the Rpi source. framerate (int/float): sets the framerate of the Rpi source. source (based on input): defines the source for the input stream. stream_mode (bool): controls the exclusive YouTube Mode. backend (int): selects the backend for OpenCV's VideoCapture class. colorspace (str): selects the colorspace of the input stream. logging (bool): enables/disables logging. time_delay (int): time delay (in sec) before start reading the frames. options (dict): provides ability to alter Tweak Parameters of WebGear_RTC, CamGear, PiGear & Stabilizer. """ # raise error(s) for critical Class imports import_dependency_safe("starlette" if starlette is None else "") import_dependency_safe("aiortc" if aiortc is None else "") # initialize global params self.__logging = logging custom_data_location = "" # path to save data-files to custom location data_path = "" # path to WebGear_RTC data-files overwrite_default = False self.__relay = None # act as broadcaster # reformat dictionary options = {str(k).strip(): v for k, v in options.items()} # assign values to global variables if specified and valid if options: if "custom_data_location" in options: value = options["custom_data_location"] if isinstance(value, str): assert os.access( value, os.W_OK ), "[WebGear_RTC:ERROR] :: Permission Denied!, cannot write WebGear_RTC data-files to '{}' directory!".format( value) assert os.path.isdir( os.path.abspath(value) ), "[WebGear_RTC:ERROR] :: `custom_data_location` value must be the path to a directory and not to a file!" custom_data_location = os.path.abspath(value) else: logger.warning( "Skipped invalid `custom_data_location` value!") del options["custom_data_location"] # clean if "overwrite_default_files" in options: value = options["overwrite_default_files"] if isinstance(value, bool): overwrite_default = value else: logger.warning( "Skipped invalid `overwrite_default_files` value!") del options["overwrite_default_files"] # clean if "enable_live_broadcast" in options: value = options["enable_live_broadcast"] if isinstance(value, bool): if value: self.__relay = MediaRelay() options[ "enable_infinite_frames"] = True # enforce infinite frames logger.critical( "Enabled live broadcasting for Peer connection(s)." ) else: None else: logger.warning( "Skipped invalid `enable_live_broadcast` value!") del options["enable_live_broadcast"] # clean # check if custom certificates path is specified if custom_data_location: data_path = generate_webdata( custom_data_location, c_name="webgear_rtc", overwrite_default=overwrite_default, logging=logging, ) else: # otherwise generate suitable path data_path = generate_webdata( os.path.join(expanduser("~"), ".vidgear"), c_name="webgear_rtc", overwrite_default=overwrite_default, logging=logging, ) # log it if self.__logging: logger.debug( "`{}` is the default location for saving WebGear_RTC data-files." .format(data_path)) # define Jinja2 templates handler self.__templates = Jinja2Templates( directory="{}/templates".format(data_path)) # define custom exception handlers self.__exception_handlers = { 404: self.__not_found, 500: self.__server_error } # define routing tables self.routes = [ Route("/", endpoint=self.__homepage), Route("/offer", self.__offer, methods=["GET", "POST"]), Mount( "/static", app=StaticFiles(directory="{}/static".format(data_path)), name="static", ), ] # define middleware support self.middleware = [] # Handle RTC video server if source is None: self.config = {"server": None} self.__default_rtc_server = None if self.__logging: logger.warning("Given source is of NoneType!") else: # Handle video source self.__default_rtc_server = RTC_VideoServer( enablePiCamera=enablePiCamera, stabilize=stabilize, source=source, camera_num=camera_num, stream_mode=stream_mode, backend=backend, colorspace=colorspace, resolution=resolution, framerate=framerate, logging=logging, time_delay=time_delay, **options) # define default frame generator in configuration self.config = {"server": self.__default_rtc_server} # add exclusive reset connection node self.routes.append( Route("/close_connection", self.__reset_connections, methods=["POST"])) # copying original routing tables for further validation self.__rt_org_copy = self.routes[:] # collects peer RTC connections self.__pcs = set()
from fastapi import FastAPI from starlette.requests import Request from starlette.staticfiles import StaticFiles from starlette.templating import Jinja2Templates from . import auth from .api.v1 import api_v1 app = FastAPI(debug=True) # pylint: disable=invalid-name base_dir = Path(__file__).parent app.mount("/static", StaticFiles(directory=str(base_dir / "static")), name="static") app.mount("/api/v1", api_v1) templates = Jinja2Templates(directory=str(base_dir / "templates")) app.include_router( auth.router, tags=["Authentication"], prefix="/api" ) @app.get("/.*") async def index(request: Request): """Index url, let frontend handle all routes.""" return templates.TemplateResponse("index.html", {"request": request}) @app.middleware("http")