def request( self, method: typing.Union[str, typing.Callable], url: typing.Optional[typing.Union[str, typing.Pattern]] = None, status_code: typing.Optional[int] = None, content: typing.Optional[ContentDataTypes] = None, content_type: typing.Optional[str] = None, headers: typing.Optional[HeaderTypes] = None, pass_through: bool = False, alias: typing.Optional[str] = None, ) -> RequestPattern: """ Adds a request pattern with given mocked response details. """ headers = Headers(headers or {}) if content_type: headers["Content-Type"] = content_type response = ResponseTemplate(status_code, headers, content) pattern = RequestPattern( method, url, response, pass_through=pass_through, alias=alias, base_url=self._base_url, ) self.add(pattern) return pattern
def _generate_authorization_headers(self, request: Request) -> Headers: date = self._get_formatted_date() digest = self._compute_digest(request) string = self._compose_string(request, date, digest) signature = self._sign_string(string) authorization_header = self._compose_authorization_header(signature) headers = {'Host': request.url.host, 'Date': date, 'Digest': digest, 'Authorization': authorization_header} return Headers(headers)
def __init__(self): self.client = AsyncClient() self.client.headers = Headers({ "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 " "Safari/537.36" }) self.disabled_until: Optional[datetime.datetime] = None
def test_last_modified_is_not_used_when_cache_control_present(self): headers = { "Date": self.now, "Last-Modified": self.week_ago, "Cache-Control": "private", } assert self.heuristic.update_headers(Headers(headers), 200) == {}
def test_last_modified_is_used_when_cache_control_public(self): headers = { "Date": self.now, "Last-Modified": self.week_ago, "Cache-Control": "public", } modified = self.heuristic.update_headers(Headers(headers), 200) assert ["expires"] == list(modified.keys()) assert datetime(*parsedate(modified["expires"]) [:6]) > datetime.now() # type: ignore
def __init__(self, token: str): self.client = AsyncClient(timeout=10) self.client.headers = Headers({ "Accept": "application/json", "Authorization": f"Bearer {token}", "User-Agent": "holo observatory bot/1.0.0" })
async def request( self, method: str, path: str, headers: typing.Union[Headers, dict], result_body: io.BytesIO, body: typing.Union[io.BytesIO, bytes] = None) -> Headers: """Returns the headers from the server after making the given request at the given path using the given headers. The body of the response is written to the result body. Arguments: - `method (str)`: The HTTP verb to perform, uppercased, e.g., 'GET' - `path (str)`: The path within the host, e.g., /api/foo - `headers (Headers, dict)`: The headers to send with case-insensitive keys. - `result_body (io.BaseIO)`: The IO to write the body from the server; nothing is written if the server does not provide a body. - `body (bytes, io.BaseIO, None)`: The bytes to send to the server in the body, specified either as bytes (which are wrapped with BytesIO) or just an bytes-based io object. Returns: - `headers (Headers)`: The returned headers and trailers from the server. """ if not self.opened: await self.open() if not isinstance(headers, Headers): headers = Headers(headers) itr = self.rconn.request(method, self.host, path, headers.multi_items(), body) raw_headers = await itr.__anext__() response_headers = Headers(raw_headers) chunk = await itr.__anext__() while chunk is not None: result_body.write(chunk) chunk = await itr.__anext__() raw_trailers = await itr.__anext__() response_trailers = Headers(raw_trailers) for key, val in response_trailers.items(): response_headers[key] = val return response_headers
async def request( self, method: bytes, url: typing.Tuple[bytes, bytes, int, bytes], headers: typing.List[typing.Tuple[bytes, bytes]], stream: ContentStream, timeout: typing.Dict[str, typing.Optional[float]] = None, ) -> typing.Tuple[bytes, int, bytes, typing.List[typing.Tuple[ bytes, bytes]], ContentStream]: headers = Headers() body = JSONStream({"ok": "ok"}) return b"HTTP/1.1", 200, b"OK", headers, body
def __init__( self, status_code: typing.Optional[int] = None, headers: typing.Optional[HeaderTypes] = None, content: typing.Optional[ContentDataTypes] = None, context: typing.Optional[Kwargs] = None, ) -> None: self.http_version = 1.1 self.status_code = status_code or 200 self.context = context if context is not None else {} self._headers = Headers(headers or {}) self._content = content if content is not None else b""
async def create_session(session: AsyncClient, token: str): data = {TIMESTAMP: datetime.now().strftime("%Y-%m-%d %H:%M:%S")} resp = await session.post(constants.BASE_URL + "/api/portal/CreateSession2", headers=Headers({ **bearer_header(token), **{ "Content-Type": "application/json" } }), json=data) return resp.json()['BrowserSessionId']
def __init__(self) -> None: """Define DOI credentials and config. :param state: can be publish, register, hide or draft. """ self.rems_api = environ.get("REMS_API", "") self.rems_user = environ.get("REMS_USER", "") self.rems_key = environ.get("REMS_KEY", "") self.config = CONFIG_INFO["rems"] self.headers = Headers({ "Content-Type": "application/json", "Accept": "application/json", "x-rems-api-key": self.rems_key, "x-rems-user-id": self.rems_user, })
def __init__(self, key_id: str, rsa_key: RSAPrivateKey, staging: bool = False, **kwargs) -> None: auth = SatispayAuth(key_id, rsa_key) headers = kwargs.get('headers', Headers()) headers.update({'Accept': 'application/json'}) if staging: base_url = URL('https://staging.authservices.satispay.com') else: base_url = URL('https://authservices.satispay.com') super().__init__(auth=auth, headers=headers, base_url=base_url, **kwargs)
def _inject_headers(self, headers: dict): # need to coerce to str headers = {k: str(v) for k, v in headers.items()} headers.update( {"date": get_utc_datetime().strftime("%a, %d %b %y %T %z")}) # inject user information to request headers user = context_user() headers.update({ settings.INTERNAL_REQUEST_USER_HEADER.lower(): to_header_value(user) }) # inject correlation_id correlation_id = context_correlation_id() headers.update( {settings.REQUEST_ID_HEADER_FIELD.lower(): correlation_id}) return Headers(headers)
def _fetch_stored_request(self, method, path): cache_key = self._cache_key(method, path) with self.cache.transact(): cached_at = self.cache.get(cache_key + b'-cached-at') if cached_at is None: return (None, None, None) header = self.cache.get(cache_key + b'-header') if header is None: self.cache.delete(cache_key + b'-cached-at') return (None, None, None) body = self.cache.get(cache_key + b'-body') if body is None: self.cache.delete(cache_key + b'-cached-at') self.cache.delete(cache_key + b'-header') return (None, None, None) return (cached_at, Headers(header), body)
async def create_draft_doi(self, user: str, inbox_path: str) -> Union[Dict, None]: """Create an auto-generated draft DOI. We are using just the prefix for the DOI so that it will be autogenerated. """ dataset = generate_dataset_id(user, inbox_path, self.ns_url) suffix = shortuuid.uuid(name=dataset)[:10] doi_suffix = f"{suffix[:4]}-{suffix[4:]}" headers = Headers({"Content-Type": "application/json"}) draft_doi_payload = { "data": { "type": "dois", "attributes": { "doi": f"{self.doi_prefix}/{doi_suffix}" } } } async with AsyncClient() as client: response = await client.post(self.doi_api, auth=(self.doi_user, self.doi_key), json=draft_doi_payload, headers=headers) doi_data = None if response.status_code == 201: draft_resp = response.json() _doi = draft_resp["data"]["attributes"]["doi"] _suffix = draft_resp["data"]["attributes"]["suffix"] LOG.debug(f"DOI draft created and response was: {draft_resp}") LOG.info(f"DOI draft created with doi: {_doi}.") doi_data = { "suffix": _suffix, "fullDOI": _doi, "dataset": f"{self.ns_url}/{_suffix.lower()}", } else: LOG.error( f"DOI API create draft request failed with code: {response.status_code}" ) doi_data = self._check_errors(response, doi_suffix) return doi_data
def failure_response(): return Response( status_code=404, request=Request(url="https://leomenezessz.github.io/pyppium/", method="get"), headers=Headers({ "cache-control": "no-cache", "content-type": "application/json; charset=utf-8", "date": "Fri, 04 Sep 2020 06:35:18 GMT", "server": "nginx", "status": "404 Not Found", "vary": "Origin", "x-powered-by": "Phusion Passenger", "x-request-id": "632eeff4-a6f4-4016-82aa-75d10805f149", "x-runtime": "0.093190", "x-ua-compatible": "IE=Edge,chrome=1", "content-length": "36", "connection": "keep-alive", }), )
def test_production(self, key_id, rsa_key, create_payment_production_signature): route = respx.post( 'https://authservices.satispay.com/g_business/v1/payments') body_params = { 'callback_url': 'https://test.test?payment_id={uuid}', 'expiration_date': '2019-03-18T16:10:24.000Z', 'external_code': 'test_code', 'metadata': { 'metadata': 'test' } } headers = Headers({'Idempotency-Key': 'test_idempotency_key'}) satispaython.create_payment(key_id, rsa_key, 100, 'EUR', body_params, headers) assert route.called assert route.call_count == 1 request = route.calls.last.request assert request.method == 'POST' assert json.loads(request.content.decode()) == { 'flow': 'MATCH_CODE', 'amount_unit': 100, 'currency': 'EUR', 'callback_url': 'https://test.test?payment_id={uuid}', 'expiration_date': '2019-03-18T16:10:24.000Z', 'external_code': 'test_code', 'metadata': { 'metadata': 'test' } } assert request.headers['Idempotency-Key'] == 'test_idempotency_key' assert request.headers['Accept'] == 'application/json' assert request.headers['Content-Type'] == 'application/json' assert request.headers['Host'] == 'authservices.satispay.com' assert request.headers['Date'] == 'Mon, 18 Mar 2019 15:10:24 +0000' assert request.headers[ 'Digest'] == 'SHA-256=dOjZtX6Has9wFZQDmriLhIfThHD11nuxFZNIjp7FwR0=' assert request.headers['Authorization'] == f'Signature keyId="{key_id}", ' \ f'algorithm="rsa-sha256", ' \ f'headers="(request-target) host date digest", ' \ f'signature="{create_payment_production_signature}"'
def __init__(self, **kwargs): data = { 'body': {}, 'headers': {}, 'path': {}, 'query': {}, } data['header'] = data['headers'] skip_validation = kwargs.pop('esi_skip_validation', False) errors = {} for param in self.params: value = kwargs.pop(param.safe_name) if value == param.default: continue try: param.validate(value) except ValidationError as e: e.update_error_dict(errors, param.safe_name) data[param.part][param.name] = value if errors and not skip_validation: raise ValidationError(errors) cls = self.__class__ body = None if data['body']: body = list(data['body'].values())[0] self.method = cls.method.upper() self.url = URL(self.path.format(**data['path']), allow_relative=True, params=data['query']) self.headers = Headers(data['header']) self.stream = encode(body, None, None) self.timer = ElapsedTimer() self.prepare() # Clear out headers we don't need (These will be set by the session) for key in ["User-Agent"]: if key in self.headers: del self.headers[key]
async def app(scope, receive, send): request = Request(scope, receive) user_key = request.headers.get('api_key') if not USERS_CACHE.get(user_key): USERS_CACHE[user_key] = await auth(user_key) headers = (tuple(["session_id", USERS_CACHE[user_key]]), *request.headers.items()) print(headers) async with httpx.AsyncClient() as client: url = TARGET_SERVER + request.url.path r = await client.request(request.method, url, headers=Headers(headers), data=await request.body()) response = UJSONResponse(r.json()) #response = Response(content=r.content, headers=r.headers, status_code=r.status_code, media_type="application/json") result = await response(scope, receive, send) return result
async def create_payment(self, amount_unit: int, currency: str, body_params: Optional[dict] = None, headers: Optional[Headers] = None) -> Response: target = URL('/g_business/v1/payments') try: headers.update({'Content-Type': 'application/json'}) except AttributeError: headers = Headers({'Content-Type': 'application/json'}) try: body_params.update({ 'flow': 'MATCH_CODE', 'amount_unit': amount_unit, 'currency': currency }) except AttributeError: body_params = { 'flow': 'MATCH_CODE', 'amount_unit': amount_unit, 'currency': currency } return await self.post(target, json=body_params, headers=headers)
def _only_if_cached_failure(self, method, path, headers, request_body, body): return Headers(((b':status', b'504'), ))
def test_last_modified_is_not_used_when_status_is_unknown(self): headers = {"Date": self.now, "Last-Modified": self.week_ago} status = 299 assert self.heuristic.update_headers(Headers(headers), status) == {}
def test_last_modified_is_used(self): headers = {"Date": self.now, "Last-Modified": self.week_ago} modified = self.heuristic.update_headers(Headers(headers), 200) assert ["expires"] == list(modified.keys()) assert datetime(*parsedate(modified["expires"]) [:6]) > datetime.now() # type: ignore
def test_expires_is_not_replaced_when_present(self): headers = {"Expires": self.day_ahead} assert self.heuristic.update_headers(Headers(headers), 200) == {}
from inspect import iscoroutinefunction from json import JSONDecodeError from typing import Optional import aiohttp from fastjsonschema.exceptions import JsonSchemaException # noinspection PyPackageRequirements from httpcore import TimeoutException from httpx import AsyncClient, HTTPError, Headers, NetworkError from .blivedm import BLiveClient from .schemas import room_info_schema http = AsyncClient(headers=Headers({ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ' 'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36' })) class LiveStatus(Enum): DISABLED = 0 LIVE = 1 PREPARE = 2 @dataclass class LiveRoom: room_id: int title: str uid: int
def test_expiry_is_no_more_than_twenty_four_hours(self): headers = {"Date": self.now, "Last-Modified": self.year_ago} modified = self.heuristic.update_headers(Headers(headers), 200) assert ["expires"] == list(modified.keys()) assert self.day_ahead == modified["expires"]
def test_header_does_not_exist(): headers = Headers({"foo": "bar"}) with pytest.raises(KeyError): del headers["baz"]
def from_text(cls, text): headers = Headers() for line in text.splitlines(): k, v = line.split(": ", 1) headers[k] = v return cls.from_headers(headers)
async def request(self, method, path, params=None, headers=None, data=None, json=None) -> ResponseData: """Makes a request using the given method to the given path. Arguments: - `method (str)`: The HTTP verb (uppercased) - `path (str)`: The path to make the request to, must just be the path and must be prefixed with a forward slash (e.g., /api) - `params (dict, None)`: If specified the keys and values must be strings and they will be injected into the query arguments. - `headers (dict, Headers, None)`: If specified these headers will be sent alongside the request. - `data (io.BytesIO, bytes, str, None)`: Sent in the body of the request. If specified as a BytesIO like object the data will be streamed across the connection, which is very suitable for uploading files. If specified as a string it is encoding using utf-8. Unlike requests we do not support `application/x-www-form-urlencoded` style requests natively. - `json (any)`: If not `None` then `data` is ignored, and `json` will be serialized as json to text and then treated as if it were the value of `data`. Returns: - `response (ResponseData)`: The result from the server, fully loaded in memory. """ if params is not None: base_path, _, current_args = path.partition('?') query_args = dict( arg.split('=') for arg in current_args.split('&') if arg) query_args = {**query_args, **params} path = base_path + '?' + urlencode(query_args) content_type_hint = None if json is not None: data = jsonlib.dumps(json).encode('utf-8') content_type_hint = 'application/json; charset=utf-8' if isinstance(data, str) and content_type_hint is None: data = data.encode('utf-8') content_type_hint = 'text/plain; charset=utf-8' if headers is None: headers = {} if content_type_hint is not None and headers.get( 'content-type') is None: headers['content-type'] = content_type_hint headers = {**self.default_headers, **headers} result_body = io.BytesIO() response_headers = await self.h2conn.request(method, path, headers, result_body, data) return ResponseData(self.h2conn.host, path, method, Headers(headers), response_headers, result_body.getvalue())
async def request(self, method: str, path: str, headers: typing.Union[Headers, dict], result_body: io.BytesIO, body: typing.Union[io.BytesIO, bytes] = None) -> Headers: """See `h2client.http2_connection.HTTP2Connection#request`""" if not isinstance(headers, Headers): headers = Headers(headers) request_directives = self._get_cache_directives(headers) only_if_cached = 'only-if-cached' in request_directives if 'no-store' in request_directives: if only_if_cached: return self._only_if_cached_failure(method, path, headers, result_body, body) return await self._no_store_request(method, path, headers, result_body, body) if 'no-cache' in request_directives: if only_if_cached: return self._only_if_cached_failure(method, path, headers, result_body, body) return await self._no_cache_request(method, path, headers, result_body, body) cached_at, cached_headers, cached_body = self._fetch_stored_request( method, path) if cached_at is None: if only_if_cached: return self._only_if_cached_failure(method, path, headers, result_body, body) return await self._no_cache_request(method, path, headers, result_body, body) time_since_cached = time.time() - cached_at cached_headers['age'] = str(time_since_cached) cached_directives = self._get_cache_directives(cached_headers) if 'immutable' in cached_directives: if cached_body: result_body.write(cached_body) return cached_headers must_revalidate = 'must-revalidate' in cached_directives max_age = int(cached_directives.get('max-age', '0')) if 'max-age' in request_directives: max_age = min(max_age, int(request_directives['max-age'])) stale_while_revalidate = int( cached_directives.get('stale-while-revalidate', '0')) stale_if_error = int(cached_directives.get('stale-if-error', '0')) if 'max-stale' in request_directives: max_stale = int(request_directives['max-stale']) stale_while_revalidate = min(stale_while_revalidate, max_stale) stale_if_error = min(stale_if_error, max_stale) if 'min-fresh' in request_directives: max_age = max(max_age - int(request_directives['min-fresh']), 0) stale_while_revalidate = 0 stale_if_error = 0 if time_since_cached < max_age: if must_revalidate: self._revalidate_request(method, path, headers, body) if cached_body: result_body.write(cached_body) return cached_headers if time_since_cached < max_age + stale_while_revalidate: if (must_revalidate or max_age < time_since_cached) and not only_if_cached: self._revalidate_request(method, path, headers, body) if cached_body: result_body.write(cached_body) return cached_headers if only_if_cached: return self._only_if_cached_failure(method, path, headers, result_body, body) mem_body = io.BytesIO() real_result_headers = await self._no_cache_request( method, path, headers, mem_body, body) time_since_cached = time.time() - cached_at cached_headers['age'] = str(time_since_cached) is_error = real_result_headers.get(':status', '200') in ('500', '502', '503', '504') if (time_since_cached < max_age + stale_if_error) and is_error: self._store_request(method, path, cached_headers, cached_body, cached_at=cached_at) if cached_body: result_body.write(cached_body) return cached_headers result_body.write(mem_body.getvalue()) return real_result_headers