def test_import_with_db_exists_ok_if_empty__empty_db_exists(
setup_masterdb, drop_dbs):
data = [
{
"_id": "testdoc_1",
"_rev": "3-825cb35de44c433bfb2df415563a19de"
},
{
"_id": "testdoc_2",
"_rev": "1-c3d84a0ca6114a8e8fbef75dc8c7be00",
"test": "test",
},
{
"_id": "testdoc_3",
"_rev": "15-305afde91ffef71edcff06458e17c186",
"test": "test",
"another": "test",
},
{
"_id": "testdoc_4",
"_rev": "1-967a00dff5e02add41819138abb3284d"
},
]
with NamedTemporaryFile() as tmpfile:
filename = tmpfile.name
print(filename)
with open(filename, "w", encoding="utf8") as inf:
inf.write("\n".join(json.dumps(x) for x in data))
with sessions.BaseUrlSession(base_url="http://localhost:5984/") as client:
client.auth = ("admin", "adminadmin")
response = client.put("import_testdb_exists")
assert response.status_code == 201
result = runner.invoke(
app,
[
"import",
"--user",
"admin",
"--password",
"adminadmin",
filename,
"import_testdb_exists",
],
)
print(result.stdout)
assert result.exit_code == 0
with sessions.BaseUrlSession(
base_url="http://localhost:5984/import_testdb_exists/",
) as client:
client.auth = ("admin", "adminadmin")
assert len(data) == client.get("").json()["doc_count"]
for doc in data:
response = client.get(doc["_id"])
assert response.status_code == 200
assert doc == response.json()
class UndersideApi(object):
session = sessions.BaseUrlSession(
base_url='https://underside.tjcache.pw/api/v1/message/')
trans_table = str.maketrans('\u200e\u200b', '01')
encr_table = str.maketrans('01', '\u200e\u200b')
@staticmethod
def bin2ascii(bin: str) -> str:
n = int(bin, 2)
return n.to_bytes((n.bit_length() + 7) // 8, 'big').decode()
@staticmethod
def ascii2bin(string: str) -> str:
return bin(int.from_bytes(string.encode(), 'big')).replace('b', '')
def code_decryption(self, json: dict) -> str:
return self.bin2ascii(json.get('code', '').translate(self.trans_table))
def code_encryption(self, code: str) -> str:
return self.ascii2bin(code).translate(self.encr_table)
def encode(self, message: str) -> str:
request = self.session.post('encode/', json={'message': message})
return self.code_decryption(request.json())
def decode(self, code: str) -> str:
request = self.session.post('decode/',
json={'code': self.code_encryption(code)})
return request.json().get('text', '')
def to_http(config, base_url):
start = time()
retry_strategy = Retry(total=5,
status_forcelist=[500, 502, 503, 504],
method_whitelist=["POST"],
backoff_factor=3)
http = sessions.BaseUrlSession(base_url=BASE_URL())
adaptor = HTTPAdapter(max_retries=retry_strategy)
http.adapters = {"https://": adaptor, "http://": adaptor}
while not quitevent.is_set():
for item in config.generator:
item['image'] = image_to_base64(item['image'])
header = dict(sent_from=gethostname(),
uptime=str(time() - start),
device_name=str(config.device_name))
data = dict(device_name=item['device_name'],
timestamp=datetime.utcnow().replace(
tzinfo=pytz.utc).isoformat(),
confidence=item['is_bad'],
coordinates=[item['lat'], item['lon']],
photo_data=item['image'])
http.post(f"{base_url}/dev/upload",
data=dumps(data),
headers=header)
def __init__(self,
base,
token=None,
username=None,
password=None,
_getuser=_getuser_default,
_getpass=_getpass_default,
retries=3,
insecure=False):
self.lock = Lock()
self.base = base.rstrip('/')
self.token = token or os.environ.get('CDROUTER_API_TOKEN')
self.username = username
self.password = password
self._getuser = _getuser
self._getpass = _getpass
self.retries = retries
self.insecure = insecure
if insecure:
# disable annoying InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
self.session = sessions.BaseUrlSession(base_url=self.base + self.BASE)
#: :class:`configs.ConfigsService <configs.ConfigsService>` object
self.configs = ConfigsService(self)
#: :class:`devices.DevicesService <devices.DevicesService>` object
self.devices = DevicesService(self)
#: :class:`attachments.AttachmentsService <attachments.AttachmentsService>` object
self.attachments = AttachmentsService(self)
#: :class:`jobs.JobsService <jobs.JobsService>` object
self.jobs = JobsService(self)
#: :class:`packages.PackagesService <packages.PackagesService>` object
self.packages = PackagesService(self)
#: :class:`results.ResultsService <results.ResultsService>` object
self.results = ResultsService(self)
#: :class:`testresults.TestResultsService <testresults.TestResultsService>` object
self.tests = TestResultsService(self)
#: :class:`annotations.AnnotationsService <annotations.AnnotationsService>` object
self.annotations = AnnotationsService(self)
#: :class:`captures.CapturesService <captures.CapturesService>` object
self.captures = CapturesService(self)
#: :class:`highlights.HighlightsService <highlights.HighlightsService>` object
self.highlights = HighlightsService(self)
#: :class:`imports.ImportsService <imports.ImportsService>` object
self.imports = ImportsService(self)
#: :class:`exports.ExportsService <exports.ExportsService>` object
self.exports = ExportsService(self)
#: :class:`history.HistoryService <history.HistoryService>` object
self.history = HistoryService(self)
#: :class:`system.SystemService <system.SystemService>` object
self.system = SystemService(self)
#: :class:`tags.TagsService <tags.TagsService>` object
self.tags = TagsService(self)
#: :class:`testsuites.TestsuitesService <testsuites.TestsuitesService>` object
self.testsuites = TestsuitesService(self)
#: :class:`users.UsersService <users.UsersService>` object
self.users = UsersService(self)
class Renderer:
session = sessions.BaseUrlSession('https://dl.dropboxusercontent.com')
url = '/s/sg48j6iuoc819jm/Jason R. Coombs resume.xml'
def __init__(self, url=None):
if url:
self.url = url
def get_transform_path(self, output_name):
path_tmpl = 'resume-1.5.1/xsl/output/{output_name}.xsl'
path = path_tmpl.format(**locals())
here = os.path.dirname(__file__)
return os.path.join(here, 'static', path)
def html(self):
transform_path = self.get_transform_path('us-html')
transform = etree.XSLT(etree.parse(open(transform_path)))
resp = self.session.get(self.url)
src = etree.fromstring(resp.content)
return str(transform(src))
def pdf(self):
"use subprocess and fop to render the output"
cmd = [
'fop', '-xml', '-', '-xsl',
self.get_transform_path('us-letter'), '-'
]
resp = self.session.get(self.url)
proc = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
stdout, stderr = proc.communicate(resp.content)
return stdout
def main():
pub_api_session = sessions.BaseUrlSession(base_url=PUBLIC_API)
priv_api_session = None
if args.cookies:
if os.path.isfile(args.cookies):
priv_api_session = create_priv_api_session(cookie_jar_path=args.cookies)
else:
print_log("openrec-dl", f"could not find cookies file \'{args.cookies}\', continuing without cookies")
elif args.username and args.password:
cookies = get_cookies_from_username_password(args.username, args.password)
priv_api_session = create_priv_api_session(cookie_jar=cookies)
if args.version:
print(VERSION_STRING)
return
if len(args.links) == 0:
parser.print_usage()
elif not os.path.isdir(args.directory):
os.makedirs(args.directory)
for link in args.links:
# is openrec link
openrec_m = re.search(OPENREC, link)
id_m = re.search(VALID_LIVE_ID, link)
if openrec_m:
t = openrec_m.group("type")
if t == "user":
dl_channel(pub_api_session, priv_api_session, openrec_m.group("id"))
elif t == "live":
dl_movie(pub_api_session, priv_api_session, openrec_m.group("id"))
else:
print_log("openrec", f"unknown link type \'{t}\'")
elif id_m:
dl_movie(pub_api_session, priv_api_session, id_m.group("id"))
else:
print_log("openrec", f"invalid link or id \'{link}\'")
def get_session(cls):
session = sessions.BaseUrlSession('https://api.github.com/repos/')
session.headers.update(
Accept='application/vnd.github.v3+json',
Authorization=f'token {cls.load_token()}',
)
return session
def __init__(
self,
stitch_api_key: str,
stitch_client_id: int,
stitch_auth_user: str,
stitch_auth_password: str,
stitch_blacklist_sources: str = None,
) -> None:
self.stitch_api_key = stitch_api_key
self.stitch_client_id = stitch_client_id
self.stitch_auth_user = stitch_auth_user
self.stitch_auth_password = stitch_auth_password
self.client = sessions.BaseUrlSession(base_url=constants.API_URL)
self.client.hooks["response"] = [assert_status_hook]
self.headers = {
'Accept': 'application/json',
'Origin': 'https://app.stitchdata.com',
'User-Agent': constants.DEVICE_SETTINGS['user_agent'],
'Content-Type': 'application/json',
'Authorization': 'Bearer %s' % stitch_api_key
}
self._logged_in_internal = False
self.write_blacklist = None
self._parse_blacklist_config(stitch_blacklist_sources)
def set_image(image):
with sessions.BaseUrlSession(base_url=address) as s:
login_page = s.get('users/sign_in')
login_payload = get_auth_payload(login_page)
login_responce = s.post('users/sign_in', data=login_payload)
appearance_page = s.get('admin/appearance')
appearance_payload = process_appearance_page(appearance_page)
# We COULD use python-magic and libmagic to get the mime type... or I can just make it png.
# http://stackoverflow.com/a/2753385
appearance_payload['appearance[header_logo]'] = (image.name,
image.open(mode='rb'),
'image/png')
logging.info(image.name)
appearance_payload = MultipartEncoder(fields=appearance_payload)
appearance_responce = s.post(
'admin/appearance',
data=appearance_payload,
headers={'Content-Type': appearance_payload.content_type})
def __init__(self,
token=None,
base_url=r'https://developer.api.autodesk.com/',
timeout=1):
"""
Initialize the ForgeApi class and optionally attach an authentication token for the Autodesk Forge API.
Args:
token (str): Authentication token for Autodesk Forge API.
base_url (str, optional): Base URL for calls to the forge API.
Defaults to r'https://developer.api.autodesk.com/'
timeout (float, optional): Default timeout for API calls. Defaults to 1.
Returns:
None.
"""
self.token = token
self.http = sessions.BaseUrlSession(base_url)
self.http.hooks['response'] = [
lambda response, *args, **kwargs: response.raise_for_status()
]
retries = Retry(total=6,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504])
adapter = TimeoutHttpAdapter(timeout=timeout, max_retries=retries)
self.http.mount("https://", adapter)
self.http.mount("http://", adapter)
def __init__(
self,
base_url,
user,
password,
timeout=HTTP_DEFAULT_TIMEOUT,
max_retries=HTTP_DEFAULT_MAX_RETRIES,
cache_maxsize=CACHE_DEFAULT_MAXSIZE,
cache_ttl=CACHE_DEFAULT_TTL,
):
self._user = user
self._password = password
self._http = sessions.BaseUrlSession(base_url=base_url)
self._cache_maxsize = cache_maxsize
self._cache_ttl = cache_ttl
# Retry strategy for http requests
retries = Retry(
total=max_retries,
status_forcelist=[429, 500, 502, 503, 504],
method_whitelist=[
"HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE", "POST"
],
backoff_factor=
1, # this will do `sleep({backoff factor} * (2 ** ({number of retries} - 1)))`
)
# Include timeout for http requests
adapter = TimeoutHTTPAdapter(timeout=timeout, max_retries=retries)
self._http.mount("https://", adapter)
self._http.mount("http://", adapter)
def __init__(
self,
api_key: str,
query_dir: Optional[str] = None,
base_url: Optional[str] = r"https://classic.warcraftlogs.com:443/v1/",
timeout: Optional[int] = 1,
) -> None:
"""
Initialize the WCLApi class and optionally attach an authentication token.
Args:
api_key (str): Authentication api_key.
query_dir (str, optional): Path to the directory where queries should be
stored.
base_url (str, optional): Base URL for calls to the API.
Defaults to r'https://classic.warcraftlogs.com:443/v1/'
timeout (float, optional): Default timeout for API calls. Defaults to 1.
Returns:
None.
"""
assert api_key is not None, "Please enter an api_key"
self.api_key = api_key
self.query_dir = query_dir
self.http = sessions.BaseUrlSession(base_url)
self.http.hooks["response"] = [
lambda response, *args, **kwargs: response.raise_for_status()
]
retries = Retry(total=6,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504])
adapter = TimeoutHttpAdapter(timeout=timeout, max_retries=retries)
self.http.mount("https://", adapter)
self.http.mount("http://", adapter)
def test_override_base(self):
session = sessions.BaseUrlSession('https://www.google.com')
recorder = get_betamax(session)
with recorder.use_cassette('simple_get_request'):
response = session.get('https://httpbin.org/get')
response.raise_for_status()
assert response.json()['headers']['Host'] == 'httpbin.org'
def __init__(self, playlist_base):
self.m3u8_session = sessions.BaseUrlSession(base_url=playlist_base)
adapter = requests.adapters.HTTPAdapter(pool_connections=5, pool_maxsize=5, max_retries=10)
self.m3u8_session.mount('http://', adapter)
self.m3u8_session.mount('https://', adapter)
self.success = True
self.failed_list = []
self.completed = {}
def __init__(self, username, password):
super(MobileCommonsIntegration, self).__init__()
if username and password:
self.mc_api = sessions.BaseUrlSession(
base_url='https://secure.mcommons.com')
self.mc_api.auth = HTTPBasicAuth(username, password)
else:
raise Exception('unable to authenticate to MobileCommons')
def __init__(self, host, api_key):
super(Jackett, self).__init__()
self._api_key = api_key
self._caps = {}
self._session = sessions.BaseUrlSession(
base_url=urljoin(host, "/api/v2.0/indexers/"))
self.get_caps()
def __init__(self, config):
self.url = config["url"]
self.session = sessions.BaseUrlSession(base_url=self.url)
if "token" in config:
self.session.headers.update({"X-Device-Token": config["token"]})
else:
self.session.headers.update({"X-Device-Token": config['environ']})
self.min_delay = 0.6
def endpt(self, url):
baseurl = "https://financialmodellingprep.com/api/v3/"
http = sessions.BaseUrlSession(base_url=baseurl)
path = (url + "?apikey={}").format(self.symb, self.getkey)
#print(path)
result = http.get(path).text
return json.loads(result)
def __init__(self, host, username, password):
self.session = sessions.BaseUrlSession(base_url=urljoin(host, 'api/'))
token = codecs.decode(b64encode(codecs.encode(f'{username}:{password}')))
self.session.headers.update({
'User-Agent': 'mautic2keycloak',
'Accept': 'application/json',
'Authorization': f'Basic {token}'
})
def __init__(self):
self.api_key = getpass.getpass('api_key: ')
self.endpoint = sessions.BaseUrlSession(
base_url="https://content.guardianapis.com")
adapter = HTTPAdapter(
max_retries=Retry(total=3,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504]))
self.endpoint.mount('https://', adapter)
def cloudflare(ctx, email, token):
client = sessions.BaseUrlSession(base_url="https://api.cloudflare.com")
client.hooks["response"] = [exit_hook]
client.headers.update({
"x-auth-email": email,
"x-auth-key": token,
})
ctx.obj = {"client": client}
def drop_dbs() -> None:
with sessions.BaseUrlSession(base_url="http://localhost:5984/") as client:
client.auth = ("admin", "adminadmin")
all_dbs = client.get("_all_dbs").json()
for db in all_dbs:
if db == MASTER_DB:
continue
response = client.delete(f"{db}")
assert response.status_code == 200
def __init__(self, email, password):
self.id = None
self.email = email
self.password = password
self.credentials = {
'email': email,
'password': password
}
self.requests = sessions.BaseUrlSession(
base_url='http://localhost:5000')
def log_all():
def log_request(resp, *args, **kwargs):
#print(f"Hook: {resp.url}")
data = dump.dump_all(resp)
print(data.decode())
session = sessions.BaseUrlSession("https://httpbin.org")
session.hooks['response'] = [
log_request,
]
session.get("/ip")
def get_endpoint(endpoint, params=None):
with sessions.BaseUrlSession(
base_url="https://api.covid19api.com/") as session:
try:
response = session.get(endpoint)
response.raise_for_status()
logging.info(f"Request successful for endpoint={endpoint}.")
except requests.exceptions.HTTPError as e:
logging.error(f"{e}. Retrying...")
response = get_endpoint(endpoint)
return response
def teams_session():
client_id = ge('client_id')
authority_id = ge('authority_id')
client_credential = ge('client_credential')
BASE_URL = "https://graph.microsoft.com/beta/"
ms_s = sessions.BaseUrlSession(base_url=BASE_URL)
app = ConfidentialClientApplication(
client_id=client_id,
authority=f"https://login.microsoftonline.com/{authority_id}",
client_credential=client_credential)
result = app.acquire_token_for_client(
scopes=["https://graph.microsoft.com/.default"])
token = result['access_token']
sessions.BaseUrlSession(base_url='https://graph.microsoft.com/beta/')
ms_s.headers.update({"Authorization": f"Bearer {token}"})
return ms_s
def __init__(self, domain, api_key):
super(RogueIntegration, self).__init__()
if api_key:
self.rogue_session = sessions.BaseUrlSession(base_url='https://' +
domain)
self.rogue_session.headers = {
'X-DS-Importer-API-Key': api_key,
'Accept': 'application/json'
}
else:
raise Exception('unable to authenticate to Rogue')
def build_http(customer, headers):
"""Build an HTTP object with backoff/retry."""
retry_strategy = Retry(
total=7,
status_forcelist=[429, 500, 502, 503, 504],
backoff_factor=1,
)
adapter = HTTPAdapter(max_retries=retry_strategy)
base_url = f'https://www.googleapis.com/admin/directory/v1.1beta1/customer/{customer}/'
http_client = sessions.BaseUrlSession(base_url=base_url)
http_client.mount("https://", adapter)
http_client.headers.update(headers)
return http_client
def retry():
session = sessions.BaseUrlSession("http://httpstat.us")
session.verify = False
retry_strategy = Retry(total=3,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["HEAD", "GET", "OPTIONS"],
backoff_factor=1)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
session.mount("https://", adapter)
session.get("/500")
def cp_native_server(request):
"""A native server."""
class Root(object):
@cherrypy.expose
def index(self):
return 'Hello World!'
cls = cherrypy._cpnative_server.CPHTTPServer
cherrypy.server.httpserver = cls(cherrypy.server)
cherrypy.tree.mount(Root(), '/')
cherrypy.engine.start()
request.addfinalizer(cherrypy.engine.stop)
url = 'http://localhost:{cherrypy.server.socket_port}'.format(**globals())
return sessions.BaseUrlSession(url)
