def main(fail_on_major, fail_on_minor, fail_on_patch):
# Set logging
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
# Load images from compose file specified
images = load_compose(compose_file)
# Loop to check image by image
for image in images:
logging.info("Checking if {} is the latest version...".format(image))
# Parse out image information
org, repo, version = parse_image(image)
# Generate token to authenticate call to registry
token = authenticate(registry_username, registry_password, org, repo,
registry_auth_domain, registry_auth_service,
registry_api_domain)
# Get the full list of versions from the tag list
versions = get_tags(org, repo, registry_api_domain, token)
# Parse the versions and see if a newer one exists
parse_versions(version, versions, fail_on_major, fail_on_minor,
fail_on_patch)
def main():
reddit_object = authenticate()
configured_processor = functools.partial(reply_function,
api_input=api(),
reddit_object_input=reddit_object)
# map reply to list of comments, and use your partials to simplify your parameters.
list(
map(lambda x: configured_processor(comment_id_input=x),
list_creator(reddit_object)))
def wrap_f(self, *args, **kwargs):
auth_header = self.request.headers.get('Authorization', None)
auth_user = None
if((auth_header != None) and (auth_header.startswith('Basic'))):
(user, passwd) = base64.decodestring(auth_header[6:]).split(':', 2)
auth_user = self.USER = authenticator.authenticate(user, passwd)
if(auth_user == None):
self.set_header('WWW-Authenticate', 'Basic realm=rabbitornado')
self.set_header('Location', '/')
self.set_status(401)
self.write('Login needed')
self.finish()
return False
return f(self, *args, **kwargs)
def sign_in():
error = False
if 'token' in session:
return redirect(url_for('overview'))
if request.method == 'POST':
# we got some request, let's see if we can authenticate that user
username = request.form['username']
password = request.form['password']
if authenticator.authenticate(username, password):
return redirect(url_for('overview'))
else:
error = True
return render_template('sign_in.html', error=error)
from Common import * from log import * from new_Common import * import time from authenticator import authenticate import functools import new_scripture_bot import functools api_key = new_scripture_bot.api() print(api_key) reddit_object = authenticate() print(reddit_object) comment_list = new_scripture_bot.list_creator(reddit_object) print(comment_list)
import praw
import authenticator
from authenticator import authenticate
'''
def authenticate():
reddit_instance = praw.Reddit(client_id='FUlMD-cKILpnUA',
client_secret='bkZH3og2C2x8_IpqDD-mFCTOseA',
password='******',
user_agent='scripture_bot',
username='******')
return reddit_instance
'''
scripture_bot_object = authenticate()
print(scripture_bot_object.user.me())
print('the reddit bot object is ' + str(scripture_bot_object))
'''
unread_messages = scripture_bot.unread_generator(scripture_bot_object)
print('the unread message object is '+str(unread_messages))
'''
unread = scripture_bot_object.inbox.unread(limit=None)
for i in unread:
print(i.body)
for i in scripture_bot_object.inbox.unread(limit=None):
print(i.body)
print(i.author)
print(i.fullname)
'''
#Graham Wood #This file contains most of the functions for tweeting #tweets, though it can only really be used as an extention of main #Not sure if this is needed, considering these functions will only #be called from main, but here it is anyway import tweepy import authenticator import time api = authenticator.authenticate() #takes in a string and tweets it immediately def tweetInput (string): api.update_status(string) #takes in a string and a number of seconds, will wait that long and then tweet def timedTweet (string, seconds): time.sleep(seconds) tweetInput(string)
import tweepy
import authenticator as auth
import json
import time
from os.path import join
api = tweepy.API(auth.authenticate(),
wait_on_rate_limit=True,
wait_on_rate_limit_notify=True)
cursor = tweepy.Cursor(api.search,
q='Star Trek',
rpp=50,
lang='en',
result_typr='recent',
include_entities=True).items()
jsonDir = 'tngTweets'
def now():
return int(round(time.time()))
def checkRls():
"""Checks rate_limit_status of Twitter Search API and returns its value."""
return api.rate_limit_status(
)['resources']['search']['/search/tweets']['remaining']
def writeTweets(cursor):
# tweets = [tweet._json for tweet in cursor].sort(key=lambda x: x["id"])
count = 1
def on_close(ws):
logger.info(f'{ws} connection closed.')
def on_open(ws):
logger.info(f'{ws} connection opened.')
def on_error(ws, error):
logger.info(error)
def on_message(ws, message):
logger.info(message)
# Define pair.
pair = 'ETHUSD'
# Define filter.
filtering = ''
usefilter = True
if usefilter: filtering = 'trades=true'
# Construct payload.
request = resourcelocator.sockgenuine + '/v1/marketdata/' + pair + '?' + filtering
nonce = int(time.time() * 1000)
payload = {'request': request, 'nonce': nonce}
authenticate(payload)
# Establish websocket connection.
ws = websocket.WebSocketApp(request, on_message=on_message)
ws.run_forever(sslopt={'cert_reqs': ssl.CERT_NONE})
def authenticate():
global file_write_data
# URL that the information is stored at
reg_data_url = "http://pastebin.com/raw.php?i=PER0wCBM"
try:
# Request the URL, and retrieve the info on that page, in this case it is raw text, save it as reg_data.xml
urllib.request.urlretrieve(reg_data_url, REG_FILE_DIR)
reg_file_exits = True
except HTTPError:
authenticator.contact_error()
reg_file_exits = False
except URLError:
authenticator.contact_error()
reg_file_exits = False
if reg_file_exits:
# Get the authenticator to authenticate the entered reg key
authenticator.authenticate()
# Pre-define the index array (list) variable that will store data for the user
match_data = [None, None, None, None, None]
# If it returns False, remove the reg_data.xml file, then return False to the place in which it was run.
if authenticator.get_match_data() is False:
if reg_file_exits:
remove(REG_FILE_DIR)
return False
# If get_match_data returns anything else, it should be user information
else:
# Extract the data from match_data_received from a tuple to a list, as it should be formatted
match_data[0], match_data[1], match_data[2], match_data[3], match_data[
4] = authenticator.get_match_data()
# In index 4, the code for a logo should be stored, set logo_code to that URL
logo_code = str(match_data[4])
try:
# Request and retrieve the logo from the url and store it as logo.png
urllib.request.urlretrieve(str(LOGO_BASE_URL + logo_code + ".png"),
LOGO_FILE_DIR)
except HTTPError:
authenticator.contact_error()
except URLError:
authenticator.contact_error()
# Request a string to be encoded as an MD5 (Hex Digest), store it in encoded_result
encode_string_general.EncodeString(
match_data[3] + registry.get_reg_value(registry.HKEY_CURRENT_USER,
REG_DIR, "reg_key"))
encoded_result = str(
encode_string_general.get_encoded_string_variable())
# Set the file_write_data to a format of the data that has been retrieved, excluding the image url
file_write_data = format(
"%s\n"
"%s\n"
"%s" % (encoded_result, match_data[1], match_data[2]))
if reg_file_exits:
# Remove the reg_info.xml file as there is no longer any need for it
remove(REG_FILE_DIR)
# Return true to the place in which this function was called (marking this as a successful validation)
return True
