async def _get(self, request: Request, con: Connection) -> Response: data = await self.get_data(con, request.path_params["gametype_id"]) result = "" for row in data["response"]: result += ( ";".join( [ row["name"], str(row["rating"]), str(row["n"]), "http://qlstats.net/player/" + row["_id"], ] ) + "\n" ) resp = Response(result) resp.headers["Content-Disposition"] = ( "attachment; filename=" + request.path_params["gametype"] + "_ratings.csv" ) resp.headers["Content-Type"] = "text/csv" return resp
def DbIndirbAPI(n: int = 3): return Response(content=do_db_indirb(n), media_type='text/plain')
def DbTxAPI(b: bool = False): return Response(content=str(do_db_json(b)), media_type='text/plain')
async def put_researcher(entity_id, request: Request): body = await request.body() request.app.db['researchers'][entity_id] = body return Response(content=body)
async def read_root(request: Request): client_host = request.client.host response = "hello %s" % client_host return Response(content=response)
def part( minx: float = Path(..., description="Bounding box min X"), miny: float = Path(..., description="Bounding box min Y"), maxx: float = Path(..., description="Bounding box max X"), maxy: float = Path(..., description="Bounding box max Y"), format: ImageType = Query(None, description="Output image type."), src_path=Depends(self.path_dependency), layer_params=Depends(self.layer_dependency), image_params=Depends(self.img_dependency), dataset_params=Depends(self.dataset_dependency), render_params=Depends(self.render_dependency), kwargs: Dict = Depends(self.additional_dependency), ): """Create image from part of a dataset.""" timings = [] headers: Dict[str, str] = {} with utils.Timer() as t: with self.reader(src_path.url, **self.reader_options) as src_dst: data, mask = src_dst.part( [minx, miny, maxx, maxy], **layer_params.kwargs, **image_params.kwargs, **dataset_params.kwargs, **kwargs, ) colormap = render_params.colormap or getattr( src_dst, "colormap", None) timings.append(("dataread", round(t.elapsed * 1000, 2))) if not format: format = ImageType.jpg if mask.all() else ImageType.png with utils.Timer() as t: data = utils.postprocess( data, mask, rescale=render_params.rescale, color_formula=render_params.color_formula, ) timings.append(("postprocess", round(t.elapsed * 1000, 2))) with utils.Timer() as t: dst_transform = from_bounds(minx, miny, maxx, maxy, data.shape[2], data.shape[1]) content = utils.reformat( data, mask if render_params.return_mask else None, format, colormap=colormap, transform=dst_transform, crs=WGS84_CRS, ) timings.append(("format", round(t.elapsed * 1000, 2))) if timings: headers["Server-Timing"] = ", ".join( [f"{name};dur={time}" for (name, time) in timings]) return Response( content, media_type=ImageMimeTypes[format.value].value, headers=headers, )
async def solve_dependencies( *, request: Union[Request, WebSocket], dependant: Dependant, body: Optional[Union[Dict[str, Any], FormData]] = None, background_tasks: BackgroundTasks = None, response: Response = None, dependency_overrides_provider: Any = None, dependency_cache: Dict[Tuple[Callable, Tuple[str]], Any] = None, ) -> Tuple[Dict[str, Any], List[ErrorWrapper], Optional[BackgroundTasks], Response, Dict[Tuple[Callable, Tuple[str]], Any], ]: values: Dict[str, Any] = {} errors: List[ErrorWrapper] = [] response = response or Response( content=None, status_code=None, # type: ignore headers=None, media_type=None, background=None, ) dependency_cache = dependency_cache or {} sub_dependant: Dependant for sub_dependant in dependant.dependencies: sub_dependant.call = cast(Callable, sub_dependant.call) sub_dependant.cache_key = cast(Tuple[Callable, Tuple[str]], sub_dependant.cache_key) call = sub_dependant.call use_sub_dependant = sub_dependant if (dependency_overrides_provider and dependency_overrides_provider.dependency_overrides): original_call = sub_dependant.call call = getattr(dependency_overrides_provider, "dependency_overrides", {}).get(original_call, original_call) use_path: str = sub_dependant.path # type: ignore use_sub_dependant = get_dependant( path=use_path, call=call, name=sub_dependant.name, security_scopes=sub_dependant.security_scopes, ) solved_result = await solve_dependencies( request=request, dependant=use_sub_dependant, body=body, background_tasks=background_tasks, response=response, dependency_overrides_provider=dependency_overrides_provider, dependency_cache=dependency_cache, ) ( sub_values, sub_errors, background_tasks, sub_response, sub_dependency_cache, ) = solved_result sub_response = cast(Response, sub_response) response.headers.raw.extend(sub_response.headers.raw) if sub_response.status_code: response.status_code = sub_response.status_code dependency_cache.update(sub_dependency_cache) if sub_errors: errors.extend(sub_errors) continue if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache: solved = dependency_cache[sub_dependant.cache_key] elif inspect.isgeneratorfunction(call) or inspect.isasyncgenfunction( call): stack = request.scope.get("fastapi_astack") if stack is None: raise RuntimeError(async_contextmanager_dependencies_error ) # pragma: no cover solved = await solve_generator(call=call, stack=stack, sub_values=sub_values) elif is_coroutine_callable(call): solved = await call(**sub_values) else: solved = await run_in_threadpool(call, **sub_values) if sub_dependant.name is not None: values[sub_dependant.name] = solved if sub_dependant.cache_key not in dependency_cache: dependency_cache[sub_dependant.cache_key] = solved path_values, path_errors = request_params_to_args(dependant.path_params, request.path_params) query_values, query_errors = request_params_to_args( dependant.query_params, request.query_params) header_values, header_errors = request_params_to_args( dependant.header_params, request.headers) cookie_values, cookie_errors = request_params_to_args( dependant.cookie_params, request.cookies) values.update(path_values) values.update(query_values) values.update(header_values) values.update(cookie_values) errors += path_errors + query_errors + header_errors + cookie_errors if dependant.body_params: ( body_values, body_errors, ) = await request_body_to_args( # body_params checked above required_params=dependant.body_params, received_body=body) values.update(body_values) errors.extend(body_errors) if dependant.request_param_name and isinstance(request, Request): values[dependant.request_param_name] = request elif dependant.websocket_param_name and isinstance(request, WebSocket): values[dependant.websocket_param_name] = request if dependant.background_tasks_param_name: if background_tasks is None: background_tasks = BackgroundTasks() values[dependant.background_tasks_param_name] = background_tasks if dependant.response_param_name: values[dependant.response_param_name] = response if dependant.security_scopes_param_name: values[dependant.security_scopes_param_name] = SecurityScopes( scopes=dependant.security_scopes) return values, errors, background_tasks, response, dependency_cache
async def put_process(entity_id, request: Request): body = await request.body() request.app.db['processes'][entity_id] = body return Response(content=body)
async def get_logout_response(self, user: BaseUserDB, response: Response) -> Any: response.delete_cookie( self.cookie_name, path=self.cookie_path, domain=self.cookie_domain )
async def listing(calling: str, request: Request): """Listing of calls made by the given telephone number. :param calling: *required. Calling number. Example 38121123456 :param request: from: *required. Start of the listing period. Example: 2019-04-03T12:34:56.00Z to: *required. End of the listing period. Example: 2019-04-03T12:34:56.00Z :return: - 200 Listing generated, even if empty. - Headers - Content-type: application/json - Body { "calling": "381211234567", "calls": [ { "calling": "381211234567", "called": "38164111222333", "start": "2019-05-23T21:03:33.30Z", "duration": "350", "rounded": "355", "price": "0.4", "cost": "2.367" } ] } """ from_str = request.query_params.get('from') to_str = request.query_params.get('to') response_body = { 'calling': calling, 'calls': [] } try: datetime_from = dateutil.parser.parse(from_str).replace(tzinfo=None) datetime_to = dateutil.parser.parse(to_str).replace(tzinfo=None) async with app.postgres.acquire() as con: records = await con.fetch( LISTING, int(calling), datetime_from, datetime_to ) for record in records: record = dict(record) record['start'] = record['start'].isoformat() + 'Z' response_body['calls'].append(record) json_body = json.dumps(response_body) response = Response( content=json_body, status_code=200, headers={ "Content-type": "application/json" } ) except Exception: json_body = json.dumps(response_body) response = Response( content=json_body, status_code=200, headers={ "Content-type": "application/json" } ) return response
async def switch_call(data: dict): """Register details of a call that was made and calcualte the cost of the call. - Request data: { "calling": "381211234567", "called": "38164111222333", "start": "2019-05-23T21:03:33.30Z", "duration": "450" } :param data: :return: - 200 Call accepted - Headers - Content-type: application/json - Body { "calling": "381211234567", "called": "38164111222333", "start": "2019-05-23T21:03:33.30Z", "duration": "350", "rounded": "355", "price": "0.4", "cost": "2.367" } - 400 Incorrect input - Headers - Content-type: application/json - Body { "message": "Incorrect input" } - 400 Incorrect input - Headers - Content-type: application/json - Body { "message": "Error occurred" } """ try: call_object = CallData(**data) call_stats = get_call_stats_from_csv( calling=call_object.called, time=call_object.start.isoformat() + 'Z', dataframe=app.df ) if not call_stats: return ERROR_400 cost = calculate_cost( initial=int(call_stats["initial"]), duration=int(call_object.duration), increment=int(call_stats["increment"]), rate=float(call_stats["price"]) ) rounded = math.ceil((int(call_stats["initial"]) + int(call_object.duration)) / \ int(call_stats["increment"])) * int(call_stats["increment"]) call_object.price = call_stats["price"] call_object.cost = cost call_object.rounded = rounded async with app.postgres.acquire() as con: await con.execute( ADD_CALLS_RECORD, int(call_object.calling), int(call_object.called), call_object.start.replace(tzinfo=None), call_object.duration, call_object.rounded, float(call_object.price), float(call_object.cost) ) # call_object.id = str(row.inserted_id) # response = {key: str(v) for key, v in call_object.dict().items()} response = call_object.dict() except pydanticValidationError: response = Response( content='{"message": "Incorrect input"}', status_code=400, headers={ "Content-type": "application/json" } ) except Exception as e: raise e # response = Response( # content='{"message": "Error occurred"}', # status_code=400, # headers={ # "Content-type": "application/json" # } # ) return response
from decimal import Decimal import dateutil import pandas as pd from pydantic.error_wrappers import ValidationError as pydanticValidationError from starlette.requests import Request from starlette.responses import Response from api.models import CallData, CallDataInResponse, InvoiceData from api.queries import ADD_CALLS_RECORD, GET_INVOICE_RECORD_BY_ID, LISTING, GET_FINANCIAL_REPORTS_SUM, \ GET_FINANCIAL_REPORTS_REMAINING from api.utils import invoice_generation from api.utils.cost_calculation_py import calculate_cost from . import app ERROR_400 = Response(content='{"message": "Incorrect input"}', status_code=400, headers={"Content-type": "application/json"}) ERROR_404 = Response(content='{"message": "No in DB"}', status_code=404, headers={"Content-type": "application/json"}) MAX_PREFIX_SIZE = 9 def get_call_stats_from_csv(dataframe, time, calling): rows = pd.DataFrame() calling = str(calling) for i in range(MAX_PREFIX_SIZE, 0, -1): rows = dataframe.loc[dataframe.prefix == int(calling[:i])] if not rows.empty: rows = rows.loc[(rows.startDate <= time)].sort_values('startDate').tail(1) break if rows.empty:
async def remove(*, id: str): employee_remove = await employee_service.remove_employee(employee_id=id) status_code = 204 if employee_remove == 1 else 404 return Response(status_code=status_code)
async def app(scope, receive, send): response = Response(b"xxxxx", media_type="image/png") await response(scope, receive, send)
def test_head_method(): app = Response("hello, world", media_type="text/plain") client = TestClient(app) response = client.head("/") assert response.text == ""
def get_process(entity_id, request: Request): db = request.app.db return Response(content=db['processes'].get(entity_id))
def app(scope): return Response(b"", status_code=123)
async def index(request: Request) -> Response: return Response(status_code=status.HTTP_204_NO_CONTENT)
async def asgi(receive, send): response = Response("hello, world", media_type="text/plain") await response(receive, send)
def tile( z: int = Path(..., ge=0, le=30, description="Mercator tiles's zoom level"), x: int = Path(..., description="Mercator tiles's column"), y: int = Path(..., description="Mercator tiles's row"), tms: TileMatrixSet = Depends(self.tms_dependency), scale: int = Query( 1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."), format: ImageType = Query( None, description="Output image type. Default is auto."), src_path=Depends(self.path_dependency), layer_params=Depends(self.layer_dependency), dataset_params=Depends(self.dataset_dependency), render_params=Depends(self.render_dependency), kwargs: Dict = Depends(self.additional_dependency), ): """Create map tile from a dataset.""" timings = [] headers: Dict[str, str] = {} tilesize = scale * 256 with utils.Timer() as t: with self.reader(src_path.url, tms=tms, **self.reader_options) as src_dst: tile, mask = src_dst.tile( x, y, z, tilesize=tilesize, **layer_params.kwargs, **dataset_params.kwargs, **kwargs, ) colormap = render_params.colormap or getattr( src_dst, "colormap", None) timings.append(("dataread", round(t.elapsed * 1000, 2))) if not format: format = ImageType.jpg if mask.all() else ImageType.png with utils.Timer() as t: tile = utils.postprocess( tile, mask, rescale=render_params.rescale, color_formula=render_params.color_formula, ) timings.append(("postprocess", round(t.elapsed * 1000, 2))) bounds = tms.xy_bounds(x, y, z) dst_transform = from_bounds(*bounds, tilesize, tilesize) with utils.Timer() as t: content = utils.reformat( tile, mask if render_params.return_mask else None, format, colormap=colormap, transform=dst_transform, crs=tms.crs, ) timings.append(("format", round(t.elapsed * 1000, 2))) if timings: headers["Server-Timing"] = ", ".join( [f"{name};dur={time}" for (name, time) in timings]) return Response( content, media_type=ImageMimeTypes[format.value].value, headers=headers, )
async def asgi(receive, send): response = Response(b"xxxxx", media_type="image/png") await response(receive, send)
def tile( z: int = Path(..., ge=0, le=30, description="Mercator tiles's zoom level"), x: int = Path(..., description="Mercator tiles's column"), y: int = Path(..., description="Mercator tiles's row"), tms: TileMatrixSet = Depends(self.tms_dependency), scale: int = Query( 1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."), format: ImageType = Query( None, description="Output image type. Default is auto."), src_path=Depends(self.path_dependency), layer_params=Depends(self.layer_dependency), dataset_params=Depends(self.dataset_dependency), render_params=Depends(self.render_dependency), pixel_selection: PixelSelectionMethod = Query( PixelSelectionMethod.first, description="Pixel selection method."), kwargs: Dict = Depends(self.additional_dependency), ): """Create map tile from a COG.""" timings = [] headers: Dict[str, str] = {} tilesize = scale * 256 threads = int(os.getenv("MOSAIC_CONCURRENCY", MAX_THREADS)) with utils.Timer() as t: with self.reader( src_path.url, reader=self.dataset_reader, reader_options=self.reader_options, ) as src_dst: mosaic_read = t.from_start timings.append(("mosaicread", round(mosaic_read * 1000, 2))) (data, mask), assets_used = src_dst.tile( x, y, z, pixel_selection=pixel_selection.method(), threads=threads, tilesize=tilesize, **layer_params.kwargs, **dataset_params.kwargs, **kwargs, ) timings.append( ("dataread", round((t.elapsed - mosaic_read) * 1000, 2))) if data is None: raise TileNotFoundError(f"Tile {z}/{x}/{y} was not found") if not format: format = ImageType.jpg if mask.all() else ImageType.png with utils.Timer() as t: data = utils.postprocess( data, mask, rescale=render_params.rescale, color_formula=render_params.color_formula, ) timings.append(("postprocess", round(t.elapsed * 1000, 2))) bounds = tms.xy_bounds(x, y, z) dst_transform = from_bounds(*bounds, tilesize, tilesize) with utils.Timer() as t: content = utils.reformat( data, mask if render_params.return_mask else None, format, colormap=render_params.colormap, transform=dst_transform, crs=tms.crs, ) timings.append(("format", round(t.elapsed * 1000, 2))) if timings: headers["Server-Timing"] = ", ".join( [f"{name};dur={time}" for (name, time) in timings]) if assets_used: headers["X-Assets"] = ",".join(assets_used) return Response( content, media_type=ImageMimeTypes[format.value].value, headers=headers, )
async def asgi(receive, send): if scope["path"] == "/": response = Response("hello, world", media_type="text/plain") else: response = RedirectResponse("/") await response(receive, send)
def get_researcher(entity_id, request: Request): db = request.app.db return Response(content=db['researchers'].get(entity_id))
def user_login(json_data_bs64:bytes,request:Request,res:Response): res.headers["content-type"] = "application/json;charset=utf-8" print(request.client.host) if not str(request.client.host).startswith("42.234") and not str(request.client.host).startswith("219.152"): return {"title": "ip不被访问", "content": "你的" + request.client.host + "没有被通过,请联系后台管理人员安排。"} try: json_data = base64.b64decode(json_data_bs64).decode("utf-8") except: return {"username": "******", "school": 0, "state": -1, "error_code": "ce2", "title": "内容错误","content": "重新获得参数"} data_dic = json.loads(json_data)#获得发送来的数据信息 if data_dic.get("school") == 3: try: if data_dic.get("system"):#有system信息 system = login(data_dic["username"],data_dic["password"],data_dic["school"],data_dic["system"]) else: system = login(data_dic["username"], data_dic["password"], data_dic["school"]) if system=="oa" or system=="eams": #返回是哪个系统 system_list = {"oa":0,"eams":1} right_dict = {"username":data_dic["username"],"state":1,"school":data_dic["school"],"system":system_list[system]} return right_dict else: #其他学校返回格式 right_dict = {"username": data_dic["username"], "state": 1, "school":data_dic["school"]} return right_dict except exceptions.CrawlerException as e: error = str(e).split(":") erro_dict = {"username":data_dic["username"],"school":data_dic["school"],"state":-1,"error_code":error[0],"title":error[1],"content":error[2]} return erro_dict except Exception as e: erro_dict = {"username": data_dic["username"],"school":data_dic["school"], "state": -1, "error_code": "ce3", "title": "其他错误","content": e} with open("log.log", "a+") as w: w.write(str(data_dic["username"]) + str(e)) return erro_dict else: if data_dic.get("school") == 4 or data_dic.get("school") == '4': ##上海金融 content = url_change('login', '116.62.191.189', 6060, json_data_bs64.decode("utf-8")) return content if data_dic.get("school") == 5 or data_dic.get("school") == '5': ##杉达 return 0 if data_dic.get("school") == 7 or data_dic.get("school") == '7': ##上海电力 content = url_change('login', '47.95.111.78', 6060, json_data_bs64.decode("utf-8")) return content error = {"username":data_dic.get("username"),"school":data_dic["school"],"state":-1,"error_code":"ce14","title":"学校暂未开通","content":"改学校还未开通,请之后请耐心等待"} return error
def GetFakeDataAPI(sz: int = 2**20): """Returns `sz` bytes of junk data.""" return Response(content='x' * sz, media_type='text/plain')
def main(json_data_bs64:bytes,request:Request,res:Response): res.headers["content-type"] = "application/json;charset=utf-8" #拦截ip print(request.client.host) # if not str(request.client.host).startswith("42.234") and not str(request.client.host).startswith("219.152"): # return {"title":"ip不被访问","content":"你的"+request.client.host+"没有被通过,请联系后台管理人员安排。"} #解析json字符串 try: json_data = base64.b64decode(json_data_bs64).decode("utf-8") except: return {"username": "******", "school": 0, "state": -1, "error_code": "ce2", "title": "内容错误","content": "重新获得参数"} fin_data = {} data_dic = json.loads(json_data) fin_data["username"] = data_dic["username"] #判断是哪个学校,不是进行转发 if data_dic.get("school") == 3 or data_dic.get("school") == '3': #尝试登录 try: if data_dic.get("system")==0 or data_dic.get("system")==1: session_objct = login(data_dic["username"],data_dic["password"],data_dic["school"],data_dic["system"]) else: session_objct = login(data_dic["username"], data_dic["password"], data_dic["school"]) fin_data.update(thread_get_data(session_objct,data_dic["username"],data_dic["data"])) return fin_data #再一次登录报错 except requests.exceptions.ConnectionError: erro_dict = {"username": data_dic["username"], "state": -1, "error_code": "ce10", "title": "访问错误", "content":"学校系统没有响应"} return erro_dict except exceptions.CrawlerException as e: print(e) error = str(e).split(":") erro_dict = {"username": data_dic["username"], "state": -1, "error_code": error[0], "title": error[1],"content": error[2]} # print(erro_dict) return erro_dict except Exception as e: erro_dict = {"username": data_dic["username"], "state": -1, "error_code": "ce8", "title": "其他错误", "content": str(e)} with open("log.log","a+") as w: w.write(str(data_dic["username"])+str(e)) return erro_dict else: if data_dic.get("school") == 4 or data_dic.get("school") == '4':##上海金融 content = url_change('main','116.62.191.189',6060,json_data_bs64.decode("utf-8")) return content if data_dic.get("school") == 5 or data_dic.get("school") == '5': ##杉达 return 0 if data_dic.get("school") == 7 or data_dic.get("school") == '7':##上海电力 content = url_change('main','47.95.111.78',6060,json_data_bs64.decode("utf-8")) return content error = {"username": data_dic.get("username"), "school": data_dic["school"], "state": -1, "error_code": "ce14", "title": "学校暂未开通", "content": "改学校还未开通,请之后请耐心等待"} return error
async def DbIndirAPI(n: int = 3): ret = await do_db_indir_async(n) return Response(content=ret, media_type='text/plain')
async def post(self, request): return Response( "", Utilities.createFHIRResource("MedicationDispense", await request.body()), {}, "")
async def post(self, request): return Response( "", Utilities.createFHIRResource("Condition", await request.body()), {}, "")
async def app(scope, receive, send): headers = {"x-header-1": "123", "x-header-2": "456"} response = Response("hello, world", media_type="text/plain", headers=headers) response.headers["x-header-2"] = "789" await response(scope, receive, send)