def add(request):
instance = Person(verified=False, ip="127.0.0.1",
last_updated=datetime.datetime.utcfromtimestamp(0))
form = AddPersonForm(request.POST or None, instance=instance)
if form.is_valid():
person = form.save(commit=False)
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
host = resolve_location(person)
connection = HTTPSConnection(host=host, port=8080,
context=ssl_context)
connection.request("GET", reverse("directory:info"))
response = connection.getresponse()
data = JSONParser().parse(response)
cert = connection.sock.getpeercert()
connection.close()
serializer = PublicPersonSerializer(person, data=data)
cn = None
#for key, value in cert["subject"]:
# if key == "commonName":
# cn = value
# break
#if cn == person.location and serializer.is_valid():
if serializer.is_valid():
serializer.save()
return HttpResponseRedirect(reverse("directory:index"))
context = {"form": form, "section": "directory"}
return render(request, "person_form.html", context)
def filter(self):
url = "https://stream.twitter.com/1.1/statuses/filter.json"
query = {}
querystring =""
if self.track:
query["track"] = self.track
querystring += "track="+quote(self.track)
if self.locations:
query["locations"] = self.locations
if querystring:
querystring += "&"
querystring += "locations="+quote(self.locations)
self.start_time = int(time.time())
running = True
while running:
try:
auth_header = self.generate_authorization_header("POST",url,query)
logging.getLogger("twitstream").debug("calling: https://stream.twitter.com/1.1/statuses/filter.json?"+querystring)
conn = HTTPSConnection("stream.twitter.com")
conn.request("POST","/1.1/statuses/filter.json?"+querystring,"",{'User-agent':'Mozilla/5.0','Authorization':auth_header})
running = self.stream(conn)
except Exception as ex:
logging.getLogger("twitstream").error(str(ex))
def _is_online(domain, sub_path, response_status, response_reason):
conn = HTTPSConnection(domain, timeout=1)
conn.request("HEAD", sub_path)
response = conn.getresponse()
conn.close()
return (response.status == response_status) and (response.reason == response_reason)
def submit_xml_request(xml_file):
'''
Submit the xml request to MAST.
Parameters:
xml_file : string
The xml request string.
Returns:
response : httplib object
The xml request submission result.
'''
home = os.environ.get("HOME")
user = os.environ.get("USER")
signer = SignStsciRequest()
request_xml_str = signer.signRequest("{0}/.ssh/privkey.pem".format(home),
xml_file)
params = urllib.urlencode({
"dadshost": "dmsops1.stsci.edu",
"dadsport": 4703,
"mission": "HST",
"request": request_xml_str})
headers = {"Accept": "text/html",
"User-Agent": "{0}PythonScript".format(user)}
req = HTTPSConnection("archive.stsci.edu")
req.request("POST", "/cgi-bin/dads.cgi", params, headers)
response = req.getresponse().read()
return response
def get_yandex_translate(self, searching_text, to_language):
try:
quoted_text = quote(u"" + searching_text + "")
req = '/api/v1.5/tr.json/translate?' \
'key=trnsl.1.1.20150629T151613Z.82119cbb3415f490.ba44aa922a8b28e549144e0e2fa6249c7508358e' \
'&text=' + quoted_text \
+ "&lang=" + to_language \
+ '&options=1'
conn = HTTPSConnection('translate.yandex.net')
conn.request("GET", req)
rez = conn.getresponse()
data = rez.read()
conn.close()
if rez.status == 200:
ddata = data.decode("utf-8")
j = simplejson.loads(ddata, )
tr_text = ''.join(j['text'])
print(tr_text)
return tr_text
else:
print("Something is wrong: " + str(rez.status) + " status code")
print(data)
except HTTPException as err:
print(err)
def send(self, type, text, raw):
message_time = time.time()
message_timestamp = time.ctime(message_time)
if check_time_restriction(self.starttime, self.endtime):
if self.suppress_timestamp == False:
self.msg_to_send = text[:10000].encode('utf8') + " Message Sent at: " + message_timestamp
else:
self.msg_to_send = text[:10000].encode('utf8')
notify_data = {
'apikey': self.api_key,
'application': self.app_name,
'event': self.event,
'description': self.msg_to_send,
'priority': self.priority
}
if sys.version_info >= (2,7,9):
http_handler = HTTPSConnection(PROWL_URL, context=ssl._create_unverified_context())
else:
http_handler = HTTPSConnection(PROWL_URL)
http_handler.request(PROWL_METHOD, PROWL_PATH, headers=self.headers,body=urlencode(notify_data))
http_response = http_handler.getresponse()
if http_response.status == 200:
return True
else:
current_app.logger.info('Event Prowl Notification Failed: {0}'. format(http_response.reason))
raise Exception('Prowl Notification Failed: {0}' . format(http_response.reason))
def _send(self, message):
"""
Sends the specified PushoverMessage object via the Pushover API.
"""
kwargs = message.get()
kwargs['token'] = self.token
assert 'message' in kwargs
assert self.token is not None
if not 'user' in kwargs:
if self.set_user is not None:
kwargs['user'] = self.user_token
if self.user_device is not None:
kwargs['device'] = self.user_device
else:
kwargs['user'] = os.environ['PUSHOVER_USER']
data = urlencode(kwargs)
conn = HTTPSConnection(Pushover.PUSHOVER_SERVER)
conn.request("POST", Pushover.PUSHOVER_ENDPOINT, data,
Pushover.PUSHOVER_CONTENT_TYPE)
output = conn.getresponse().read().decode('utf-8')
data = json.loads(output)
if data['status'] != 1:
raise PushoverError(output)
else:
return True
def getRemoteDBModifiedTS():
"""
Performs a HEAD request to get the Last-Modified date-time
of a database dump file and parses it into a UNIX timestamp.
"""
debug_msg = "Unable to get timestamp of remote database dump - {0}"
logging.info("Getting timestamp of database dump at '%s'", HOST + PATH)
try:
# Removing the scheme from the URL
conn = HTTPSConnection(HOST[8:], timeout=TIMEOUT)
conn.request("HEAD", PATH)
except gaierror as e:
logging.debug(debug_msg.format("Cannot connect to '%s', error: %s"), HOST + PATH, e)
exit(1)
rsp = conn.getresponse()
if rsp.status != 200:
logging.debug(debug_msg.format("Server responded with: %d %s"), rsp.status, rsp.reason)
exit(1)
last_modified = rsp.getheader("last-modified", None)
if last_modified is None:
logging.debug(debug_msg.format("Response doesnt include Last-Modified Header"))
exit(1)
last_m_dt = datetime.strptime(last_modified.split(", ")[1], "%d %b %Y %H:%M:%S %Z")
return timegm(last_m_dt.timetuple())
def push(event, msg):
global config
data = {'apikey': config["API_KEY"],
'application': __application__,
'event': event,
'description': msg,
'priority': 0}
h = Https(config["API_DOMAIN"])
h.request("POST",
"/publicapi/add",
headers={'Content-type': "application/x-www-form-urlencoded",
'User-Agent': __application__ + '/' + str(__version__)
},
body=urlencode(data))
response = h.getresponse()
request_status = response.status
if request_status == 200:
return True
else:
return False
def submit_xml_request(xml_request):
"""Submit the XML request to the MAST archive.
Parameters
----------
xml_request : string
The request XML string.
Returns
-------
submission_results : httplib object
The XML request submission results.
"""
user = os.environ.get("USER")
home = os.environ.get("HOME")
signer = SignStsciRequest()
request_xml_str = signer.signRequest('{0}/.ssh/privkey.pem'.format(home), xml_request)
params = urlencode({
'dadshost': get_settings()['dads_host'],
'dadsport': 4703,
'mission':'HST',
'request': request_xml_str})
headers = {"Accept": "text/html", "User-Agent":"{0}PythonScript".format(user)}
req = HTTPSConnection(get_settings()['archive'])
req.request("POST", "/cgi-bin/dads.cgi", params, headers)
response = req.getresponse().read()
req.close()
return response
def post_mp_request(self,data,files,extra_path=""):
# Create the multipart request body
buffer_fname = tempfile.mktemp()
buffer_fp = open(buffer_fname,'wb')
mpw = MultiPartWriter(buffer_fp)
mpw.add_attachment(data.encode('utf-8'),'application/json, charset=UTF-8','body')
for cid,fp in files.items():
mpw.add_attachment(fp,'application/octet-stream',cid)
mpw.done()
buffer_fp.close()
headers = {
"Content-type": b'multipart/related; boundary=' + mpw.boundary,
"Accept": b'application/json,multipart/related'}
if self.scheme.lower()=='https':
conn = HTTPSConnection(self.hostname,self.port)
else:
conn = HTTPConnection(self.hostname,self.port)
req_path = self.path + '/' + extra_path
buffer_fp = open(buffer_fname,'rb')
conn.request("POST", req_path, buffer_fp, headers)
buffer_fp.close()
jsonwsp_response = self.parse_response(conn.getresponse())
conn.close()
os.unlink(buffer_fname)
return jsonwsp_response
def query(self, endpoint, arguments=None):
if not endpoint.startswith('/'):
endpoint = '/' + endpoint
if not endpoint.endswith(ApiClient.ENDPOINT_EXT):
endpoint += ApiClient.ENDPOINT_EXT
if arguments is None:
arguments = {}
query_string = '?'.join([endpoint, urlencode(arguments)])
result = self.cache.get(query_string)
if result is not None:
return objectify.fromstring(result)
connection = HTTPSConnection(ApiClient.API_HOST)
connection.request('GET', query_string)
response = connection.getresponse()
if response.status != 200:
raise ApiError('Error response: ' + str(response.status))
result = response.read()
result_object = objectify.fromstring(result)
cached_until = datetime.strptime(result_object.cachedUntil.text,
ApiClient.TIMESTAMP_FORMAT)
self.cache.set(query_string, result, cached_until)
return result_object
def ping_url(protocol, url):
url = to_string(url)
protocol = to_string(protocol).lower()
url_parts = url.split('/', 1)
host = url_parts[0]
if len(url_parts) == 1:
path = '/'
else:
path = '/%s' % url_parts[1]
if protocol == 'https':
connection = HTTPSConnection(host)
elif protocol == 'http':
connection = HTTPConnection(host)
else:
raise ValueError('url', 'Invalid protocol %s. Use only http or https.' % protocol)
valid_url = False
try:
connection.request('HEAD', path)
response = connection.getresponse()
except Exception:
pass
else:
if response.status != 404:
valid_url = True
finally:
connection.close()
return valid_url
def _send_post(self, url, payload={}):
payload = copy.copy(payload) # avoid modifying the original dict
# add some stuff to the payload
payload['nonce'] = int(time.time()*1e6)
body = urllib.parse.urlencode(payload).encode() # convert to bytes object
sig = hmac.new(base64.b64decode(self._secret), body, hashlib.sha512).digest()
sig_b64 = base64.b64encode(sig)
headers = {
'bitfloor-key': self._key,
'bitfloor-sign': sig_b64,
'bitfloor-passphrase': self._passphrase,
'bitfloor-version': self._api_version,
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': len(body)
}
conn = HTTPConn(self._host, self._order_port)
conn.request("POST", url, body, headers)
resp = conn.getresponse()
s = resp.read().decode() # comes as a bytes object, decode to a string
conn.close()
return json.loads(s)
def do_request(self, method, url, params = {}):
final_url = url
if method == 'GET' and params:
final_url += '?' + urlencode(params)
request_body = None
elif (method == 'POST' or method == 'PUT') and params:
request_body = urlencode(params)
else:
request_body = None
print("Starting {method} {final_url}".format(method = method, final_url = final_url))
if self.use_ssl:
con = HTTPSConnection(self.base_url)
else:
con = HTTPConnection(self.base_url)
headers = {}
headers["Content-Type"] = "application/x-www-form-urlencoded"
headers["ISV_API_KEY"] = self.key
headers["ISV_API_SECRET"] = self.secret
headers["LCNS_DISABLE_SIGN"] = "true"
con.request(method, final_url, request_body, headers)
res = con.getresponse()
body = res.read()
status = res.status
if self.debug:
debug_message = ""
debug_message += "################################\n"
debug_message += "REQUEST: {method} {uri}\n".format(method = method.upper(), uri = self.request_url(final_url) )
if params and ( method == 'POST' or method == 'GET' ):
debug_message += "PARAMETERS: {params}\n".format(params = params)
debug_message += "RESPONSE CODE: {status}\n".format(status = status)
debug_message += "BODY:\n{body}\n".format(body = body)
debug_message += "================================\n"
print(debug_message)
return {'body': body, 'status': status}
def send(self, type, text):
message_time = time.time()
message_timestamp = time.ctime(message_time)
if check_time_restriction(self.starttime, self.endtime):
self.msg_to_send = text[:10000].encode('utf8') + " Message Sent at: " + message_timestamp
self.event = NMA_EVENT.encode('utf8')
self.content_type = NMA_CONTENT_TYPE
notify_data = {
'application': self.app_name,
'description': self.msg_to_send,
'event': self.event,
'priority': self.priority,
'content-type': self.content_type,
'apikey': self.api_key
}
headers = { 'User-Agent': NMA_USER_AGENT }
headers['Content-type'] = NMA_HEADER_CONTENT_TYPE
http_handler = HTTPSConnection(NMA_URL)
http_handler.request(NMA_METHOD, NMA_PATH, urlencode(notify_data), headers)
http_response = http_handler.getresponse()
try:
res = self._parse_response(http_response.read())
except Exception as e:
res = {
'type': 'NMA Notify Error',
'code': 800,
'message': str(e)
}
current_app.logger.info('Event NotifyMyAndroid Notification Failed: {0}'.format(str(e)))
raise Exception('NotifyMyAndroid Failed: {0}' . format(str(e)))
def ensure_no_open_tickets(version):
version = "v%s" % version
conn = HTTPSConnection("api.github.com")
try:
log("Checking for open tickets on Github for version %s" % version)
log("Check if node is available")
conn.request(
"GET",
"/repos/elasticsearch/elasticsearch/issues?state=open&labels=%s" % version,
headers={"User-Agent": "Elasticsearch version checker"},
)
res = conn.getresponse()
if res.status == 200:
issues = json.loads(res.read().decode("utf-8"))
if issues:
urls = []
for issue in issues:
urls.append(issue["url"])
raise RuntimeError("Found open issues for release version %s see - %s" % (version, urls))
else:
log("No open issues found for version %s" % version)
else:
raise RuntimeError("Failed to fetch issue list from Github for release version %s" % version)
except socket.error as e:
log("Failed to fetch issue list from Github for release version %s' % version - Exception: [%s]" % (version, e))
# that is ok it might not be there yet
finally:
conn.close()
def _url_retrieve(self, url, outfd, reporthook, binary):
#Like the one in urllib. Unlike urllib.retrieve url_retrieve
#can be interrupted. KeyboardInterrupt exception is raised when
#interrupted.
count = 0
blockSize = 1024 * 8
parsed_url = urlparse(url)
host = parsed_url.netloc
try:
connection = HTTPSConnection(host, timeout=15)
headers = { "Accept-Encoding": "identity", "Host": host, "User-Agent": "Python/3" }
connection.request("GET", parsed_url.path, headers=headers)
urlobj = connection.getresponse()
assert urlobj.getcode() == 200
totalSize = int(urlobj.info()['content-length'])
while not self._is_aborted():
data = urlobj.read(blockSize)
count += 1
if not data:
break
if not binary:
data = data.decode("utf-8")
outfd.write(data)
ui_thread_do(reporthook, count, blockSize, totalSize)
except Exception as e:
raise e
def send(self, message):
"""
Sends a specified message with id "message" or as object.
"""
# Only send message if message is instance of PushoverMessage
if type(message) is PushoverMessage:
# get dict contaning "message" and any other key-values declared
# by the "set" method.
data = message.get()
data['token'] = self.token
# define which user to send notification to if any
if self.user is not None:
data['user'] = self.user_token
# define which device to send notification to if any
if self.user_device is not None:
data['device'] = self.user_device
# initialise HTTPS connection
conn = HTTPSConnection(self.PUSHOVER_SERVER)
# send HTTPS request
conn.request(
"POST",
self.PUSHOVER_ENDPOINT,
urlencode(data),
self.PUSHOVER_CONTENT_TYPE
)
# get response form server
response = conn.getresponse().read().decode('utf-8')
data = json.loads(response)
# check response for error
if data['status'] != 1:
raise PushoverError(response)
else:
return True
else:
raise PushoverError("Wrong type passed to Pushover.send()!")
def callapi(self, method, path, args):
# Set headers.
headers = {
'User-Agent': USER_AGENT
}
# Set content type if we want to post the data.
if method == "POST":
headers['Content-type'] = "application/x-www-form-urlencoded"
# Create the HTTPSConnection and do the api call.
http_handler = HTTPSConnection(API_SERVER)
http_handler.request(method, path, urlencode(args), headers)
# Get the response.
resp = http_handler.getresponse()
try:
# Return the API-Response.
return self._parse_reponse_json(resp.read())
except Exception as e:
# Return response could not be parsed.
return {
'type': "RapidPush parse error",
'code': 600,
'message': str(e)
}
def call(self, method='', params=None):
""" Call T411 API """
if params is not None:
params = urlencode(params)
headers = HTTP_HEADERS
if method != 'auth':
headers['Authorization'] = self._token
conn = HTTPSConnection(API_URL)
conn.request('POST', '/%s' % method, body=params, headers=headers)
r = conn.getresponse()
if r.status == HTTP_OK:
#import pdb; pdb.set_trace()
rt = r.read()
try:
pass
rt = rt.decode('utf-8')
conn.close()
except:
conn.close()
return rt
else:
conn.close()
return False
def httpsGet(self, url):
Log.d("GET " + url)
url = self.completeUrl(url)
headers = self.createHeaders()
conn = HTTPSConnection(self.server)
conn.request("GET", url, None, headers)
self.lastResponse = self.parseResponse(conn.getresponse())
return self.lastResponse
def normalise_package(name):
"""
"""
http = HTTPSConnection('pypi.python.org')
http.request('HEAD', '/pypi/%s/' % name)
r = http.getresponse()
if r.status not in (200, 301):
raise ValueError(r.reason)
return r.getheader('location', name).split('/')[-1]
def _send_get(self, url, payload={}):
body = urllib.parse.urlencode(payload)
conn = HTTPConn(self._host, self._data_port)
conn.request("GET", url, body)
resp = conn.getresponse()
s = resp.read().decode() # comes as a bytes-type object, decode to string
conn.close()
print(s)
return json.loads(s)
def retrieve_apikey(self, providerkey=None, token=None):
"""
Get an API key from a registration token retrieved in retrieve/token.
The user must have approved your request first, or you will get an
error response.
The parameters are :
- providerkey (required) : your provider API key.
- token (required): the token returned from retrieve_token.
This returns a dictionary such as:
{'apikey': u'16b776682332cf11102b67d6db215821f2c233a3',
'code': u'200',
'remaining': u'999',
'resetdate': u'1299535575'}
"""
h = Https(API_DOMAIN)
data = {'apikey': self.apikey}
if providerkey is not None:
data['providerkey'] = providerkey
else:
raise Exception("Provider Key is required for retrieving API key")
if token is not None:
data['token'] = token
else:
raise Exception("Token is required for retrieving API key.\
Call retrieve_token to request it.")
h.request("GET",
"/publicapi/retrieve/apikey?" + urlencode(data),
headers=self.headers)
request = h.getresponse()
request_status = request.status
if request_status == 200:
dom = minidom.parseString(request.read())
code = dom.getElementsByTagName('prowl')[0].\
getElementsByTagName('success')[0].\
getAttribute('code')
remaining = dom.getElementsByTagName('prowl')[0].\
getElementsByTagName('success')[0].\
getAttribute('remaining')
resetdate = dom.getElementsByTagName('prowl')[0].\
getElementsByTagName('success')[0].\
getAttribute('resetdate')
users_api_key = dom.getElementsByTagName('prowl')[0].\
getElementsByTagName('retrieve')[0].\
getAttribute('apikey')
return dict(apikey=users_api_key, code=code, remaining=remaining,
resetdate=resetdate)
else:
self._relay_error(request_status)
def request(self, method, url, body=None):
connection = HTTPSConnection('saucelabs.com')
connection.request(method, url, body, headers=self.headers)
response = connection.getresponse()
json_data = response.read()
connection.close()
if response.status != 200:
raise Exception('%s: %s.\nSauce Status NOT OK' %
(response.status, response.reason))
return json_data
def __init__(self, vidID):
conn = HTTPSConnection("www.youtube.com")
conn.request("GET", "/watch?v={}".format(vidID))
stream = conn.getresponse()
if stream.getheader("Content-Encoding") is not None:
stream = GzipFile(fileobj=stream)
self.data = str(stream.read(), "utf-8")
conn.close()
def lookForAddress(loc):
print("Google GEOCODE Query")
conn = HTTPSConnection("maps.googleapis.com")
parametres = "latlng="+loc.latlng()+"&sensor=false&key="+commons.googleAPIKey
conn.request("GET", "/maps/api/geocode/xml?"+parametres)
response = conn.getresponse()
data = response.read()
dom = parseString(data)
for d in dom.getElementsByTagNameNS("*", 'formatted_address'):
loc.desc = d.firstChild.data
return
def check_updated_certs(_address, _port, certhashlist, newhash=None, timeout=config.default_timeout, connect_timeout=config.connect_timeout, traversefunc=None):
update_list = []
if None in [_address, _port]:
logging.error("address or port empty")
return None
addr, _port = url_to_ipv6(_address, _port)
cont = default_sslcont()
con = HTTPSConnection(addr, _port, context=cont, timeout=connect_timeout)
try:
con.connect()
except (ConnectionRefusedError, socket.timeout):
if not traversefunc:
logging.warning("Connection failed")
return None
# try_traverse does not work here, scnreqest creates loop
con.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
con.sock.bind(('', 0))
traversefunc(("", con.sock.getsockname()[1]))
con.sock.settimeout(connect_timeout)
for count in range(0, config.traverse_retries):
try:
con.sock.connect((addr, _port))
break
except Exception:
pass
else:
logging.warning("traversal failed")
return None
con.sock.settimeout(timeout)
oldhash = dhash(ssl.DER_cert_to_PEM_cert(con.sock.getpeercert(True)).strip().rstrip())
if newhash and newhash != oldhash:
return None
oldsslcont = con.sock.context
for _hash, _security in certhashlist:
con.request("POST", "/usebroken/{hash}".format(hash=_hash), headers=cert_update_header)
con.sock = con.sock.unwrap()
con.sock = cont.wrap_socket(con.sock, server_side=False)
con.sock.do_handshake()
brokensslcert = ssl.DER_cert_to_PEM_cert(con.sock.getpeercert(True)).strip().rstrip()
con.sock = con.sock.unwrap()
# without next line the connection would be unencrypted now
con.sock = oldsslcont.wrap_socket(con.sock, server_side=False)
# con.sock.do_handshake()
ret = con.getresponse()
if ret.status != 200:
logging.info("checking cert failed, code: %s, reason: %s", ret.status, ret.reason)
continue
if con.sock and oldhash != dhash(ssl.DER_cert_to_PEM_cert(con.sock.getpeercert(True)).strip().rstrip()):
logging.error("certificate switch detected, stop checking")
break
if dhash(brokensslcert) == _hash:
update_list.append((_hash, _security))
con.close()
return update_list
def request_token(self):
connection = HTTPSConnection(self._host)
request = oauth.OAuthRequest.from_consumer_and_token(self._consumer,
http_url='https://' + self._host + '/oauth/request_token')
request.sign_request(self._signature_method, self._consumer, None)
connection.request(request.http_method, request.to_url())
resp = connection.getresponse()
if resp.status == 200:
self._oauth_token = oauth.OAuthToken.from_string(resp.read().decode())
return {'key': self._oauth_token.key, 'secret': self._oauth_token.secret}
else:
raise InsTwitterResponseError(resp.code, resp.read().decode())
def Image_DayMovie(TitleText):
global DayMovieDoc
global MovieChart
global ChartFlag
ImgURL = []
image = []
for i in range(0, 5):
if ChartFlag == True:
server = "openapi.naver.com"
client_id = "iEV22cE2b1ZJnyGDYXtc"
client_secret = "xJB_PnOFmw"
text = urllib.parse.quote(TitleText[i])
conn = HTTPSConnection(server)
conn.request(
"GET",
"/v1/search/movie.xml?query=" + text + "&display=10&start=1",
None, {
"X-Naver-Client-Id": client_id,
"X-Naver-Client-Secret": client_secret
})
req = conn.getresponse()
if int(req.status) == 200:
ImageDoc = parseString(req.read())
ImgURL.append(getJpgURL(ImageDoc, TitleText[i]))
else:
server = "openapi.naver.com"
client_id = "iEV22cE2b1ZJnyGDYXtc"
client_secret = "xJB_PnOFmw"
text = urllib.parse.quote(TitleText[i + 5])
conn = HTTPSConnection(server)
conn.request(
"GET",
"/v1/search/movie.xml?query=" + text + "&display=10&start=1",
None, {
"X-Naver-Client-Id": client_id,
"X-Naver-Client-Secret": client_secret
})
req = conn.getresponse()
if int(req.status) == 200:
ImageDoc = parseString(req.read())
ImgURL.append(getJpgURL(ImageDoc, TitleText[i + 5]))
for i in range(0, len(ImgURL)):
#print(ImgURL[i])
if ImgURL[i] != None:
with urllib.request.urlopen(ImgURL[i]) as u:
raw_data = u.read()
tmp = Image.open(BytesIO(raw_data))
tmp = tmp.resize((160, 208), Image.ANTIALIAS)
tmp = ImageTk.PhotoImage(tmp)
image.append(tmp)
JPG = Label(MovieChart, image=image[i], bg="Black")
JPG.place(x=55 + (180 * i), y=100)
else:
image.append(None)
MovieChart.mainloop()
class MatomoUser:
"""
Utils for trying an automatic connection to matomo
whenver a admin is loggin into django's admin interface.
Matomo and django admin sharing the same username/password
to perform this.
"""
SITE = "matomo"
def __init__(self, username, password):
self.nonce = None
self.user = username
self.password = password
self._cookie = SimpleCookie()
#SECURITY ISSUE:
# - certificate not checked, can lead to man in the middle attack
self.connection = HTTPSConnection(self.SITE,
context=ssl.SSLContext())
self._retrieve_session_cookie()
self.login()
def request(self, method, url, body=None, headers={}, read=False):
"""
Hook to perform request with http.client.
"""
#Try to add session cookie if already available.
try:
headers['Cookie'] = self.matomo_session
except KeyError:
pass
#Format post data.
if type(body) is dict:
body = urllib.urlencode(body)
#Add website root if needed
if url[0] != "/":
url = "/" + url
#Send the request to website
self.connection.request(method, url, \
body=body, headers=headers)
#Return the request response
response = self.connection.getresponse()
if read:
response.read()
return response
def _retrieve_session_cookie(self):
"""
Use to retrieve default data to login.
Retrieve the MATOMO_SESSID cookie and the
hidden form input login_form_nonce.
"""
response = self.request("GET", "/")
html_page = response.read().decode()
if response.status != 200:
raise MatomoUserException("Unable to connect to matomo site")
#Retrieve <form> nonce of matomo
pattern = "<input .*login_form_nonce.*?>"
input_tag = re.search(pattern, html_page)
if input_tag is None:
raise MatomoUserException("login_form_nonce not found.")
#Retrieve form nonce value
parser = NonceExtractor()
parser.feed(input_tag.group(0))
self.nonce = parser.nonce
self._cookie.load(response.headers['Set-Cookie'])
def login(self):
"""
Login user to matomo.
"""
post_data = {
"form_login" : self.user,
"form_password" : self.password,
**self.nonce,
}
headers = {
"Content-Type" : "application/x-www-form-urlencoded",
}
response = self.request("POST", "/?module=Login", \
post_data, headers, read=True)
self._cookie.load(response.headers['Set-Cookie'])
@property
def matomo_session(self):
"""
Get current MATOMO_SESSID cookie formated for http
request
"""
return "MATOMO_SESSID={}".format(self.cookie)
@property
def cookie(self):
return self._cookie['MATOMO_SESSID'].value
return False
print(out)
#This sets up the https connection
c = HTTPSConnection("658fa002trial.it-cpitrial.cfapps.us10.hana.ondemand.com")
#we need to base 64 encode it
#and then decode it to acsii as python 3 stores it as a byte string
#username = sys.argv[1]
#password = sys.argv[2]
userAndPass = base64.b64encode(b"$(username):$(password)").decode("ascii")
#userAndPass = base64.b64encode(bytes(username + ':' + password, "utf-8")).decode("ascii")
headers = {'Authorization': 'Basic %s' % userAndPass, 'X-CSRF-Token': 'Fetch'}
#then connect
c.request('GET', '/api/v1/MessageProcessingLogs', headers=headers)
#get the response back
res = c.getresponse()
res.read()
xsrftoken = res.getheader("X-CSRF-Token")
print("token fetch status:" + str(res.getcode()))
myHeaders = {}
myCookie = res.getheader("Set-Cookie")
#print(res.getheaders())
if myCookie is not None:
myCookie = myCookie.split(";")[0]
myHeaders = {
'Authorization': 'Basic %s' % userAndPass,
'X-CSRF-Token': xsrftoken,
"Content-Type": "application/json",
"Cookie": myCookie
"consider escaping characters on your password in case you have login problems..."
)
#This sets up the https connection
c = HTTPSConnection("658fa002trial.it-cpitrial.cfapps.us10.hana.ondemand.com")
#we need to base 64 encode it
#and then decode it to acsii as python 3 stores it as a byte string
userAndPass = base64.b64encode(bytes(username + ':' + password,
"utf-8")).decode("ascii")
myHeaders = {
'Authorization': 'Basic %s' % userAndPass,
'X-CSRF-Token': 'Fetch'
}
#Get all iflow ids of a package
path = "/api/v1/IntegrationPackages('AzureExamples')/IntegrationDesigntimeArtifacts?$format=json"
c.request('GET', path, headers=myHeaders)
res = c.getresponse()
out = json.loads(res.read())["d"]["results"]
for iflow in out:
print("download " + iflow["Id"])
individualPath = iflow["__metadata"]["media_src"].split(":443")[1]
iFlowName = iflow["Id"]
c.request('GET', individualPath, headers=myHeaders)
res = c.getresponse()
#unzip
localPath = Path().resolve().parent / ("src/main/groovy") / (iFlowName)
# Check whether the specified path is an existing file
isDir = os.path.isdir(localPath)
"jql": "filter=AWO-CN1-Sprint-Task",
"startAt": 0,
"maxResults" : 500,
"fields": [
"key",
"customfield_12866",
"customfield_10242",
"subtasks",
"aggregatetimeoriginalestimate",
"aggregateprogress",
"customfield_12551"
]
}
'''
c.request('POST', '/rest/api/2/search', headers=headers, body=body)
#get the response back
print(headers)
res = c.getresponse()
# at this point you could check the status etc
# this gets the page text
data = res.read()
d=json.loads(data)
for issue_raw in d["issues"]:
print(issue_raw["key"])
# objects = ijson.items(data, 'issues.fields.item')
#
# column=list(objects)
def threads():
c = HTTPSConnection("engine.freerice.com")
#we need to base 64 encode it
#and then decode it to acsii as python 3 stores it as abyte string#POST https://engine.freerice.com/games/8166e015-f435-4ce8-b1c7-48d2cfd0759b/answer HTTP/1.1
question_id = '3f361880-805d-55ee-98b4-cb3a28ca2028'
answer = '10'
first = True
resource = '/games/dbb11f54-6d72-43f9-b628-6a061aad4922/answer'
number = 0
while True:
if first:
body = '{"answer":"a' + answer + '","question":"' + question_id + '","user":"******"}'
#then connect
#resource = '/games/33343f63-3db9-4d58-8d44-6560aee481b9/answer'
else:
body = '{"category":"66f2a9aa-bac2-5919-997d-2d17825c1837","level":1}'
#resource = '/games/33343f63-3db9-4d58-8d44-6560aee481b9/answer'
headers = {'Host': 'engine.freerice.com',\
'Connection': 'keep-alive',\
'Content-Length': str(len(body)),\
'Accept': 'application/json',\
'Origin': 'https://beta.freerice.com',\
'Authorization': 'Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE1NjE3NDQyOTEsImV4cCI6MTU2NDMzNjI5MSwidXVpZCI6IjYxYjkzN2NiLWVkNzYtNDBhMy1hNzliLTkxZTU2MTkxNDE0MiJ9.q0NRXE58uwFzgr_O5PBSIqQ3QMFVYuyop11tph9sjMM',\
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36',\
'Content-Type': 'application/json',\
#'Referer: https':'beta.freerice.com',\
'Accept-Encoding': 'gzip, deflate, br',\
'Accept-Language': 'en-US,en;q=0.9',}
try:
c.request('PATCH', resource, body=body, headers=headers)
except:
c = HTTPSConnection("engine.freerice.com")
continue
#get the response back
res = c.getresponse()
# at this point you could check the status etc
# this gets the page text
data = res.read()
print(type(data))
x = dict(json.loads(data))
try:
question_id = x["data"]["attributes"]["question_id"]
print(question_id)
question = x["data"]["attributes"]["question"]["text"]
question = question.replace("x", "*")
answer = str(eval(question))
print(question + " = " + answer)
print("Done with problem " + str(number))
first = True
number += 1
except KeyError:
first = False
print('\n')
print(x)
messagebox.showerror()
break
if int(number) > 30000:
raise Exception()
def open(readonly):
# Parse out the username from the output_conn URL.
parsed = urlparse(params['output_conn'])
username = parsed.username or "admin@internal"
# Read the password from file.
with builtins.open(params['output_password'], 'r') as fp:
password = fp.read()
password = password.rstrip()
# Connect to the server.
connection = sdk.Connection(
url=params['output_conn'],
username=username,
password=password,
ca_file=params['rhv_cafile'],
log=logging.getLogger(),
insecure=params['insecure'],
)
system_service = connection.system_service()
# Create the disk.
disks_service = system_service.disks_service()
if params['disk_format'] == "raw":
disk_format = types.DiskFormat.RAW
else:
disk_format = types.DiskFormat.COW
disk = disks_service.add(disk=types.Disk(
name=params['disk_name'],
description="Uploaded by virt-v2v",
format=disk_format,
initial_size=params['disk_size'],
provisioned_size=params['disk_size'],
# XXX Ignores params['output_sparse'].
# Handling this properly will be complex, see:
# https://www.redhat.com/archives/libguestfs/2018-March/msg00177.html
sparse=True,
storage_domains=[types.StorageDomain(name=params['output_storage'], )],
))
# Wait till the disk is up, as the transfer can't start if the
# disk is locked:
disk_service = disks_service.disk_service(disk.id)
debug("disk.id = %r" % disk.id)
endt = time.time() + timeout
while True:
time.sleep(5)
disk = disk_service.get()
if disk.status == types.DiskStatus.OK:
break
if time.time() > endt:
raise RuntimeError("timed out waiting for disk to become unlocked")
# Get a reference to the transfer service.
transfers_service = system_service.image_transfers_service()
# Create a new image transfer, using the local host is possible.
host = find_host(connection) if params['rhv_direct'] else None
transfer = transfers_service.add(
types.ImageTransfer(
disk=types.Disk(id=disk.id),
host=host,
inactivity_timeout=3600,
))
debug("transfer.id = %r" % transfer.id)
# Get a reference to the created transfer service.
transfer_service = transfers_service.image_transfer_service(transfer.id)
# After adding a new transfer for the disk, the transfer's status
# will be INITIALIZING. Wait until the init phase is over. The
# actual transfer can start when its status is "Transferring".
endt = time.time() + timeout
while True:
time.sleep(5)
transfer = transfer_service.get()
if transfer.phase != types.ImageTransferPhase.INITIALIZING:
break
if time.time() > endt:
raise RuntimeError("timed out waiting for transfer status " +
"!= INITIALIZING")
# Now we have permission to start the transfer.
if params['rhv_direct']:
if transfer.transfer_url is None:
raise RuntimeError("direct upload to host not supported, " +
"requires ovirt-engine >= 4.2 and only works " +
"when virt-v2v is run within the oVirt/RHV " +
"environment, eg. on an oVirt node.")
destination_url = urlparse(transfer.transfer_url)
else:
destination_url = urlparse(transfer.proxy_url)
context = ssl.create_default_context()
context.load_verify_locations(cafile=params['rhv_cafile'])
http = HTTPSConnection(destination_url.hostname,
destination_url.port,
context=context)
# The first request is to fetch the features of the server.
# Authentication was needed only for GET and PUT requests when
# communicating with old imageio-proxy.
needs_auth = not params['rhv_direct']
can_flush = False
can_trim = False
can_zero = False
unix_socket = None
http.request("OPTIONS", destination_url.path)
r = http.getresponse()
data = r.read()
if r.status == 200:
# New imageio never needs authentication.
needs_auth = False
j = json.loads(data)
can_flush = "flush" in j['features']
can_trim = "trim" in j['features']
can_zero = "zero" in j['features']
unix_socket = j.get('unix_socket')
# Old imageio servers returned either 405 Method Not Allowed or
# 204 No Content (with an empty body). If we see that we leave
# all the features as False and they will be emulated.
elif r.status == 405 or r.status == 204:
pass
else:
raise RuntimeError("could not use OPTIONS request: %d: %s" %
(r.status, r.reason))
debug("imageio features: flush=%r trim=%r zero=%r unix_socket=%r" %
(can_flush, can_trim, can_zero, unix_socket))
# If we are connected to imageio on the local host and the
# transfer features a unix_socket then we can reconnect to that.
if host is not None and unix_socket is not None:
try:
http = UnixHTTPConnection(unix_socket)
except Exception as e:
# Very unlikely failure, but we can recover by using the https
# connection.
debug("cannot create unix socket connection, using https: %s" % e)
else:
debug("optimizing connection using unix socket %r" % unix_socket)
# Save everything we need to make requests in the handle.
return {
'can_flush': can_flush,
'can_trim': can_trim,
'can_zero': can_zero,
'connection': connection,
'disk': disk,
'disk_service': disk_service,
'failed': False,
'highestwrite': 0,
'http': http,
'needs_auth': needs_auth,
'path': destination_url.path,
'transfer': transfer,
'transfer_service': transfer_service,
}
from http.client import HTTPSConnection
from base64 import b64encode
print("Starting module")
#This sets up the https connection
c = HTTPSConnection("jive.northgatearinso.com")
#we need to base 64 encode it
#and then decode it to acsii as python 3 stores it as a byte string
userAndPass = b64encode(b"joseenriquep:dppizza1983%.").decode("ascii")
headers = {'Authorization': 'Basic %s' % userAndPass}
#then connect
c.request('GET', '/', headers=headers)
#get the response back
res = c.getresponse()
# at this point you could check the status etc
# this gets the page text
data = res.read()
print("Printing data")
print(data)
print("Status code")
print(res.status)
print("Header")
print(res.getheaders())
def replicate_manifest_list(
image: ImageName,
endpoint: str,
*,
auth_header_dest: Dict[str, str] = None,
auth_header_src: Dict[str, str] = None,
ssl_context_dest: SSLContext = None,
ssl_context_src: SSLContext = None,
):
"""
Helper function as docker-py cannot operate on manifest lists.
Args:
image: The name of the docker image to be replicated.
endpoint: Endpoint of the docker registry into which to replicate the image.
auth_header_dest: HTTP basic authentication header to using when connecting to the service.
auth_header_src: HTTP basic authentication header to using when connecting to the service.
ssl_context_dest:
SSL context referencing the trusted root CA certificated to used when negotiating the TLS connection.
ssl_context_src:
SSL context referencing the trusted root CA certificated to used when negotiating the TLS connection.
"""
media_type = "application/vnd.docker.distribution.manifest.list.v2+json"
# Note: This cannot be imported above, as it causes a circular import!
from . import __version__ # pylint: disable=import-outside-toplevel
user_agent = f"pytest-docker-registry-fixtures/{__version__}"
https_connection = HTTPSConnection(context=ssl_context_src,
host=image.endpoint)
identifier = image.digest if image.digest else image.tag # Prefer digest
https_connection.request(
"GET",
url=f"/v2/{image.image}/manifests/{identifier}",
headers={
"Accept": media_type,
"User-Agent": user_agent,
**auth_header_src
},
)
response = https_connection.getresponse()
assert response.status == 200
assert response.headers["Content-Type"] == media_type
if image.digest:
assert response.headers["Docker-Content-Digest"] == image.digest
manifest = response.read()
https_connection = HTTPSConnection(context=ssl_context_dest, host=endpoint)
identifier = image.tag if image.tag else image.digest # Prefer tag
https_connection.request(
"PUT",
url=f"/v2/{image.image}/manifests/{identifier}",
headers={
"Content-Type": media_type,
"User-Agent": user_agent,
**auth_header_dest,
},
body=manifest,
)
assert https_connection.getresponse().status == 201
def get_raw_data():
apikey = get_apikey()
c = HTTPSConnection('clocked.io')
c.request('GET', '/time', headers={'apikey': apikey})
return c.getresponse().read().decode('utf8')
class RequestHelper:
"""
Encapsulates the recurring logic for sending out requests to the
Moodle-System.
"""
def __init__(self,
moodle_domain: str,
moodle_path: str = '/',
token: str = '',
skip_verify_cert=False):
"""
Opens a connection to the Moodle system
"""
if skip_verify_cert:
context = ssl._create_unverified_context()
else:
context = ssl._create_default_https_context()
self.connection = HTTPSConnection(moodle_domain, context=context)
self.token = token
self.moodle_domain = moodle_domain
self.moodle_path = moodle_path
RequestHelper.stdHeader = {
# 'Cookie': 'cookie1=' + cookie1,
'User-Agent':
'Mozilla/5.0 (X11; Linux x86_64)' +
' AppleWebKit/537.36 (KHTML, like Gecko)' +
' Chrome/78.0.3904.108 Safari/537.36',
'Content-Type':
'application/x-www-form-urlencoded'
# copied straight out of Chrome
}
def post_REST(self, function: str, data: {str: str} = None) -> object:
"""
Sends a POST request to the REST endpoint of the Moodle system
@param function: The Web service function to be called.
@param data: The optional data is added to the POST body.
@return: The Json response returned by the Moodle system, already
checked for errors.
"""
if (self.token is None):
raise ValueError('The required Token is not set!')
data_urlencoded = self._get_POST_DATA(function, self.token, data)
url = self._get_REST_POST_URL(self.moodle_path, function)
# uncomment this print to debug requested post-urls
# print(url)
# uncomment this print to debug posted data
# print(data_urlencoded)
self.connection.request('POST',
url,
body=data_urlencoded,
headers=self.stdHeader)
response = self.connection.getresponse()
return self._initial_parse(response)
@staticmethod
def _get_REST_POST_URL(moodle_path: str, function: str) -> str:
"""
Generates an url for a REST-POST request
@params: The necessary parameters for a REST URL
@return: A formatted url
"""
url = (('%swebservice/rest/server.php?moodlewsrestformat=json&' %
(moodle_path)) + ('wsfunction=%s' % (function)))
return url
@staticmethod
def _get_POST_DATA(function: str, token: str, data_obj: str) -> str:
"""
Generates the data for a REST-POST request
@params: The necessary parameters for a REST URL
@return: A url-encoded data string
"""
data = {
'moodlewssettingfilter': 'true',
'moodlewssettingfileurl': 'true'
}
if data_obj is not None:
data.update(data_obj)
data.update({'wsfunction': function, 'wstoken': token})
return urllib.parse.urlencode(data)
def get_login(self, data: {str: str}) -> object:
"""
Sends a POST request to the login endpoint of the Moodle system to
obtain a token in Json format.
@param data: The data is inserted into the Post-Body as arguments. This
should contain the logon data.
@return: The json response returned by the Moodle System, already
checked for errors.
"""
self.connection.request('POST',
'%slogin/token.php' % (self.moodle_path),
body=urllib.parse.urlencode(data),
headers=self.stdHeader)
response = self.connection.getresponse()
return self._initial_parse(response)
def _initial_parse(self, response) -> object:
"""
The first time parsing the result of a REST request.
It is checked for known errors.
@param response: The json response of the moodle system
@return: The paresed json object
"""
# Normaly Moodle answer with response 200
if (response.getcode() != 200):
raise RuntimeError(
'An Unexpected Error happened on side of the Moodle System!' +
(' Status-Code: %s' % str(response.getcode())) +
('\nHeader: %s' % (response.getheaders())) +
('\nResponse: %s' % (response.read())))
# Try to parse the json
try:
response_extracted = json.loads(response.read())
except ValueError as error:
raise RuntimeError('An Unexpected Error occurred while trying' +
' to parse the json response! Moodle' +
' response: %s.\nError: %s' %
(response.read(), error))
# Check for known erorrs
if ("error" in response_extracted):
error = response_extracted.get("error", "")
errorcode = response_extracted.get("errorcode", "")
stacktrace = response_extracted.get("stacktrace", "")
debuginfo = response_extracted.get("debuginfo", "")
reproductionlink = response_extracted.get("reproductionlink", "")
raise RequestRejectedError(
'The Moodle System rejected the Request.' +
(' Details: %s (Errorcode: %s, ' % (error, errorcode)) +
('Stacktrace: %s, Debuginfo: %s, Reproductionlink: %s)' %
(stacktrace, debuginfo, reproductionlink)))
if ("exception" in response_extracted):
exception = response_extracted.get("exception", "")
errorcode = response_extracted.get("errorcode", "")
message = response_extracted.get("message", "")
raise RequestRejectedError(
'The Moodle System rejected the Request.' +
' Details: %s (Errorcode: %s, Message: %s)' %
(exception, errorcode, message))
return response_extracted
def request(self, method, url, body=None, headers={}):
self.request_length = 0
if self.has_proxy:
self.set_tunnel(self.request_host, 443)
headers.setdefault("Host", self.request_host)
HTTPSConnection.request(self, method, url, body, headers)
import json
import base64
import datetime
import uuid
import copy
from http.client import HTTPSConnection, HTTPConnection
device_id = "2c5b7596-cc75-4a2e-b42d-a75a64c85028"
device_token = "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0.oRIgJ4aprPbFCGjnsSfA_9NnD1yDE2LLmXJeh53ZsPAsyMuy2N8J_tnbF_-MIU-VbNpI0An1yAngZf-KDWAxLIB_ZD-8Ss0w.vw62TETlUhZXhOxIlopb9A.RNAbQan-56XuBewGobuI-7qImsThE9RkhnHWBvaO5uPALK_sruzIAitApcx-FfC4gUVjx21ju6A5ubGk41Bjzg.Fn7F4o3ulos0z41pVMCEBzO6FIqQm-kv3HXF5N7t87o"
headers = {'Content-Type': 'application/json', 'Device-Token': device_token}
c = HTTPSConnection("api.iowt.robotika.co.uk")
c.request('POST',
'/check/status',
json.dumps({"device_id": device_id}),
headers=headers)
res = c.getresponse()
data = res.read().decode('utf-8')
print(str(res.status) + " -- " + data)
def api(self, req):
c = HTTPSConnection(self.URL)
c.request('GET', req, headers=self.headers)
return c.getresponse().read().decode('utf-8', errors='ignore')
class ssl_worker(pp_thread):
global pp_config
session_timeout = int(pp_config['thread_ssl_timeout'])
def __init__(self, key_val, manager, info = '', delay = 0):
pp_thread.__init__(self, info)
self.lock_close = Lock()
self.flag_closed= False
self.info = info
self.delay = delay
self.manager = manager
self.event_proc = Event()
self.arg = None
self.handler = None
self.host_ip = key_val['host_ip']
self.host_name = key_val['host_name']
self.group = key_val['group']
self.timeout = key_val['timeout'] if 'timeout' in key_val else None
def close(self):
if self.handler != None:
try:
self.handler.close()
except:
print_exc()
finally:
self.handler = None
def main(self):
if self.delay != 0 : sleep(self.delay)
while True:
self.handler = HTTPSConnection(self.host_ip, timeout = self.timeout)
self.handler._http_vsn = 10
self.handler._http_vsn_str = 'HTTP/1.0'
try:
self.handler.connect()
except TimeoutError:
self.close()
continue
except:
print_exc()
continue
break
self.manager.feedback('connected', self.group, self)
ev = self.event_proc.wait(self.session_timeout)
self.lock_close.acquire()
self.flag_closed = True
self.lock_close.release()
if self.flag_stop == True:
self.close()
return
if ev != True :
self.manager.feedback('timeout', self.group, self)
if self.arg == None:
self.close()
return
self.do_proc(self.arg)
def put(self, arg):
self.lock_close.acquire()
if self.flag_closed != True:
self.arg = arg
self.lock_close.release()
else:
self.lock_close.release()
return False
self.event_proc.set()
return True
def do_proc(self, arg): pass
def pyget(self, req, headers = {}):
try:
self.handler.request('GET', req, headers = headers)
except:
self.close()
self.manager.feedback('err_write', self.group, self)
print_exc()
return None
try:
ack = self.handler.getresponse()
body = ack.read()
except:
self.close()
self.manager.feedback('err_read', self.group, self)
print_exc()
return None
#--------------------------------------------------------
self.close()
self.manager.feedback('done', self.group, self)
key_val = {}
key_val['body'] = body
key_val['head'] = str(ack.msg)
key_val['status'] = ack.status
return key_val
def get_access_token(self) -> str:
conn = HTTPSConnection(self.auth_url)
conn.request("POST", "/api/token", self.auth_params, self.auth_headers)
response = conn.getresponse()
return json.loads(response.read().decode("utf-8"))["access_token"]
def _new_conn(self):
# Performs the NTLM handshake that secures the connection. The socket
# must be kept open while requests are performed.
self.num_connections += 1
log.debug('Starting NTLM HTTPS connection no. %d: https://%s%s',
self.num_connections, self.host, self.authurl)
headers = {}
headers['Connection'] = 'Keep-Alive'
req_header = 'Authorization'
resp_header = 'www-authenticate'
conn = HTTPSConnection(host=self.host, port=self.port)
# Send negotiation message
headers[req_header] = (
'NTLM %s' % ntlm.create_NTLM_NEGOTIATE_MESSAGE(self.rawuser))
log.debug('Request headers: %s', headers)
conn.request('GET', self.authurl, None, headers)
res = conn.getresponse()
reshdr = dict(res.getheaders())
log.debug('Response status: %s %s', res.status, res.reason)
log.debug('Response headers: %s', reshdr)
log.debug('Response data: %s [...]', res.read(100))
# Remove the reference to the socket, so that it can not be closed by
# the response object (we want to keep the socket open)
res.fp = None
# Server should respond with a challenge message
auth_header_values = reshdr[resp_header].split(', ')
auth_header_value = None
for s in auth_header_values:
if s[:5] == 'NTLM ':
auth_header_value = s[5:]
if auth_header_value is None:
raise Exception('Unexpected %s response header: %s' %
(resp_header, reshdr[resp_header]))
# Send authentication message
ServerChallenge, NegotiateFlags = \
ntlm.parse_NTLM_CHALLENGE_MESSAGE(auth_header_value)
auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE(ServerChallenge,
self.user,
self.domain,
self.pw,
NegotiateFlags)
headers[req_header] = 'NTLM %s' % auth_msg
log.debug('Request headers: %s', headers)
conn.request('GET', self.authurl, None, headers)
res = conn.getresponse()
log.debug('Response status: %s %s', res.status, res.reason)
log.debug('Response headers: %s', dict(res.getheaders()))
log.debug('Response data: %s [...]', res.read()[:100])
if res.status != 200:
if res.status == 401:
raise Exception('Server rejected request: wrong '
'username or password')
raise Exception('Wrong server response: %s %s' %
(res.status, res.reason))
res.fp = None
log.debug('Connection established')
return conn
class Client:
""" Responsable for requests to Blitz RESTful API """
def __init__(self, user, api_key, host=None, port=None, connect=True):
self.username = user
self.api_key = api_key
self.host = 'www.blitz.io' if host is None else host
self.port = 443 if port is None else port
self.private_key = None
if connect:
self.connect()
def connect(self):
""" Connects the client. """
self.connection = HTTPSConnection(self.host, self.port)
def get_headers(self):
""" Returns the headers need for a auccessful request to blitz.io. """
private = self.private_key
headers = {
"Content-type": "application/json",
'X-API-User': self.username,
'X-API-Key': self.api_key if private is None else private,
'X-API-Client' : 'python'
}
return headers
def set_private_key(self, key):
""" Sets the user private key to be used in the request header. """
self.private_key = key
def execute(self, post_data):
""" Sends a queue request to blitz.io RESTful API. """
path = "/api/1/curl/execute"
data = json.dumps(post_data)
self.connection.request("POST", path, data, self.get_headers())
response = self.connection.getresponse()
response_string = response.read().decode('UTF-8')
return json.loads(response_string)
def login(self):
""" Login to blitz.io RESTful API. """
path = "/login/api"
self.connection.request("GET", path, None, self.get_headers())
response = self.connection.getresponse()
response_string = response.read().decode('UTF-8')
return json.loads(response_string)
def job_status(self, job_id):
""" Sends a job status request to blitz.io RESTful API. """
path = "/api/1/jobs/{}/status".format(job_id)
self.connection.request("GET", path, None, self.get_headers())
response = self.connection.getresponse()
response_string = response.read().decode('UTF-8')
return json.loads(response_string)
def abort_job(self, job_id):
""" Send a abort request to blitz.io RESTful API. """
path = "/api/1/jobs/{}/abort".format(job_id)
self.connection.request("PUT", path, '', self.get_headers())
response = self.connection.getresponse()
response_string = response.read().decode('UTF-8')
return json.loads(response_string)
def close(self):
""" Closes the connection. """
self.connection.close()
def parse(self, post_data):
""" Sends a parse request to blitz.io RESTful API. """
path = "/api/1/parse"
data = json.dumps(post_data)
self.connection.request("POST", path, data, self.get_headers())
response = self.connection.getresponse()
response_string = response.read().decode('UTF-8')
return json.loads(response_string)
def to_voice(self,outputFile,gender=None,backend=zAI_BACKEND):
'''
Perform Text-to-speech to synthesize audio.
While we don't have a proper zAudio class, result is saved to disk as audio file.
Parameters:
-----------
outputFile: path to save output audio file
gender: desired gender of the voice used to generate audio. When set to None, any avalaible gender is used.
If a gender is specified, an error will be thrown if no voice with thta gender is available for the corresponding backend and locale combination.
backend: desired backend (Google | Microsot | local)
Returns:
--------
saves a 16kHz 16bit mono PCM wav file to desired location
'''
if self.lang == None:
raise Exception("Your zText object has no 'lang' defined. Please, set the 'lang' property or perform automatic language detection using 'detect_language()'")
if gender is not None:
gender = gender.lower()
if gender != 'female' and gender != 'male':
raise Exception("Gender must be either 'female' or 'male', to force a gender, or None to use any available voice gender")
# Check that the keys for the selected backend are available
if backend == 'Microsoft':
if MICROSOFT_AZURE_BING_VOICE_API_KEY == '':
print('MICROSOFT_AZURE_BING_VOICE_API_KEY is empty. Using local backend.')
backend = 'local'
if backend=='Google':
raise NotImplementedError("tanslate method is currently not available with Google backend")
elif backend == 'Microsoft':
if self.lang not in AZURE_TTS_DATA:
raise ValueError('Conversion to speech is not supported for this backend and language: %s' % ISO639_1_CODES[self.lang])
inputData = AZURE_TTS_DATA[self.lang]
if gender == None:
if 'females' not in inputData:
inputData = inputData['female']
else:
inputData = inputData['male']
else:
if gender not in inputData:
raise ValueError('This combination of backend and language does not support a %s voice' % gender)
inputData = inputData[gender]
params = ""
headers = {"Ocp-Apim-Subscription-Key": MICROSOFT_AZURE_BING_VOICE_API_KEY}
AccessTokenHost = "api.cognitive.microsoft.com"
path = "/sts/v1.0/issueToken"
conn = HTTPSConnection(AccessTokenHost)
conn.request("POST", path, params, headers)
response = conn.getresponse()
data = response.read()
conn.close()
accesstoken = data.decode("UTF-8")
body = ElementTree.Element('speak', version='1.0')
body.set('{http://www.w3.org/XML/1998/namespace}lang', inputData['locale'].lower())
voice = ElementTree.SubElement(body, 'voice')
voice.set('{http://www.w3.org/XML/1998/namespace}lang', inputData['locale'])
voice.set('{http://www.w3.org/XML/1998/namespace}gender', inputData['gender'])
voice.set('name', inputData['name'])
voice.text = self.text
headers = {"Content-type": "application/ssml+xml",
"X-Microsoft-OutputFormat": "riff-16khz-16bit-mono-pcm",
"Authorization": "Bearer " + accesstoken,
"User-Agent": "zAI"}
conn = HTTPSConnection("speech.platform.bing.com")
conn.request("POST", "/synthesize", ElementTree.tostring(body), headers)
response = conn.getresponse()
data = response.read()
conn.close()
if response.status == 200:
with open(outputFile, "wb") as wavfile:
wavfile.write(bytes(data))
else:
raise Exception('Request failed: %s' % response.reason)
elif backend == 'local':
raise NotImplementedError("tanslate method is currently not available with local backend")
else:
raise ValueError('invalid backend selection. Valid values are currently "Google", "Microsoft" or "local".')
username = os.environ["HAW_USER"]
password = os.environ["HAW_PASSWORD"]
userpass_string = username + ":" + password
userpass_string = userpass_string.encode()
# Crawl the Container Harbor to get the current containers.
# Only works, when there is just one set of PNS containers.
c = HTTPSConnection("pnskss.informatik.haw-hamburg.de",
context=ssl._create_unverified_context())
userAndPass = b64encode(userpass_string).decode("ascii")
headers = {
'Authorization': 'Basic %s' % userAndPass,
'Accept': 'application/json'
}
c.request('GET', '/containers', headers=headers)
res = c.getresponse()
data = res.read()
json_data = json.loads(data)
template_file = open('inventory.template', 'r')
src = Template(template_file.read())
# Save the information in a dict to generate the inventory template for ansible
result_dict = {}
for container in json_data['containers']:
service_networks = container['details']['NetworkSettings']['Networks']
service = container['details']['Config']['Labels'][
'com.docker.compose.service']
def checkEWS(host, port, mode, domain, user, data):
ews_url = "/EWS/Exchange.asmx"
if port == 443:
try:
uv_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
session = HTTPSConnection(host, port, context=uv_context)
except AttributeError:
session = HTTPSConnection(host, port)
else:
session = HTTPConnection(host, port)
# Use impacket for NTLM
ntlm_nego = ntlm.getNTLMSSPType1(host, domain)
#Negotiate auth
negotiate = base64.b64encode(ntlm_nego.getData())
# Headers
headers = {
"Authorization":
'NTLM %s' % negotiate.decode('utf-8'),
"Content-type":
"text/xml; charset=utf-8",
"Accept":
"text/xml",
"User-Agent":
"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36"
}
session.request("POST", ews_url, POST_BODY, headers)
res = session.getresponse()
res.read()
if res.status != 401:
print(
'Status code returned: %d. Authentication does not seem required for URL'
% (res.status))
return False
try:
if 'NTLM' not in res.getheader('WWW-Authenticate'):
print('NTLM Auth not offered by URL, offered protocols: %s' %
(res.getheader('WWW-Authenticate')))
return False
except (KeyError, TypeError):
print('No authentication requested by the server for url %s' %
(ews_url))
return False
print('[*] Got 401, performing NTLM authentication')
# Get negotiate data
try:
ntlm_challenge_b64 = re.search(
'NTLM ([a-zA-Z0-9+/]+={0,2})',
res.getheader('WWW-Authenticate')).group(1)
ntlm_challenge = base64.b64decode(ntlm_challenge_b64)
except (IndexError, KeyError, AttributeError):
print('No NTLM challenge returned from server')
return False
if mode == 'plaintext':
password1 = data
nt_hash = ''
elif mode == 'ntlmhash':
password1 = ''
nt_hash = binascii.unhexlify(data)
else:
print('[!]Wrong parameter')
return False
lm_hash = ''
ntlm_auth, _ = ntlm.getNTLMSSPType3(ntlm_nego, ntlm_challenge, user,
password1, domain, lm_hash, nt_hash)
auth = base64.b64encode(ntlm_auth.getData())
headers = {
"Authorization":
'NTLM %s' % auth.decode('utf-8'),
"Content-type":
"text/xml; charset=utf-8",
"Accept":
"text/xml",
"User-Agent":
"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36"
}
session.request("POST", ews_url, POST_BODY, headers)
res = session.getresponse()
body = res.read()
if res.status == 401:
print('[!] Server returned HTTP status 401 - authentication failed')
return False
else:
print('[+] Valid:%s %s' % (user, data))
#print(body)
return True
def request(self, method, url, body=None, headers={}):
self.request_length = 0
HTTPSConnection.request(self, method, url, body, headers)
from base64 import b64encode
from http.client import HTTPSConnection
#This sets up the https connection
c = HTTPSConnection("jira.aspiraconnect.com")
#we need to base 64 encode it
#and then decode it to acsii as python 3 stores it as a byte string
userAndPass = b64encode(b"gzhang:Pinwen@18").decode("ascii")
headers = {
'Authorization': 'Basic %s' % userAndPass,
'Content-Type': 'application/json'
}
#then connect
c.request('GET',
'/rest/api/2/user/assignable/search?project=AWO&maxResults=1000',
headers=headers)
#get the response back
res = c.getresponse().read()
# at this point you could check the status etc
# this gets the page text
data = json.loads(res)
# for issue_raw in data:
# print(issue_raw["key"],issue_raw["emailAddress"],issue_raw["displayName"],issue_raw["active"])
def user_dict():
users = {}
}
}
}
headers = {
'Accept': 'application/json',
'Connection': 'Keep-Alive',
'Authorization': 'none',
'Content-Type': 'application/json',
'User-Agent': _USER_AGENT,
'Host': user_server,
'Accept-Encoding': 'gzip'
}
logging.debug('POST /users/sign_in.json, body=%r, headers=%r' %
(json.dumps(query), headers))
conn.request('POST',
'/users/sign_in.json',
body=json.dumps(query),
headers=headers)
resp = conn.getresponse()
if resp.status != 200:
logging.error('Failed to login to Hisense server:\nStatus %d: %r',
resp.status, resp.reason)
sys.exit(1)
resp_data = resp.read()
try:
resp_data = gzip.decompress(resp_data)
except OSError:
pass # Not gzipped.
try:
tokens = json.loads(resp_data)
except UnicodeDecodeError:
logging.exception(
class urlopen(object):
"""HTTP(S) urlopen that handles compressed connections
Errors that respond with bencoded data can be read
Raises IOError on other errors
"""
conntypes = {'http': HTTPConnection, 'https': HTTPSConnection}
def __init__(self, url):
self.tries = 0
self.error_return = None
self.connection = None
self.url = None
self._open(url.strip())
def _setconn(self, url):
scheme, host, path, params, query, _ = urllib.parse.urlparse(url)
if scheme not in self.conntypes:
raise IOError(('url error', 'unknown url type', scheme, url))
if self.connection is not None and not (
isinstance(self.connection, self.conntypes[scheme])
and host == self.connection.host):
try:
self.connection.close()
except socket.error:
pass
self.connection = None
if self.connection is None:
if scheme == 'http':
self.connection = HTTPConnection(host, timeout=30)
else:
self.connection = HTTPSConnection(host,
timeout=30,
context=SSLCONTEXT)
# a[:len(b)] == (a if b else '')
self.url = path + ';'[:len(params)] + params + '?'[:len(query)] + query
def _open(self, url):
try:
self._setconn(url)
except HTTPException as e:
raise IOError(('http error', str(e)))
for _ in range(MAX_REDIRECTS):
try:
self.connection.request('GET', self.url, None, {
'User-Agent': VERSION,
'Accept-Encoding': 'gzip'
})
self.response = self.connection.getresponse()
if self.response.status == 200: # Success
return
if self.response.status in (301, 302): # Redirect
self._setconn(self.response.getheader('Location'))
continue
except HTTPException as e:
raise IOError(('http error', str(e)))
# Handle bencoded errors
try:
data = self._read()
d = bdecode(data)
if 'failure reason' in d:
self.error_return = data
return
except (IOError, ValueError):
pass
# General HTTP error
raise IOError(
('http error', self.response.status, self.response.reason))
else:
raise IOError(('http error', 500,
"Internal Server Error: Redirect Recursion"))
def read(self):
"""Read response"""
if self.error_return:
return self.error_return
return self._read()
def _read(self):
data = self.response.read()
if self.response.getheader('Content-Encoding', '').find('gzip') >= 0:
try:
data = gzip.GzipFile(fileobj=io.BytesIO(data)).read()
except IOError:
raise IOError(('http error', 'got corrupt response'))
return data
def close(self):
"""Close connection
Always succeeds"""
if self.connection is not None:
try:
self.connection.close()
except socket.error:
pass
def __enter__(self):
return self
def __exit__(self, _type, _value, _traceback):
self.close()
def _test_connection_to_URL(self, url_str):
"""
Internal function that tests the connection to a URL via a simple
HTTP/1.1 HEAD request. If a test connection cannot be established,
raises an exception with a helpful diagnostic message (e.g. the
HTTP Response status code & reason).
:param url_str: full string for the URL to test a connection to
:type url_str: str
:return: the value of the HTTP Response 'Content-Type' header,
or None if no successful test connection was made
"""
content_type_header = None
try:
url = urlparse(url_str)
test_conn = None
if url.scheme == 'https':
test_conn = HTTPSConnection(url.netloc)
elif url.scheme == 'http':
test_conn = HTTPConnection(url.netloc)
else:
raise RuntimeError(" Error: Cannot connect to URL '{}'\n" \
" Unsupported network protocol scheme " \
"'{}' specified\n" \
" Supported schemes: http | https".format(
url_str, url.scheme))
test_conn.request('HEAD', url.path)
response = test_conn.getresponse()
content_type_header = response.getheader('Content-Type')
if response.status != OK: # i.e. "HTTP/1.1 200 OK"
raise RuntimeError(" Error: Cannot connect to URL '{}'\n" \
" HTTP Response status code & reason: " \
"{} {}".format(url_str, response.status,
response.reason))
except ValueError as ve: # Raised by urlparse(...)
raise RuntimeError(" Error: Cannot connect to URL '{}'\n" \
" URL string may be invalid.".format(url_str))
except HTTPException as he: # Raised by HTTPSConnection(...)
# or HTTPConnection(...)
raise RuntimeError(" Error: Cannot connect to URL '{}'\n" \
" HTTPException: {}\n" \
" url.scheme : '{}'\n" \
" url.netloc : '{}'\n" \
" url.path : '{}'\n".format(
url_str, str(he),
url.scheme, url.netloc, url.path))
except OSError as oe: # Catches any low-level socket errors
# raised by test_conn.request(...)
# -> _socket (socketmodule.c)
raise RuntimeError(" Error: Cannot connect to URL '{}'\n" \
" Socket Error: {}: {}\n" \
" url.scheme : '{}'\n" \
" url.netloc : '{}'\n" \
" url.path : '{}'\n".format(
url_str, type(oe).__name__, str(oe),
url.scheme, url.netloc, url.path))
finally:
if isinstance(test_conn, HTTPConnection):
test_conn.close()
return content_type_header
class Robot(_Robot):
def __init__(self,
fci_ip,
dynamic_rel=1.0,
user=None,
password=None,
repeat_on_error=True,
stop_at_python_signal=True):
super().__init__(fci_ip,
dynamic_rel=dynamic_rel,
repeat_on_error=repeat_on_error,
stop_at_python_signal=stop_at_python_signal)
self.hostname = fci_ip
self.user = user
self.password = password
self.client = None
self.token = None
@staticmethod
def _encode_password(user, password):
bs = ','.join([
str(b)
for b in hashlib.sha256((password + '#' + user +
'@franka').encode('utf-8')).digest()
])
return base64.encodebytes(bs.encode('utf-8')).decode('utf-8')
def __enter__(self):
self.client = HTTPSConnection(
self.hostname,
timeout=12,
context=ssl._create_unverified_context()) # [s]
self.client.connect()
self.client.request('POST',
'/admin/api/login',
body=json.dumps({
'login':
self.user,
'password':
self._encode_password(self.user, self.password)
}),
headers={'content-type': 'application/json'})
self.token = self.client.getresponse().read().decode('utf8')
return self
def __exit__(self, type, value, traceback):
self.client.close()
def start_task(self, task):
self.client.request('POST',
'/desk/api/execution',
body=f'id={task}',
headers={
'content-type':
'application/x-www-form-urlencoded',
'Cookie': f'authorization={self.token}'
})
return self.client.getresponse().read()
def unlock_brakes(self):
self.client.request('POST',
'/desk/api/robot/open-brakes',
headers={
'content-type':
'application/x-www-form-urlencoded',
'Cookie': f'authorization={self.token}'
})
return self.client.getresponse().read()
def lock_brakes(self):
self.client.request('POST',
'/desk/api/robot/close-brakes',
headers={
'content-type':
'application/x-www-form-urlencoded',
'Cookie': f'authorization={self.token}'
})
return self.client.getresponse().read()
def move_async(self, *args) -> Thread:
p = Thread(target=self.move, args=tuple(args), daemon=True)
p.start()
sleep(0.001) # Sleep one control cycle
return p
def get_gripper(self):
return _Gripper(self.fci_ip)
class XMLManager(object):
def __init__(self, cls, db_name, db_user, db_passwd, db_host, db_port,
db_table, ddl_dir, enable_ssl):
self.cls = cls
if not db_name:
db_name = cls.__name__.lower()
self.db_name = db_name
self.db_user = db_user
self.db_passwd = db_passwd
self.db_host = db_host
self.db_port = db_port
self.db_table = db_table
self.ddl_dir = ddl_dir
self.s3 = None
self.converter = XMLConverter(self)
self.impl = getDOMImplementation()
self.doc = self.impl.createDocument(None, 'objects', None)
self.connection = None
self.enable_ssl = enable_ssl
self.auth_header = None
if self.db_user:
import base64
base64string = base64.encodestring(
'%s:%s' % (self.db_user, self.db_passwd))[:-1]
authheader = "Basic %s" % base64string
self.auth_header = authheader
def _connect(self):
if self.db_host:
if self.enable_ssl:
from http.client import HTTPSConnection as Connection
else:
from http.client import HTTPConnection as Connection
self.connection = Connection(self.db_host, self.db_port)
def _make_request(self, method, url, post_data=None, body=None):
"""
Make a request on this connection
"""
if not self.connection:
self._connect()
try:
self.connection.close()
except:
pass
self.connection.connect()
headers = {}
if self.auth_header:
headers["Authorization"] = self.auth_header
self.connection.request(method, url, body, headers)
resp = self.connection.getresponse()
return resp
def new_doc(self):
return self.impl.createDocument(None, 'objects', None)
def _object_lister(self, cls, doc):
for obj_node in doc.getElementsByTagName('object'):
if not cls:
class_name = obj_node.getAttribute('class')
cls = find_class(class_name)
id = obj_node.getAttribute('id')
obj = cls(id)
for prop_node in obj_node.getElementsByTagName('property'):
prop_name = prop_node.getAttribute('name')
prop = obj.find_property(prop_name)
if prop:
if hasattr(prop, 'item_type'):
value = self.get_list(prop_node, prop.item_type)
else:
value = self.decode_value(prop, prop_node)
value = prop.make_value_from_datastore(value)
setattr(obj, prop.name, value)
yield obj
def reset(self):
self._connect()
def get_doc(self):
return self.doc
def encode_value(self, prop, value):
return self.converter.encode_prop(prop, value)
def decode_value(self, prop, value):
return self.converter.decode_prop(prop, value)
def get_s3_connection(self):
if not self.s3:
self.s3 = boto.connect_s3(self.aws_access_key_id,
self.aws_secret_access_key)
return self.s3
def get_list(self, prop_node, item_type):
values = []
try:
items_node = prop_node.getElementsByTagName('items')[0]
except:
return []
for item_node in items_node.getElementsByTagName('item'):
value = self.converter.decode(item_type, item_node)
values.append(value)
return values
def get_object_from_doc(self, cls, id, doc):
obj_node = doc.getElementsByTagName('object')[0]
if not cls:
class_name = obj_node.getAttribute('class')
cls = find_class(class_name)
if not id:
id = obj_node.getAttribute('id')
obj = cls(id)
for prop_node in obj_node.getElementsByTagName('property'):
prop_name = prop_node.getAttribute('name')
prop = obj.find_property(prop_name)
value = self.decode_value(prop, prop_node)
value = prop.make_value_from_datastore(value)
if value != None:
try:
setattr(obj, prop.name, value)
except:
pass
return obj
def get_props_from_doc(self, cls, id, doc):
"""
Pull out the properties from this document
Returns the class, the properties in a hash, and the id if provided as a tuple
:return: (cls, props, id)
"""
obj_node = doc.getElementsByTagName('object')[0]
if not cls:
class_name = obj_node.getAttribute('class')
cls = find_class(class_name)
if not id:
id = obj_node.getAttribute('id')
props = {}
for prop_node in obj_node.getElementsByTagName('property'):
prop_name = prop_node.getAttribute('name')
prop = cls.find_property(prop_name)
value = self.decode_value(prop, prop_node)
value = prop.make_value_from_datastore(value)
if value != None:
props[prop.name] = value
return (cls, props, id)
def get_object(self, cls, id):
if not self.connection:
self._connect()
if not self.connection:
raise NotImplementedError(
"Can't query without a database connection")
url = "/%s/%s" % (self.db_name, id)
resp = self._make_request('GET', url)
if resp.status == 200:
doc = parse(resp)
else:
raise Exception("Error: %s" % resp.status)
return self.get_object_from_doc(cls, id, doc)
def query(self, cls, filters, limit=None, order_by=None):
if not self.connection:
self._connect()
if not self.connection:
raise NotImplementedError(
"Can't query without a database connection")
from urllib.parse import urlencode
query = str(self._build_query(cls, filters, limit, order_by))
if query:
url = "/%s?%s" % (self.db_name, urlencode({"query": query}))
else:
url = "/%s" % self.db_name
resp = self._make_request('GET', url)
if resp.status == 200:
doc = parse(resp)
else:
raise Exception("Error: %s" % resp.status)
return self._object_lister(cls, doc)
def _build_query(self, cls, filters, limit, order_by):
import types
if len(filters) > 4:
raise Exception('Too many filters, max is 4')
parts = []
properties = cls.properties(hidden=False)
for filter, value in filters:
name, op = filter.strip().split()
found = False
for property in properties:
if property.name == name:
found = True
if types.TypeType(value) == list:
filter_parts = []
for val in value:
val = self.encode_value(property, val)
filter_parts.append("'%s' %s '%s'" %
(name, op, val))
parts.append("[%s]" % " OR ".join(filter_parts))
else:
value = self.encode_value(property, value)
parts.append("['%s' %s '%s']" % (name, op, value))
if not found:
raise Exception('%s is not a valid field' % name)
if order_by:
if order_by.startswith("-"):
key = order_by[1:]
type = "desc"
else:
key = order_by
type = "asc"
parts.append("['%s' starts-with ''] sort '%s' %s" %
(key, key, type))
return ' intersection '.join(parts)
def query_gql(self, query_string, *args, **kwds):
raise NotImplementedError("GQL queries not supported in XML")
def save_list(self, doc, items, prop_node):
items_node = doc.createElement('items')
prop_node.appendChild(items_node)
for item in items:
item_node = doc.createElement('item')
items_node.appendChild(item_node)
if isinstance(item, Node):
item_node.appendChild(item)
else:
text_node = doc.createTextNode(item)
item_node.appendChild(text_node)
def save_object(self, obj, expected_value=None):
"""
Marshal the object and do a PUT
"""
doc = self.marshal_object(obj)
if obj.id:
url = "/%s/%s" % (self.db_name, obj.id)
else:
url = "/%s" % (self.db_name)
resp = self._make_request("PUT", url, body=doc.toxml())
new_obj = self.get_object_from_doc(obj.__class__, None, parse(resp))
obj.id = new_obj.id
for prop in obj.properties():
try:
propname = prop.name
except AttributeError:
propname = None
if propname:
value = getattr(new_obj, prop.name)
if value:
setattr(obj, prop.name, value)
return obj
def marshal_object(self, obj, doc=None):
if not doc:
doc = self.new_doc()
if not doc:
doc = self.doc
obj_node = doc.createElement('object')
if obj.id:
obj_node.setAttribute('id', obj.id)
obj_node.setAttribute(
'class',
'%s.%s' % (obj.__class__.__module__, obj.__class__.__name__))
root = doc.documentElement
root.appendChild(obj_node)
for property in obj.properties(hidden=False):
prop_node = doc.createElement('property')
prop_node.setAttribute('name', property.name)
prop_node.setAttribute('type', property.type_name)
value = property.get_value_for_datastore(obj)
if value is not None:
value = self.encode_value(property, value)
if isinstance(value, list):
self.save_list(doc, value, prop_node)
elif isinstance(value, Node):
prop_node.appendChild(value)
else:
text_node = doc.createTextNode(
str(value).encode("ascii", "ignore"))
prop_node.appendChild(text_node)
obj_node.appendChild(prop_node)
return doc
def unmarshal_object(self, fp, cls=None, id=None):
if isinstance(fp, str) or isinstance(fp, str):
doc = parseString(fp)
else:
doc = parse(fp)
return self.get_object_from_doc(cls, id, doc)
def unmarshal_props(self, fp, cls=None, id=None):
"""
Same as unmarshalling an object, except it returns
from "get_props_from_doc"
"""
if isinstance(fp, str) or isinstance(fp, str):
doc = parseString(fp)
else:
doc = parse(fp)
return self.get_props_from_doc(cls, id, doc)
def delete_object(self, obj):
url = "/%s/%s" % (self.db_name, obj.id)
return self._make_request("DELETE", url)
def set_key_value(self, obj, name, value):
self.domain.put_attributes(obj.id, {name: value}, replace=True)
def delete_key_value(self, obj, name):
self.domain.delete_attributes(obj.id, name)
def get_key_value(self, obj, name):
a = self.domain.get_attributes(obj.id, name)
if name in a:
return a[name]
else:
return None
def get_raw_item(self, obj):
return self.domain.get_item(obj.id)
def set_property(self, prop, obj, name, value):
pass
def get_property(self, prop, obj, name):
pass
def load_object(self, obj):
if not obj._loaded:
obj = obj.get_by_id(obj.id)
obj._loaded = True
return obj
def payment_status(request):
# Read notification parameters
pos_id = request.POST["pos_id"]
session_id = request.POST["session_id"]
ts = request.POST["ts"]
sig = request.POST["sig"]
logger.info(
"Payment status - pos_id: %s, session_id: %s, ts: %s, sig: %s" %
(pos_id, session_id, ts, sig))
check_sig(sig, (pos_id, session_id, ts))
# Determine the status of transaction based on the notification
c = HTTPSConnection("secure.payu.com")
timestamp = str(int(time.time()))
c.request(
"POST",
"/paygw/UTF/Payment/get/txt/",
urlencode((
("pos_id", pos_id),
("session_id", session_id),
("ts", timestamp),
("sig", make_sig((pos_id, session_id, timestamp))),
)),
{
"Content-type": "application/x-www-form-urlencoded",
"Accept": "text/plain",
},
)
raw_response = codecs.decode(c.getresponse().read(), "utf-8")
r = {}
for i in [
i.split(":", 1) for i in raw_response.split("\n")
if i.strip() != ""
]:
r[i[0]] = i[1].strip()
check_sig(
r["trans_sig"],
(
r["trans_pos_id"],
r["trans_session_id"],
r["trans_order_id"],
r["trans_status"],
r["trans_amount"],
r["trans_desc"],
r["trans_ts"],
),
)
amount = math.floor(int(r["trans_amount"]) / 100)
# Update the corresponding payment
# TODO: use update_or_create in Django 1.7
p, created = Payment.objects.select_for_update().get_or_create(
session_id=r["trans_session_id"],
defaults={
"order_id": r["trans_order_id"],
"amount": amount,
"description": r["trans_desc"],
},
)
if p.amount != amount:
logger.error(
"Payment amount doesn't match",
extra={
"pay_type": p.pay_type,
"status": p.status,
"payment_response": r,
"expected_amount": p.amount,
"request": request,
},
)
return HttpResponse("Bad amount", status=400)
p.pay_type = r["trans_pay_type"]
p.status = r["trans_status"]
if r["trans_recv"] != "":
p.realized = r["trans_recv"]
p.save()
logger.info(
"Payment status: pay_type: %s, status: %s, payment response: %s" %
(p.pay_type, p.status, r))
# Return positive error code as per PayU protocol
return HttpResponse("OK")
class GraphAPI(object):
"""A client for the Facebook Graph API.
See http://developers.facebook.com/docs/api for complete
documentation for the API.
The Graph API is made up of the objects in Facebook (e.g., people,
pages, events, photos) and the connections between them (e.g.,
friends, photo tags, and event RSVPs). This client provides access
to those primitive types in a generic way. For example, given an
OAuth access token, this will fetch the profile of the active user
and the list of the user's friends:
graph = facebook.GraphAPI(access_token)
user = graph.get_object("me")
friends = graph.get_connections(user["id"], "friends")
You can see a list of all of the objects and connections supported
by the API at http://developers.facebook.com/docs/reference/api/.
You can obtain an access token via OAuth or by using the Facebook
JavaScript SDK. See
http://developers.facebook.com/docs/authentication/ for details.
If you are using the JavaScript SDK, you can use the
get_user_from_cookie() method below to get the OAuth access token
for the active user from the cookie saved by the SDK.
"""
def __init__(self, access_token=None, timeout=None):
self.access_token = access_token
self.timeout = timeout
try:
self.conn = HTTPSConnection('graph.facebook.com',
timeout=self.timeout)
except TypeError:
# Timeout support for Python <2.6
if self.timeout:
socket.setdefaulttimeout(self.timeout)
self.conn = HTTPSConnection('graph.facebook.com')
def __del__(self):
self.conn.close()
def get_object(self, id, **args):
"""Fetchs the given object from the graph."""
return self.request(id, args)
def get_objects(self, ids, **args):
"""Fetchs all of the given object from the graph.
We return a map from ID to object. If any of the IDs are
invalid, we raise an exception.
"""
args["ids"] = ",".join(ids)
return self.request("", args)
def get_connections(self, id, connection_name, **args):
"""Fetchs the connections for given object."""
return self.request(id + "/" + connection_name, args)
def put_object(self, parent_object, connection_name, **data):
"""Writes the given object to the graph, connected to the given parent.
For example,
graph.put_object("me", "feed", message="Hello, world")
writes "Hello, world" to the active user's wall. Likewise, this
will comment on a the first post of the active user's feed:
feed = graph.get_connections("me", "feed")
post = feed["data"][0]
graph.put_object(post["id"], "comments", message="First!")
See http://developers.facebook.com/docs/api#publishing for all
of the supported writeable objects.
Certain write operations require extended permissions. For
example, publishing to a user's feed requires the
"publish_actions" permission. See
http://developers.facebook.com/docs/publishing/ for details
about publishing permissions.
"""
assert self.access_token, "Write operations require an access token"
return self.request(parent_object + "/" + connection_name,
post_args=data)
def put_wall_post(self, message, attachment={}, profile_id="me"):
"""Writes a wall post to the given profile's wall.
We default to writing to the authenticated user's wall if no
profile_id is specified.
attachment adds a structured attachment to the status message
being posted to the Wall. It should be a dictionary of the form:
{"name": "Link name"
"link": "http://www.example.com/",
"caption": "{*actor*} posted a new review",
"description": "This is a longer description of the attachment",
"picture": "http://www.example.com/thumbnail.jpg"}
"""
return self.put_object(profile_id,
"feed",
message=message,
**attachment)
def put_comment(self, object_id, message):
"""Writes the given comment on the given post."""
return self.put_object(object_id, "comments", message=message)
def put_like(self, object_id):
"""Likes the given post."""
return self.put_object(object_id, "likes")
def delete_object(self, id):
"""Deletes the object with the given ID from the graph."""
self.request(id, post_args={"method": "delete"})
def delete_request(self, user_id, request_id):
"""Deletes the Request with the given ID for the given user."""
conn = HTTPSConnection('graph.facebook.com')
url = '/%s_%s?%s' % (
request_id,
user_id,
urlencode({'access_token': self.access_token}),
)
conn.request('DELETE', url)
response = conn.getresponse()
data = response.read()
response = _parse_json(data)
# Raise an error if we got one, but don't not if Facebook just
# gave us a Bool value
if (response and isinstance(response, dict) and response.get("error")):
raise GraphAPIError(response)
conn.close()
def put_photo(self, image, message=None, album_id=None, **kwargs):
"""Uploads an image using multipart/form-data.
image=File like object for the image
message=Caption for your image
album_id=None posts to /me/photos which uses or creates and uses
an album for your application.
"""
object_id = album_id or "me"
#it would have been nice to reuse self.request;
#but multipart is messy in urllib
post_args = {
'access_token': self.access_token,
'source': image,
'message': message,
}
post_args.update(kwargs)
content_type, body = self._encode_multipart_form(post_args)
req = Request(("https://graph.facebook.com/%s/photos" % object_id),
data=body)
req.add_header('Content-Type', content_type)
try:
data = urlopen(req).read()
#For Python 3 use this:
#except HTTPError as e:
except HTTPError as e:
data = e.read() # Facebook sends OAuth errors as 400, and urllib2
# throws an exception, we want a GraphAPIError
try:
response = _parse_json(data)
# Raise an error if we got one, but don't not if Facebook just
# gave us a Bool value
if (response and isinstance(response, dict)
and response.get("error")):
raise GraphAPIError(response)
except ValueError:
response = data
return response
# based on: http://code.activestate.com/recipes/146306/
def _encode_multipart_form(self, fields):
"""Encode files as 'multipart/form-data'.
Fields are a dict of form name-> value. For files, value should
be a file object. Other file-like objects might work and a fake
name will be chosen.
Returns (content_type, body) ready for httplib.HTTP instance.
"""
BOUNDARY = '----------ThIs_Is_tHe_bouNdaRY_$'
CRLF = '\r\n'
L = []
for (key, value) in fields.items():
logging.debug("Encoding %s, (%s)%s" % (key, type(value), value))
if not value:
continue
L.append('--' + BOUNDARY)
if hasattr(value, 'read') and callable(value.read):
filename = getattr(value, 'name', '%s.jpg' % key)
L.append(('Content-Disposition: form-data;'
'name="%s";'
'filename="%s"') % (key, filename))
L.append('Content-Type: image/jpeg')
value = value.read()
logging.debug(type(value))
else:
L.append('Content-Disposition: form-data; name="%s"' % key)
L.append('')
if isinstance(value, unicode):
logging.debug("Convert to ascii")
value = value.encode('ascii')
L.append(value)
L.append('--' + BOUNDARY + '--')
L.append('')
body = CRLF.join(L)
content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
return content_type, body
def request(self, path, args=None, post_args=None):
"""Fetches the given path in the Graph API.
We translate args to a valid query string. If post_args is
given, we send a POST request to the given path with the given
arguments.
"""
args = args or {}
if self.access_token:
if post_args is not None:
post_args["access_token"] = self.access_token
else:
args["access_token"] = self.access_token
post_data = None if post_args is None else urlencode(post_args)
try:
self.conn.request('GET', "/" + path + "?" + urlencode(args),
post_data)
file = self.conn.getresponse()
except HTTPError as e:
response = _parse_json(e.read())
raise GraphAPIError(response)
charsetStr = "charset="
mimetype = file.getheader('content-type')
if "text" in mimetype:
encoding = mimetype[mimetype.find(charsetStr) + len(charsetStr):]
response = _parse_json(file.read().decode(encoding))
elif "image" in mimetype:
response = {
"data": file.read(),
"mime-type": mimetype,
"url": file.getheader('location'),
}
else:
raise GraphAPIError('Maintype was not text or image')
if response and isinstance(response, dict) and response.get("error"):
raise GraphAPIError(response["error"]["type"],
response["error"]["message"])
return response
def fql(self, query, args=None, post_args=None):
"""FQL query.
Example query: "SELECT affiliations FROM user WHERE uid = me()"
"""
args = args or {}
if self.access_token:
if post_args is not None:
post_args["access_token"] = self.access_token
else:
args["access_token"] = self.access_token
post_data = None if post_args is None else urlencode(post_args)
"""Check if query is a dict and
use the multiquery method
else use single query
"""
if not isinstance(query, basestring):
args["queries"] = query
fql_method = 'fql.multiquery'
else:
args["query"] = query
fql_method = 'fql.query'
args["format"] = "json"
try:
file = urlopen("https://api.facebook.com/method/" + fql_method +
"?" + urlencode(args),
post_data,
timeout=self.timeout)
except TypeError:
# Timeout support for Python <2.6
if self.timeout:
socket.setdefaulttimeout(self.timeout)
file = urlopen(
"https://api.facebook.com/method/" + fql_method + "?" +
urlencode(args), post_data)
try:
content = file.read()
response = _parse_json(content)
#Return a list if success, return a dictionary if failed
if type(response) is dict and "error_code" in response:
raise GraphAPIError(response)
except Exception as e:
raise e
finally:
file.close()
return response
def extend_access_token(self, app_id, app_secret):
"""
Extends the expiration time of a valid OAuth access token. See
<https://developers.facebook.com/roadmap/offline-access-removal/
#extend_token>
"""
args = {
"client_id": app_id,
"client_secret": app_secret,
"grant_type": "fb_exchange_token",
"fb_exchange_token": self.access_token,
}
response = urllib.urlopen("https://graph.facebook.com/oauth/"
"access_token?" + urlencode(args)).read()
query_str = parse_qs(response)
if "access_token" in query_str:
result = {"access_token": query_str["access_token"][0]}
if "expires" in query_str:
result["expires"] = query_str["expires"][0]
return result
else:
response = json.loads(response)
raise GraphAPIError(response)
