def handle_401(self, r, **kwargs):
"""Resends a request with auth headers, if needed."""
www_authenticate = r.headers.get('www-authenticate', '').lower()
if 'basic' in www_authenticate:
if self.pos is not None:
r.request.body.seek(self.pos)
# Consume content and release the original connection
# to allow our new request to reuse the same one.
r.content
r.raw.release_conn()
prep = r.request.copy()
if not hasattr(prep, '_cookies'):
prep._cookies = cookies.RequestsCookieJar()
cookies.extract_cookies_to_jar(prep._cookies, r.request, r.raw)
prep.prepare_cookies(prep._cookies)
self.auth = auth.HTTPBasicAuth(self.username, self.password)
prep = self.auth(prep)
_r = r.connection.send(prep, **kwargs)
_r.history.append(r)
_r.request = prep
return _r
if 'digest' in www_authenticate:
self.auth = auth.HTTPDigestAuth(self.username, self.password)
# Digest auth would resend the request by itself. We can take a
# shortcut here.
return self.auth.handle_401(r, **kwargs)
def warn(change_id, revision_id):
url = ('https://review.openstack.org/a/changes/%s/revisions/%s/review' %
(change_id, revision_id))
data = {'message': WARN_MSG}
if CONF.dryrun:
return
response = requests.post(url, json=data,
auth=auth.HTTPDigestAuth(CONF.gerrit_user,
CONF.http_password))
def abandon(change_id):
url = ('https://review.openstack.org/a/changes/%s/abandon' %
change_id)
data = {'message': AB_MSG}
if CONF.dryrun:
return
response = requests.post(url, json=data,
auth=auth.HTTPDigestAuth(CONF.gerrit_user,
CONF.http_password))
def __init__(
self,
service_url,
username=None,
password=None,
service_name=None,
timeout=HTTP_TIMEOUT,
connection=None,
):
"""
:param service_url: http://user:passwd@host:port/json_rpc"
:param service_name: method name of monero wallet RPC and monero daemon RPC
"""
self.__service_url = service_url
self.__service_name = service_name
self.__timeout = timeout
self.__url = urlparse.urlparse(service_url)
if self.__url.port is None:
port = 80
else:
port = self.__url.port
self.__rpc_url = (
self.__url.scheme
+ "://"
+ self.__url.hostname
+ ":"
+ str(port)
+ self.__url.path
)
user = username if username else self.__url.username
passwd = password if password else self.__url.password
# Digest Authentication
authentication = None
log.debug(f"{user}, {passwd}")
if user is not None and passwd is not None:
authentication = auth.HTTPDigestAuth(user, passwd)
headers = {
"Content-Type": "application/json",
"User-Agent": USER_AGENT,
"Host": self.__url.hostname,
}
if connection:
# Callables re-use the connection of the original proxy
self.__conn = connection
else:
self.__conn = Session()
self.__conn.auth = authentication
self.__conn.headers = headers
def __init__(
self,
service_url,
username=None,
password=None,
service_name=None,
timeout=HTTP_TIMEOUT,
connection=None,
):
"""
:param service_url: Monero RPC URL, like http://user:passwd@host:port/json_rpc.
:param service_name: Method name of Monero RPC.
"""
self.__service_url = service_url
self.__service_name = service_name
self.__timeout = timeout
self.__url = urlparse.urlparse(service_url)
port = self.__url.port if self.__url.port else 80
self.__rpc_url = (
self.__url.scheme
+ "://"
+ self.__url.hostname
+ ":"
+ str(port)
+ self.__url.path
)
if connection:
# Callables re-use the connection of the original proxy
self.__conn = connection
else:
headers = {
"Content-Type": "application/json",
"User-Agent": USER_AGENT,
"Host": self.__url.hostname,
}
user = username if username else self.__url.username
passwd = password if password else self.__url.password
# Digest Authentication
authentication = None
if user is not None and passwd is not None:
authentication = auth.HTTPDigestAuth(user, passwd)
self.__conn = Session()
self.__conn.mount(
f"{self.__url.scheme}://{self.__url.hostname}", self.retry_adapter
)
self.__conn.auth = authentication
self.__conn.headers = headers
def getData(accountID):
# get from database
if accountID in dataDic:
return dataDic[accountID]
res = requests.get(
"http://51.104.239.212:8060/v1/documents?uri=/documents/" + accountID +
".json",
auth=auth.HTTPDigestAuth("admin", "admin"))
print(1)
if res.status_code == 404:
dataDic[accountID] = False
return False
result = json.loads(res.text)
dataDic[accountID] = result
return result
def __init__(self,
project,
user=None,
password=None,
updating_review_cb=lambda x: None):
self.base_url = 'https://review.openstack.org/'
if not (user and password):
config = _read_config()
user = config['username']
password = config['password']
self.base_url = config['url']
self.auth = auth.HTTPDigestAuth(user, password)
self.project = project
self.updating_review_cb = updating_review_cb
def parse_auth(self, auth):
# Parse "auth" parameter
if type(auth) is not tuple or len(auth) != 3:
return None
method, username, password = auth
# Basic Authentication
if method == 'basic':
print 'basic authentication method being used.'
return requestsauth.HTTPBasicAuth(username, password)
# Digest Authentication
if method == 'digest':
print 'digest authentication method being used.'
return requestsauth.HTTPDigestAuth(username, password)
raise NotImplementedError('Unsupported authentication method: %r' %
method)
def __init__(self,
service_url,
service_name=None,
timeout=HTTP_TIMEOUT,
connection=None):
"""
:param service_url: http://user:passwd@host:port/json_rpc"
:param service_name: method name of monero wallet RPC and monero daemon RPC
"""
self.__service_url = service_url
self.__service_name = service_name
self.__timeout = timeout
self.__url = urlparse.urlparse(service_url)
if self.__url.port is None:
port = 80
else:
port = self.__url.port
self.__rpc_url = (self.__url.scheme + '://' + self.__url.hostname +
':' + str(port) + self.__url.path)
(user, passwd) = (self.__url.username, self.__url.password)
# Digest Authentication
authentication = None
log.debug('{0}, {1}'.format(user, passwd))
if user is not None and passwd is not None:
authentication = auth.HTTPDigestAuth(user, passwd)
headers = {
'Content-Type': 'application/json',
'User-Agent': USER_AGENT,
'Host': self.__url.hostname
}
if connection:
# Callables re-use the connection of the original proxy
self.__conn = connection
else:
self.__conn = Session()
self.__conn.auth = authentication
self.__conn.headers = headers
def auth_basic_digest(self):
"""
return data for basic/digest auth
"""
params = dict()
for item in self.auth_params.split(','):
params[item.split("=")[0]] = item.split("=")[1]
if self.auth.lower() == "basic":
try:
return auth.HTTPBasicAuth(params["login"], params["password"])
except:
sys.exit("ERROR: Basic auth has no login and password fields")
if self.auth.lower() == "digest":
try:
return auth.HTTPDigestAuth(params["login"], params["password"])
except:
sys.exit("ERROR: Digest auth has no login and password fields")
def __init__(self, host='localhost', port=8080, user='******', password=''):
""" Roughly the order of requests used in the built in deluge webui that we emulate
1. system.listMethods
2. auth.check_session: []
3. web.register_event_listener [PluginDisabledEvent]
4. web.register_event_listener [PluginEnabledEvent]
5. web.get_events []
6. web.connected []
7. web.update_ui [["queue","name","total_size","state","progress","num_seeds",
"total_seeds","num_peers","total_peers","download_payload_rate","upload_payload_rate",
"eta","ratio","distributed_copies","is_auto_managed","time_added","tracker_host",
"save_path","total_done","total_uploaded","max_download_speed","max_upload_speed",
"seeds_peers_ratio"],{}]
8. web.get_plugins
9. web.update_ui
10. web.get_events [] (periodic?)
If the password is not accepted _valid_password will be set to false and prevent any
more requests from happening.
:param host: Host of the deluge webui
:type host: basestring
:param port: Port of the webui (default: 8112)
:type port: int
:param password: Password to the webui (default: deluge)
:type password: string
"""
super(QBittorrentClient, self).__init__()
self._endpoint = 'http://{}:{}/json'.format(host, port)
self._session = requests.session()
self._session.auth = auth.HTTPDigestAuth(user, password)
self._headers = {
'Content-type': 'application/json',
'Accept': 'application/json'
}
self._req_id = 0
self._valid_password = True
self._last_request = 0
def request(self, host, handler, request_body, verbose):
"""
Make an xmlrpc request.
"""
url = self._build_url(host, handler)
try:
resp = requests.post(url,
data=request_body,
timeout=30,
auth=auth.HTTPDigestAuth(
self._username, self._password))
except ValueError:
raise
except Exception:
raise # something went wrong
else:
try:
resp.raise_for_status()
except requests.RequestException as e:
raise xmlrpclib.ProtocolError(url, resp.status_code, str(e),
resp.headers)
else:
return self.parse_response(resp, verbose)
def getDataForAccount(accountID):
with open(
"/Users/yhw/Desktop/CS/2ndYear/SystemEngineering/webapp-testing/aux_files/finalData.json",
'r') as data:
a = json.load(data)
resultDic = {}
for key in a['Data']:
current = []
for item in a['Data'][key]:
if item["AccountId"] == accountID:
if key == "Account":
month = item["OpeningDate"][3:5]
day = item["OpeningDate"][0:2]
resultDic["BillingDate"] = month + '-' + day
current.append(item)
resultDic[key] = current
result = json.dumps(resultDic)
url = "http://51.104.239.212:8060/v1/documents?uri=/documents/" + accountID + ".json"
headers = {'Content-Type': 'application/json'}
r = requests.put(url,
data=json.dumps(result),
headers=headers,
auth=auth.HTTPDigestAuth("admin", "admin"))
return
def __init__(self, configuration, credentials):
"""
Initiate an object with configuration and credentials.
The initialized client will then operate within the given Atlas group, and the given user.
Other than this, it is stateless: methods are merely HTTP wrappers.
Note: credentials passed in as a separate object to keep them from being accidentally
dumped to logs.
:param dict configuration: group_id (required) and api root url (optional)
:param dict credentials: user and key (required)
"""
self.group_id = configuration["group_id"]
self.root = configuration.get("root", DEFAULT_ROOT_URL)
self.root += "/" if self.root[-1] != "/" else ""
self.private_root = configuration.get("private", PRIVATE_ROOT_URL)
self.private_root += "/" if self.private_root[-1] != "/" else ""
# Check and fail early if credentials missing
assert credentials["public_key"]
assert credentials["private_key"]
self.auth = auth.HTTPDigestAuth(credentials["public_key"],
credentials["private_key"])
def create_digest_auth(config):
return requests_auth.HTTPDigestAuth(config['username'], config['password'])
def __init__(self, username, password):
self.digest_auth = auth.HTTPDigestAuth(username, password)
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from users.forms import UserRegistrationForm, UserUpdateForm, ProfileUpdateForm
import requests
from requests import auth
import json
from django.contrib import messages
import requests, json
from requests import auth
me = auth.HTTPDigestAuth("admin", "admin")
resp = requests.get("http://51.132.8.252:8060/v1/search?format=json", auth=me)
jsonFile = json.loads(resp.text)
result = jsonFile["results"]
a = []
for key in result:
uri = key["uri"]
res = requests.get("http://51.132.8.252:8060/v1/documents?uri=" + uri,
auth=me)
a.append(res.json())
print(a)
a = [{
'accounts': [{
'id':
'8ca8a7e4-6d02-40e3-a129-0b2bf89de9f0',
'label':
'My Account',
'bank_id':
'GENODEM1GLS',
'account_routings': [{
# Purpose: Scripts for accessing and querying the MarkLogic server
#
# Author: Schei008
#
# Created: 13-02-2019
# Copyright: (c) Schei008 2019
# Licence: <your licence>
#-------------------------------------------------------------------------------
import requests
from requests import auth
import json
import pandas as pd
#import rdflib
me = auth.HTTPDigestAuth("simon", "$28*Mfrh")
url = 'http://localhost:8000/v1/graphs/sparql'
prefixes = 'PREFIX db: <http://dbpedia.org/resource/> \
PREFIX onto: <http://dbpedia.org/ontology/> \
PREFIX owl: <http://www.w3.org/2002/07/owl#> \
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \
PREFIX cts: <http://marklogic.com/cts#> \
PREFIX dc: <http://purl.org/dc/elements/1.1/>\
'
""""Firing SPARQL queries against Mark Logic"""
#Fires a query against MarkLogic and returns a Pandas DF
def queryforDF(query):
- r.request.body.seek(self.pos)
-
- # Consume content and release the original connection
- # to allow our new request to reuse the same one.
- r.content
- r.raw.release_conn()
- prep = r.request.copy()
- if not hasattr(prep, '_cookies'):
- prep._cookies = cookies.RequestsCookieJar()
- cookies.extract_cookies_to_jar(prep._cookies, r.request, r.raw)
- prep.prepare_cookies(prep._cookies)
-
- self.auth = auth.HTTPBasicAuth(self.username, self.password)
- prep = self.auth(prep)
- _r = r.connection.send(prep, **kwargs)
- _r.history.append(r)
- _r.request = prep
-
- return _r
+ return self._handle_basic_auth_401(r, kwargs)
if 'digest' in www_authenticate:
- self.auth = auth.HTTPDigestAuth(self.username, self.password)
- # Digest auth would resend the request by itself. We can take a
- # shortcut here.
- return self.auth.handle_401(r, **kwargs)
+ return self._handle_digest_auth_401(r, kwargs)
def __call__(self, request):
if self.auth is not None:
