def __init__(self, url, configuration=Configuration(), debug=False):
# Set debugging settings
if debug:
self.debug = debug
# Find site settings
supported_sites = configuration.get_supported_sites().items()
_, settings = (
(
(site, settings)
for (site, settings) in supported_sites
if site in url
).__next__())
# Attempt to retrieve page
try:
page = requests.get(
url, headers={"User-Agent": UserAgent().random})
except:
raise HTTPStatusException(page.status_code)
else:
print("Retrieved [%s](%s) Length: %d" %
(settings["site"], url, len(page.text)))
# Get domain name
parsed_uri = urlparse(url)
self.domain = '{uri.scheme}://{uri.netloc}'.format(uri=parsed_uri)
# Save url
self.url = url
# Process article
page_soup = BeautifulSoup(page.text, "html.parser")
article_soup = page_soup.select_one(settings["content_selector"])
if article_soup is None:
return
# Convert all URLs to static global URLs
article_soup = self.replace_url(article_soup)
# Modify specified selectors
article_html = self.modify_selectors(
article_soup, settings["modifications"])
# Replace local regex
article_html = self.replace_local(
article_html, settings["replacements"])
self.article_html = article_html
# Replace html with markdown
article_text = self.replace_markdown(article_html)
# Replace global regex
article_text = self.replace_global(article_text)
# Save article text to object-scope variable
self.article_text = article_text
if debug:
print(article_html)
def user_ballance_changes():
# TODO check if an ammount can be substracted
"""
:type notification_data: NotificationUrl
:rtype: str
"""
print("received notification2")
print(request.data[19:-1])
data = json.loads(request.data[19:-1])
# print(d)
# transaction = json.loads(request.data[19:-1])
# print(transaction.object_.Payment.amount.value)
amount = decimal.Decimal(data['object']['Payment']['amount']['value'])
print(amount)
receiver = data['object']['Payment']['counterparty_alias']['iban']
print(receiver)
if amount < 0 and receiver \
not in charities:
donation = (5 + ((amount * 100) % 5)) / 100
print(donation)
if donation > 0 and donation < 0.05:
configuration_json = configurationRepository.read()
configuration = Configuration.build_from_json(configuration_json)
payment = bunqLib.make_payment(
str(donation), 'Donation',
charities_name[configuration.active_charity])
print(json.dumps(dict(payment.headers)))
donationsRepository.create(
Donation(value=float(donation), charity=receiver))
return ""
def on_state_changed(self):
sbm_normalised = self.sbm_check_box.isChecked()
background_method = self.background_button_group.checkedButton().method
excluded_spots = self.calculate_current_excluded_spots()
self.current_config = Configuration(sbm_normalised, background_method,
excluded_spots)
self.state_changed.emit()
def process_samples(self):
self.clear_previous_calculations()
samples = list(self.samples_by_name.values())
equilibrium_standards = self.view.ask_user_for_equilibrium_standards(
samples, [])
if equilibrium_standards is None:
return
for sample in samples:
if sample in equilibrium_standards:
sample.is_standard = True
# age_standard_info = self.view.ask_user_for_age_standard(samples, equilibrium_standards)
# if age_standard_info is None:
# return
# self.manual_whole_rock_values(samples)
self.view.ask_user_for_WR_activity_ratios(samples)
self.standardise_all_sbm_and_calculate_time_series(samples)
default_config = Configuration(
normalise_by_sbm=True,
background_method=BackgroundCorrection.EXP,
excluded_spots=frozenset())
self.view.show_user_results(samples, default_config,
self.ensure_config_calculated, self.data,
self.export_results)
def initialize(self):
try:
with open(self.fileName, 'r') as json_file:
json_array = json.load(json_file)
configurations = []
for item in json_array:
url = item['url']
user = User(item['user']['username'],
item['user']['password'])
testCase = item['test_case']
configuration = Configuration(url)
configuration.user = user
configuration.testCase = testCase
configurations.append(configuration)
return configurations
except FileNotFoundError:
print(
f'ConfigurationManager - Error: file {self.fileName} is not found!'
)
def check_phrase_donation():
donations = donationsRepository.read()
donations_total = calculate_donations_total(donations)
print(donations_total)
configuration_json = configurationRepository.read()
configuration = Configuration.build_from_json(configuration_json)
if (((decimal.Decimal(donations_total) -
decimal.Decimal(configuration.last_donation_value)) * 100) % 2) > 0:
phrases = phraseRepository.read()
charity_phrases = [phrase for phrase in phrases \
if Phrase.build_from_json(phrase).charity == configuration.active_charity]
print(dumps(charity_phrases))
configuration.last_donation_value = donations_total
print(configuration.last_donation_value)
configurationRepository.update(configuration)
return dumps(random.choice(charity_phrases))
else:
return '0'
def update_configuration():
if request.is_json:
try:
json_data = request.get_data()
active_charity = json_data['active_charity']
configuration_json = configurationRepository.read()
configuration = Configuration.build_from_json(configuration_json)
if configuration is None:
configuration = Configuration(last_donation_value=0.0,
active_charity=active_charity)
configurationRepository.create(configuration)
else:
configuration.active_charity = active_charity
configurationRepository.update(configuration)
except KeyError as e:
raise Exception("Key not found in json_data: {}".format(e.message))
configuration = Configuration.build_from_json(
configurationRepository.read())
return dumps(configuration.get_as_json())
dblogger = logging.getLogger('orator.connection.queries')
dblogger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'It took %(elapsed_time)sms to execute the query %(query)s'
)
dbhandler = logging.StreamHandler()
dbhandler.setFormatter(formatter)
dblogger.addHandler(handler)
logger.info('Starting up Catebot...')
configuration = Configuration.find(1)
catechism = pickle.load(open(configuration.catechismFilename, 'rb'))
logger.info('Catechism successfully loaded!')
baltimore = pickle.load(open(configuration.baltimoreFilename, 'rb'))
logger.info('Baltimore Catechism successfully loaded!')
canon = pickle.load(open(configuration.canonFilename, 'rb'))
logger.info('Canon successfully loaded!')
girm = pickle.load(open(configuration.girmFilename, 'rb'))
logger.info('GIRM successfully loaded!')
try:
r = praw.Reddit(
def __init__(self):
print("RNPB started in", "debug" if self.debug else "standard", "mode")
# Don't print stacktrace on ctrl-c
signal.signal(signal.SIGINT, lambda x, y: sys.exit(0))
self.configuration = Configuration()
self.reddit = Reddit(self.configuration)
class RedditNewsPostBot:
# Object variables
debug = True
reddit = None
configuration = None
active_threads = []
submission_queue = queue.Queue()
def __init__(self):
print("RNPB started in", "debug" if self.debug else "standard", "mode")
# Don't print stacktrace on ctrl-c
signal.signal(signal.SIGINT, lambda x, y: sys.exit(0))
self.configuration = Configuration()
self.reddit = Reddit(self.configuration)
def start(self):
queue_handler_thread = Thread(target=self.queue_handler)
queue_handler_thread.daemon = True
queue_handler_thread.start()
self.active_threads.append(queue_handler_thread)
self.reddit.stream_subreddit(
subreddit="singapore",
submission_queue=self.submission_queue,
supported_sites=self.configuration.get_supported_sites())
def reply_article(self, submission, article):
article_lines = article.split("\n")
article_parts = []
article_part = ""
i = 0
while i < len(article_lines):
article_part += "> " + article_lines[i] + "\n"
i += 1
if len(article_part) >= 5000:
article_parts.append(article_part)
article_part = ""
article_parts.append(article_part)
i = 0
parent = submission
for article_part in article_parts:
comment_part_header = ""
if len(article_parts) != 1:
comment_part_header = "Part [%d/%d]\n" % (i + 1,
len(article_parts))
reply_comment = self.configuration.get_comment_template().format(
comment_part_header, article_part, submission.shortlink)
print("Posting [%s]" % submission.id)
if self.debug:
print(reply_comment)
parent = self.reddit.post_reply(parent, reply_comment)
i += 1
def queue_handler(self):
while True:
submission = self.submission_queue.get()
article = None
print("Attempting [%s](%s)" % (submission.id, submission.url))
supported_sites = self.configuration.get_supported_sites().items()
site = ((site, settings) for (site, settings) in supported_sites
if site in submission.url).__next__()
if site:
article = Article(submission.url,
self.configuration,
debug=self.debug).get_article_text()
if article != "":
self.reply_article(submission, article)
else:
print("Empty [%s](%s)" % (submission.id, submission.url))
print("Sleeping for 5 seconds...")
time.sleep(5)
db = DatabaseManager(config)
Model.set_connection_resolver(db)
parser = argparse.ArgumentParser(description='Catebot configuration')
parser.add_argument('--version', help='Catebot software version', required=True)
parser.add_argument('--username', help='Reddit username', required=True)
parser.add_argument('--password', help='Reddit password', required=True)
parser.add_argument('--clientId', help='Reddit client ID', required=True)
parser.add_argument('--clientSecret', help='Reddit client secret', required=True)
parser.add_argument('--catechismFilename', help='CCC pickle file', required=True)
parser.add_argument('--baltimoreFilename', help='BCCD pickle file', required=True)
parser.add_argument('--canonFilename', help='CCL pickle file', required=True)
parser.add_argument('--girmFilename', help='GIRM pickle file', required=True)
args = vars(parser.parse_args())
configuration = Configuration.find(1)
if not configuration:
configuration = Configuration()
configuration.version = args['version']
configuration.username = args['username']
configuration.password = args['password']
configuration.clientId = args['clientId']
configuration.clientSecret = args['clientSecret']
configuration.catechismFilename = args['catechismFilename']
configuration.baltimoreFilename = args['baltimoreFilename']
configuration.canonFilename = args['canonFilename']
configuration.girmFilename = args['girmFilename']
configuration.save()