def send(msg):
if Config.TESTING:
logger = logging.getLogger("email")
for line in str(msg).splitlines():
logger.info(line)
else:
mail.send(msg)
async def document_parser(app, queue):
log = logging.getLogger('Document parser')
model = app['data'].get('model')
index = app['data'].get('index')
pool = app['db_pool']
if not model or not index:
log.error(
"Word2vec model or document index is not loaded. Aborting...")
else:
while True:
# wait for an item from the producer
item = await queue.get()
# process the item
log.info('Indexing sentence_id: {} ...'.format(item))
async with pool.acquire() as connection:
async with connection.transaction():
sql = "SELECT text from sentence WHERE id = $1;"
text = await connection.fetchval(sql, item)
word_embeddings = []
words = filter(lambda x: x not in config.IGNORED_WORDS,
nltk.word_tokenize(text))
for w in words:
if w in model:
word_embeddings.append(model[w])
if word_embeddings:
sentence_embedding = np.mean(word_embeddings, axis=0)
index.add_items(sentence_embedding, item)
async with connection.transaction():
sql = "UPDATE sentence SET indexed = true WHERE id = $1;"
await connection.execute(sql, item)
queue.task_done()
import xml.etree.ElementTree as ET
import requests
from models import XRate, peewee_datetime
from config import logging, LOGGER_CONFIG
log = logging.getLogger("CbrApi")
fh = logging.FileHandler(LOGGER_CONFIG["file"])
fh.setLevel(LOGGER_CONFIG["level"])
fh.setFormatter(LOGGER_CONFIG["formatter"])
log.addHandler(fh)
log.setLevel(LOGGER_CONFIG["level"])
def update_xrates(from_currency, to_currency):
log.info("Started update for: %s=>%s" % (from_currency, to_currency))
xrate = XRate.select().where(XRate.from_currency == from_currency,
XRate.to_currency == to_currency).first()
log.debug("rate before: %s", xrate)
xrate.rate = get_cbr_rate(from_currency)
xrate.updated = peewee_datetime.datetime.now()
xrate.save()
log.debug("rate after: %s", xrate)
log.info("Finished update for: %s=>%s" % (from_currency, to_currency))
def get_cbr_rate(from_currency):
response = requests.get(
import tensorflow as tf
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from config import config, logging
from tools import utils
from learner.feature_extractor import get_droid_feature, FeatureMapping, drebin
from learner.basic_DNN import BasicDNNModel, tester
from learner import model_scope_dict
from defender import defense_model_scope_dict
MODLE_TEMP = BasicDNNModel
models = model_scope_dict.values() + defense_model_scope_dict.values()
logger = logging.getLogger("learning.surrogate")
SUR_INFO = {
'dataset_dir':
os.path.join(config.get('DEFAULT', 'database_dir'),
config.get('DEFAULT', 'surrogate_dataset')),
'feature_type':
'drebin',
'feature_utility_rate':
1.,
'feature_mapping_type':
config.get('feature.drebin', 'feature_mp'),
'use_interdependent_features':
False,
'learning_algorithm':
'DNN'
import sys
from datetime import datetime
from timeit import default_timer
import shutil
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from learner.classification import *
from tools import utils
from learner.feature_extractor import get_droid_feature, FeatureMapping, DREBIN_FEAT_INFO, feature_type_scope_dict
from config import config, logging
logger = logging.getLogger("learning.basic_dnn")
INFO = {
'dataset_dir': config.get('dataset', 'dataset_root'),
'feature_type': list(feature_type_scope_dict.keys())[0], # 'drebin',
'feature_mapping_type': config.get('feature.drebin', 'feature_mp'),
'use_interdependent_features': False,
'learning_algorithm': 'DNN'
}
DNN_HP = {
'random_seed': 23456,
'hidden_units':
[160, 160], # DNN has two hidden layers with each having 160 neurons
'output_dim': 2, # malicious vs. benign
'n_epochs': 150,
import requests
from models import XRate, peewee_datetime
from config import logging, LOGGER_CONFIG
log = logging.getLogger("PrivatApi")
fh = logging.FileHandler(LOGGER_CONFIG["file"])
fh.setLevel(LOGGER_CONFIG["level"])
fh.setFormatter(LOGGER_CONFIG["formatter"])
log.addHandler(fh)
log.setLevel(LOGGER_CONFIG["level"])
def update_xrates(from_currency, to_currency):
log.info("Started update for: %s=>%s" % (from_currency, to_currency))
xrate = XRate.select().where(XRate.from_currency == from_currency,
XRate.to_currency == to_currency).first()
log.debug("rate before: %s", xrate)
xrate.rate = get_privat_rate(from_currency)
xrate.updated = peewee_datetime.datetime.now()
xrate.save()
log.debug("rate after: %s", xrate)
log.info("Finished update for: %s=>%s" % (from_currency, to_currency))
def get_privat_rate(from_currency):
response = requests.get(
"https://api.privatbank.ua/p24api/pubinfo?exchange&json&coursid=11")
def __init__(self, logger_name):
self.log = logging.getLogger("Api")
self.log.name = logger_name
from models import XRate, peewee_datetime
from config import logging, LOGGER_CONFIG
log = logging.getLogger("TestApi")
fh = logging.FileHandler(LOGGER_CONFIG["file"])
fh.setLevel(LOGGER_CONFIG["level"])
fh.setFormatter(LOGGER_CONFIG["formatter"])
log.addHandler(fh)
log.setLevel(LOGGER_CONFIG["level"])
def update_xrates(from_currency, to_currency):
log.info("Started update for: %s=>%s" % (from_currency, to_currency))
xrate = XRate.select().where(XRate.from_currency == from_currency,
XRate.to_currency == to_currency).first()
log.debug("rate before: %s", xrate)
xrate.rate += 0.01
xrate.updated = peewee_datetime.datetime.now()
xrate.save()
log.debug("rate after: %s", xrate)
log.info("Finished update for: %s=>%s" % (from_currency, to_currency))
if __name__ == '__main__':
update_xrates(840, 980)
OPERATOR = {
#insert
0 : "insertion",
#delete
1 : "removal"
}
'''
import os
import sys
from abc import ABCMeta, abstractmethod
project_root = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
sys.path.append(project_root)
from config import config, logging
logger = logging.getLogger("attacker.modification")
MANIFEST = "AndroidManifest.xml" # type: str
class DroidModification(object):
"""Abstract base class for all attack classes."""
__metaclass__ = ABCMeta
def __init__(self, disassembly_root, verbose):
self.disassembly_root = disassembly_root
self.verbose = verbose
@abstractmethod
def insert(self, elem_name, mod_count=1):
"""Insert an specified element"""
from flask import request
from flask import jsonify
from config import KEYSTONE, DATABASE, DATABASE_CMDB, DATABASE_CLOUD, logging
from flask import g
import urlparse
import json
import re
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = DATABASE
app.config['SQLALCHEMY_BINDS'] = {
'cmdb': DATABASE_CMDB,
'cloud': DATABASE_CLOUD
}
db = SQLAlchemy(app)
logger = logging.getLogger(__name__)
@app.errorhandler(401)
def page_not_found(error):
return 'Unauthorized', 401
from apiUtil import http_request
@app.before_request
def before_request():
token = request.headers.get("X-Auth-Token")
g.party = request.headers.get("Sp-Agent", "default")
g.admin_token = KEYSTONE[g.party]['admin_token']
g.uri = KEYSTONE[g.party]['uri']
g.admin_proj = KEYSTONE[g.party]['admin_proj']
# 静态文件和监控数据不用验证，直接通过
def __init__(self, logger_name):
self.log = logging.getLogger(logger_name)
self.log.addHandler(fh)
self.log.setLevel(LOGGER_CONFIG["level"])
import hashlib
import math
import json
from config import CoreConfigure, logging
import os
from django.conf import settings
import datetime
import time
logging.basicConfig(level = logging.DEBUG,
format = '%(asctime)s %(name)s %(levelname)s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
)
logger = logging.getLogger("util")
class Node:
def __init__(self, info):
self.methodName = info['name']
self.executeTime = info['execute_time']
self.self_time = 0
self.position = info['position']
self.p_Father = 0
self.p_Root = 0
self.children = []
self.father = None
self.depth = 0
self.isValid = False
self.hashcode = None
self.maxTime = info['execute_time']
self.minTime = info['execute_time']
self.avgTime = info['execute_time']
self.percentageChildren = 0
break
else:
if any((drinks_amount == [], ingredients_amount == [])):
log.error(f'client has ordered non-existent drink \u2013 {choice_drink=}, {choice_ingredient=}')
client_socket.sendall('Sorry, I cannot make it'.encode())
break
else:
if all((drinks_amount[0][0], ingredients_amount[0][0])):
transfer_data(update_menu, choice_drink, choice_ingredient)
event.set()
log.info(f'client has ordered {choice_drink} with {choice_ingredient}')
client_socket.sendall(f'Take your {choice_drink} with {choice_ingredient}'.encode())
break
else:
log.warning(f'coffe machine has no {choice_drink} or {choice_ingredient}')
client_socket.sendall(f'coffe machine has no {choice_drink} or {choice_ingredient}'.encode())
break
log.info('client has disconnected')
client_socket.close()
if __name__ == '__main__':
log = logging.getLogger('Coffee machine')
log.setLevel(LOGGER_CONFIG['level'])
fh = logging.FileHandler(LOGGER_CONFIG['file'], 'w', 'utf-8')
fh.setFormatter(LOGGER_CONFIG['formatter'])
log.addHandler(fh)
initialize_menu()
accept_connection(server_socket, lock, event)
from multiprocessing.sharedctypes import Value
from multiprocessing.managers import BaseManager, SyncManager
from config import CoreConfigure, logging
from util import Node, Tree, InvertedIndex, DateTimeHashTable, HistroyRecord
import time
import signal
import os
from django.conf import settings
import json
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s %(name)s %(levelname)s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
)
logger = logging.getLogger("detector")
class logProfiler(object):
def __init__(self):
self.reader = Reader()
self.shareQueue = JoinableQueue()
self.finalTreeCollection = Manager().Queue()
self.processPool = []
self.slaveNumber = 2
self.count = Value('i', 0)
self.manager = Manager()
self.sharedLst = self.manager.list()
self.invertedIndex = InvertedIndex()
self.services = {}
self.final = []
"""Extract various types of features"""
import os
import collections
import warnings
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from collections import defaultdict
from tools import utils
from config import config, COMP, logging
from learner import drebin
from learner.drebin import DREBIN_FEAT_INFO
logger = logging.getLogger('learner.feature')
def normalize_data(X, is_fitting=False, feature_type='drebin'):
if is_fitting:
minmax_norm = MinMaxScaler()
normalizer = minmax_norm.fit(X)
utils.dump_pickle(normalizer,
config.get('feature.' + feature_type, 'normalizer'))
elif os.path.exists(config.get('feature.' + feature_type,
'normalizer')) and not is_fitting:
normalizer = utils.read_pickle(
config.get('feature.' + feature_type, 'normalizer'))
else:
raise ValueError("Unable to find the normalizer")
feat_normlized = normalizer.transform(X)
__date__ = "2016-08-18"
import yaml
import sys
import json
import os
import time
import math
from lib2to3.pgen2 import driver
import requests
from bs4 import BeautifulSoup
from selenium import webdriver
import config
from config import logging
logger = logging.getLogger("test")
class PhantomJsUtils(object):
__instance = None
__phantomJsDriver = None
def __new__(cls, *args, **keys):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
log_name = "/tmp/phantomjs.log" #ログを出力しない場合はos.path.devnull
userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_2 like Mac OS X) AppleWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/11D257 Safari/9537.53"
timeDriverStart = time.clock()
cls.__phantomJsDriver = webdriver.PhantomJS(
desired_capabilities={
import requests
from models import XRate, peewee_datetime
from config import logging, LOGGER_CONFIG
log = logging.getLogger('PrivatApi')
fh = logging.FileHandler(LOGGER_CONFIG['file'])
fh.setLevel(LOGGER_CONFIG['level'])
fh.setFormatter(LOGGER_CONFIG['formatter'])
log.addHandler(fh)
log.setLevel(LOGGER_CONFIG['level'])
def update_xrates(from_currency, to_currency):
log.info(f'Started update for: {from_currency} => {to_currency}')
# получение курса из БД
xrate = XRate.select().where(XRate.from_currency == from_currency,
XRate.to_currency == to_currency).first()
log.debug(f'rate before: {xrate}')
# получение нового значения от Привата и сохранение его в объект xrate
xrate.rate = get_private_rate(from_currency)
# обновление поля updated
xrate.updated = peewee_datetime.datetime.now()
xrate.save()
log.debug(f'rate after: {xrate}')
log.info(f'Finished update for: {from_currency} => {to_currency}')
def get_private_rate(from_currency):
""" @author : MG @Time : 2020/9/18 8:48 @File : period_resonance_strategy.py @contact : [email protected] @desc : 用于多周期共振策略 首先研究 1分钟、5分钟周期共振，之后再扩展到多周期，甚至日级别共振 """ from vnpy.app.cta_strategy import (StopOrder, TickData, BarData, TradeData, OrderData, BarGenerator, ArrayManager, CtaSignal, TargetPosTemplate) from config import logging logger = logging.getLogger() class MACDSignal(CtaSignal): """""" def __init__(self, fast_window: int, slow_window: int, signal_period: int, period: int = 30): """""" super().__init__() self.fast_window = fast_window self.slow_window = slow_window self.signal_period = signal_period self.period = period
from time import sleep
from defenses import BasicDNN, FeatureBinarizationDNN, AdversarialTrainingRegDNN, \
DAE_RPST_DNN, JointDefense, RandomSubspaceMethod
from config import logging
logger = logging.getLogger("common")
class Defender(object):
def __init__(self, defense_method_name='adv_training_dnn'):
self.defense_method_name = defense_method_name
self.defense = None
if self.defense_method_name == 'basic_dnn':
self.defense = BasicDNN()
elif self.defense_method_name == 'feature_bnrz_dnn':
self.defense = FeatureBinarizationDNN()
elif self.defense_method_name == 'adv_training_dnn':
self.defense = AdversarialTrainingRegDNN()
elif self.defense_method_name == 'dae_rpst_dnn':
self.defense = DAE_RPST_DNN()
elif self.defense_method_name == 'joint_defense':
self.defense = JointDefense()
elif self.defense_method_name == 'random_subspace':
self.defense = RandomSubspaceMethod()
else:
raise ValueError(
"Please choose method from 'basic_dnn', 'feature_bnrz_dnn', 'adv_training_dnn', 'dae_rpst_dnn', 'joint_defense', and 'random_subspace'."
)
def train(self):
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from defenses.classification import *
from dataset.dataset import load_trainset, load_testset
from dataset.input_preprocessing import normalize_data, random_over_sampling
from utils import utils
from config import config, logging
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
logger = logging.getLogger("basic_dnn")
def graph(x_input, hidden_neurons=[160, 160], output_dim=5, is_training=True, name="BASIC_DNN",
reuse=False):
'''
the defined architectures of nerual network
:param x_input: Tensor
:param hidden_neurons: neurons for hidden layers
:param output_dim: int
:param is_training: training or not
:param name: string, nets name
:param reuse: reuse or not
:return: the defined graph of neural networks
'''
with tf.variable_scope("{}".format(name), reuse=reuse):
from config import logging
# define name and location of logfile
log_file = "./logfile.log"
# Configure logging
logging.basicConfig(level=logging.DEBUG, filename=log_file, filemode="a",
format="%(asctime)-15s %(levelname)-8s %(message)s")
logger = logging.getLogger("logger")
# Configure streamhandler
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
stream_handler.setFormatter(logging.Formatter("%(asctime)-15s %(levelname)-8s %(message)s"))
logger.addHandler(stream_handler)
def wrapper(pre, post):
"""
Simple wrap function, Wrapper decorator @ is to be placed right on top of function to be wrapped
:param pre: Function called before the function that is being wrapped
:param post: Function called after the function that is being wrapped
"""
def decorator(function):
def inner(*args, **kwargs):
# function that is called before executing wrapped function
pre(function)
# execute wrapped function
result = function(*args, **kwargs)
import requests
import xml.etree.ElementTree as ET
from models import XRate, peewee_datetime
from config import logging, LOGGER_CONFIG
log = logging.getLogger('CBRApi')
fh = logging.FileHandler(LOGGER_CONFIG['file'])
fh.setLevel(LOGGER_CONFIG['level'])
fh.setFormatter(LOGGER_CONFIG['formatter'])
log.addHandler(fh)
log.setLevel(LOGGER_CONFIG['level'])
def update_xrates(from_currency, to_currency):
log.info(f'Started update for: {from_currency} => {to_currency}')
# получение курса из БД
xrate = XRate.select().where(XRate.from_currency == from_currency,
XRate.to_currency == to_currency).first()
log.debug(f'rate before: {xrate}')
# получение нового значения от Привата и сохранение его в объект xrate
xrate.rate = get_cbr_rate(from_currency)
# обновление поля updated
xrate.updated = peewee_datetime.datetime.now()
xrate.save()
log.debug(f'rate after: {xrate}')
log.info(f'Finished update for: {from_currency} => {to_currency}')
from reader import Reader
from multiprocessing import *
from multiprocessing.sharedctypes import Value
from multiprocessing.managers import BaseManager, SyncManager
from config import CoreConfigure, logging
from util import Node, Tree, InvertedIndex, DateTimeHashTable, HistroyRecord
import time
import signal
import os
from django.conf import settings
import json
logging.basicConfig(level = logging.INFO,
format = '%(asctime)s %(name)s %(levelname)s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
)
logger = logging.getLogger("detector")
class logProfiler(object):
def __init__(self):
self.reader = Reader()
self.shareQueue = JoinableQueue()
self.finalTreeCollection = Manager().Queue()
self.processPool = []
self.slaveNumber = 2
self.count = Value('i',0)
self.manager = Manager()
self.sharedLst = self.manager.list()
self.invertedIndex = InvertedIndex()
self.services = {}
self.final = []
def main():
global r
prawlogger = logging.getLogger('prawcore')
prawlogger.setLevel(logging.WARN)
while True:
# Login retry loop
try:
logger.info('Logging in as {0}'
.format(cfg_file.get('reddit', 'username')))
r = praw.Reddit(client_id = cfg_file.get('reddit', 'client_id'),
client_secret = cfg_file.get('reddit', 'client_secret'),
user_agent = cfg_file.get('reddit', 'user_agent'),
username = cfg_file.get('reddit', 'username'),
password = cfg_file.get('reddit', 'password'))
# break
except Exception as e:
logger.error('ERROR: {0}'.format(e))
logger.debug(traceback.format_exc())
else:
sr_dict = get_moderated_subreddits()
# load conditions from wiki
rule_dict = load_all_rules(sr_dict)
pprint.pprint(rule_dict)
break
while True:
# main execution loop
sleep_after = True
reload_mod_subs = False
try:
# First, process command messages
for message in unread_messages():
try:
command = message.body.strip().lower()
sr_name = clean_sr_name(message.subject).lower()
subreddit = r.subreddit(sr_name)
# TODO: validate user is moderator
if message.author not in subreddit.moderator():
message.reply('Error: You do not moderate /r/{0}'.format(subreddit.display_name))
continue
# OK, validated
if command == 'register':
# do we know this sub?
if sr_name in sr_dict.keys():
message.reply("I already moderate /r/{}.\n\n".format(sr_name))
continue
# otherwise... try to accept mod invite
try:
subreddit.mod.accept_invite()
except:
# should be APIException(error_type='NO_INVITE_FOUND')
message.reply("You must invite me to moderate /r/{} first."
.format(sr_name))
raise
else:
# get sub from db if previously registered:
db_subreddit = None
try:
db_subreddit = (session.query(Subreddit)
.filter(Subreddit.name == sr_name)
.one())
except NoResultFound:
# add to DB
db_subreddit = Subreddit()
db_subreddit.name = subreddit.display_name.lower()
db_subreddit.last_submission = datetime.utcnow() - timedelta(days=1)
db_subreddit.last_spam = datetime.utcnow() - timedelta(days=1)
db_subreddit.last_comment = datetime.utcnow() - timedelta(days=1)
db_subreddit.conditions_yaml = ''
session.add(db_subreddit)
finally:
# now that it definitely exists: set enabled
# (should we clear old rules from the db?)
db_subreddit.enabled = True
session.commit()
message.reply("I have joined /r/{}".format(db_subreddit.name))
elif command in ['update', 'status', 'enable', 'disable', 'leave']:
# these require the same database query
db_subreddit = None
try:
db_subreddit = (session.query(Subreddit)
.filter(Subreddit.name == sr_name)
.one())
except NoResultFound:
message.reply("Subreddit /r/{} is not registered with me."
.format(sr_name))
else:
# only proceed if we get a database hit.
if command == 'update':
# refresh configuration for a subreddit
# todo: cache duplicate requests from multiple mods
reload_mod_subs = True
update_from_wiki(db_subreddit, message)
elif command == 'status':
pass
elif command == 'enable':
db_subreddit.enabled = True
reload_mod_subs = True
elif command == 'disable':
db_subreddit.enabled = False
reload_mod_subs = True
elif command == 'leave':
# leave moderator of subreddit
if db_subreddit.enabled:
message.reply("Please disable me on this subreddit first.")
else:
# TODO not implemented yet
reload_mod_subs = True
raise NotImplementedError
# the following commands should respond with the enabled status
if command in ['status', 'enable', 'disable']:
message.reply("Subreddit /r/{} is currently {}abled."
.format(db_subreddit.name,
'en' if db_subreddit.enabled else 'dis'))
finally:
session.commit()
elif command == 'help':
# should this just provide a link, or real command explanations?
raise NotImplementedError
else:
# invalid command
message.reply("Invalid command.")
except NotImplementedError:
message.reply("Error: that feature is not yet implemented.")
except KeyboardInterrupt:
raise
except Exception as e:
logger.error('ERROR: {0}'.format(e))
logger.debug(traceback.format_exc())
message.reply("# ERROR:\n\n{}".format(indent_lines(str(e))))
finally:
message.mark_read()
# changed mod subs
if reload_mod_subs:
sr_dict = get_moderated_subreddits()
rule_dict = load_all_rules(sr_dict)
# Then process queues: submission, comment, spam, report, comment reply, username mention
# TODO: queue for edited items...
# Queue priority, in increasing specificity:
# - reports: multi/about/reports?only=(links|comments)
# - comment
# - submission
# - any
# - spam: multi/about/spam?only=(links|comments)
# - comment
# - submission
# - any
# - edited: multi/about/edited?only=(links|comments)
# - comment
# - submission
# - any
# - reply: inbox
# - mention: inbox
# - submission: multi/new
# - comment: multi/comments
multi_mod_queues = ['reports', 'spam', 'edited'] # r.subreddit().mod.<q>
multi_queues = ['new', 'comments'] # r.subreddit().<q>
user_queues = ['comment_replies', 'submission_replies', 'mentions'] # r.user.inbox.<q>
# proof of concept
for sr_name, subreddit in sr_dict.items():
logger.debug("Checking items in /r/{}".format(sr_name))
sr = r.subreddit(sr_name)
# mod-only level queues
for item in sr.mod.spam():
for rule in rule_dict[sr_name]:
rule.process(item)
for item in sr.mod.reports():
for rule in rule_dict[sr_name]:
rule.process(item)
for item in sr.mod.edited():
for rule in rule_dict[sr_name]:
rule.process(item)
# sub-level queues
for item in sr.mod.new():
for rule in rule_dict[sr_name]:
rule.process(item)
for item in sr.mod.comments():
for rule in rule_dict[sr_name]:
rule.process(item)
# user queues - not implemented
# for queue in queue_funcs:
# subreddits = [s for s in sr_dict
# if s in cond_dict and len(cond_dict[s][queue]) > 0]
# if len(subreddits) == 0:
# continue
# multireddits = build_multireddit_groups(subreddits)
# # fetch and process the items for each multireddit
# for multi in multireddits:
# if queue == 'report':
# limit = cfg_file.get('reddit', 'report_backlog_limit_hours')
# stop_time = datetime.utcnow() - timedelta(hours=int(limit))
# else:
# stop_time = max(getattr(sr, 'last_'+queue)
# for sr in sr_dict.values()
# if sr.name in multi)
# queue_subreddit = r.get_subreddit('+'.join(multi))
# if queue_subreddit:
# queue_func = getattr(queue_subreddit, queue_funcs[queue])
# items = queue_func(limit=None)
# check_items(queue, items, stop_time, sr_dict, cond_dict)
except KeyboardInterrupt:
raise
except Exception as e:
logger.error('ERROR: {0}'.format(e))
logger.debug(traceback.format_exc())
session.rollback()
finally:
if sleep_after:
logger.info('Sleeping for 10 seconds')
sleep(10)
logger.info('Sleep ended, resuming')
logging.info("Looping")
import os
import shutil
import sys
import multiprocessing
import subprocess
import time
from collections import defaultdict
sys.path.append(os.path.dirname(os.getcwd()))
sys.path.append(os.getcwd())
from attacker.modification import *
from tools import utils, progressbar_wrapper
from config import config, COMP, logging, ErrorHandler
logger = logging.getLogger("attacker.modifier")
logger.addHandler(ErrorHandler)
OPERATOR = {
# insert
0: "insert",
# remove
1: "remove"
}
INSTR_ALLOWED = {
OPERATOR[0]: [
COMP['Permission'], COMP['Activity'], COMP['Service'],
COMP['Receiver'], COMP['Hardware'], COMP['Intentfilter'],
COMP['Android_API'], COMP['User_String']
],
from models import XRate, init_db
from config import logging, LOGGER_CONFIG
log = logging.getLogger('TestApi')
fh = logging.FileHandler(LOGGER_CONFIG['file'])
fh.setLevel(LOGGER_CONFIG['level'])
fh.setFormatter(LOGGER_CONFIG['formatter'])
log.addHandler(fh)
log.setLevel(LOGGER_CONFIG['level'])
def update_xrates(from_currency, to_currency):
log.info(f'Started update for: {from_currency} => {to_currency}')
xrate = XRate.select().where(XRate.from_currency == from_currency,
XRate.to_currency == to_currency).first()
log.debug(f'rate before: {xrate}')
xrate.rate += 0.01
xrate.save()
log.debug(f'rate after: {xrate}')
log.info(f'Finished update for: {from_currency} => {to_currency}')