def capture_temp_humid_from_pi(base_path, pi_ip_address, pi_id):
path = os.path.join(base_path, pi_id)
# Run infintely
while 1:
humidity, temperature_C = Adafruit_DHT.read_retry(sensor, pin)
# Convert Celcius temperature to Fahrenheit
temperature_F = temperature_C * 9 / 5.0 + 32
# Choose which to report
temperature = temperature_F
#temperature = temperature_C
fname = datetime.now().strftime("%Y-%m-%d %H%M%S_TempHumid.txt")
###not sure what file type is best. Also this creates a new file for every reading,
###but not sure if we want to append to 1 file (or 1 per day?)
# Check that both captured without errors
if humidity and temperature:
try:
# Open new file we just made and write data to it
file = open(fname, "w")
file.write(humidity + " " + temperature)
file.close()
except Exception as e:
logging.CRITICAL(
"Unable to take reading and write to disk. Error: {}. File: {}"
.format(e, fname))
elif not temperature and humidity: ###not sure if this is correct way to state this
logging.CRITICAL(
"Capture from pi failed for file: {}".format(fname))
# Only try to take a reading every 10 seconds
time.sleep(timeDelay)
def tesa(a):
logging.info("into the function tesa ")
#logging.critical("the function got the value "+str(a))
logging.critical("the function got the value " + str(a))
logging.error("the function got the value " + str(a))
logging.warning("the function got the value " + str(a))
pdb.set_trace()
logging.info("the function got the value " + str(a))
logging.debug("the function got the value " + str(a))
try:
b = a / 2
except Exception as ex:
logging.DEBUG("an exception has occured DEBUG")
logging.INFO("an exception has occuredINFO")
logging.WARNING("an exception has occuredWARNING")
logging.ERROR("an exception has occuredERROR")
logging.CRITICAL("an exception has occuredCRITICAL")
logging.CRITICAL(str(ex))
logging.ERROR(str(ex))
logging.WARNING(str(ex))
logging.INFO(str(ex))
logging.DEBUG(str(ex))
def find_fandom_fic_cnt(self, ffnet_url):
logging.debug('find-cnt')
oDB = FanFicSql(self._Path)
oDB.FilePath = self._Path
logging.debug('DB: ' + self._Path)
oUrl = FanfictionNetUrlBuilder(ffnet_url, "http://",
"www.fanfiction.net/")
# cnt = 810
fic_cnt = 0
sUrl = oUrl.generate_page_url(1)
logging.debug('surl: ' + sUrl)
try:
html = urlopen(sUrl)
except:
print('sleep')
time.sleep(60)
try:
html = urlopen(sUrl)
except:
logging.CRITICAL("html = urlopen(sUrl) failed" + sUrl)
print("ERROR")
return fic_cnt
bsObj = BeautifulSoup(html, "html5lib")
icnt = self.get_fandom_length(bsObj)
sUrl = oUrl.generate_page_url(icnt)
try:
html = urlopen(sUrl)
except:
print('sleep')
time.sleep(60)
try:
html = urlopen(sUrl)
except:
logging.CRITICAL("html = urlopen(sUrl) failed" + sUrl)
print("ERROR")
return fic_cnt
bsObj = BeautifulSoup(html, "html5lib")
nameList = bsObj.findAll("div", class_='z-list zhover zpointer ')
last_pg_cnt = len(nameList)
if icnt == 1:
return last_pg_cnt
else:
icnt -= 1
fic_cnt = icnt * 25
fic_cnt += last_pg_cnt
return fic_cnt
def is_oldest_fics_in_db(self, info):
logging.debug('find-cnt')
oDB = FanFicSql(self._Path)
oDB.FilePath = self._Path
logging.debug('DB: ' + self._Path)
oUrl = FanfictionNetUrlBuilder(info.FandomUrl, "http://",
"www.fanfiction.net/")
# cnt = 810
fic_cnt = 0
sUrl = oUrl.generate_page_url(1)
logging.debug('surl: ' + sUrl)
try:
html = urlopen(sUrl)
except:
print('sleep')
time.sleep(60)
try:
html = urlopen(sUrl)
except:
logging.CRITICAL("html = urlopen(sUrl) failed" + sUrl)
print("ERROR")
return fic_cnt
bsObj = BeautifulSoup(html, "html5lib")
icnt = self.get_fandom_length(bsObj)
sUrl = oUrl.generate_page_url(icnt)
html = urlopen(sUrl)
bsObj = BeautifulSoup(html, "html5lib")
fics = self.get_fic_from_page(bsObj)
for fic in fics:
if not oDB.is_fic_in_Db(fic.FFNetID):
return False
return True
def FillClosePrice(market, tradingdate):
try:
stock_order.objects.raw(
'update d_eq008,stockclose set d_eq008.F_ClosePrice=stockclose.Close where (d_eq008.F_Status IS NULL or d_eq008.F_Status=\'1\') AND (stockclose.stocksymbol_id=concat(d_eq008.F_SKID,\'.\',d_eq008.F_Market) and stockclose.tDate=d_eq008.F_Date);'
)
except:
logging.CRITICAL("FillClosePrice error:", sys.exc_info()[0])
def connect(self):
try:
dydb = boto3.resource('dynamodb', region_name=self.region)
conn = dydb.Table(self.table)
return conn
except:
print("Problema na conexao com DynamoDB")
logging.CRITICAL("Problema na conexao com DynamoDB")
return False
def build_dep(bind,args):
global instruction_granularity
blocks = bind.blocks
#bind.writetofile(args)
if len(blocks) == 0:
logging.critical("build_dep:NO BLOCKS FOUND")
print "ENTER A VALID ASM"
exit(-1)
else:
#Every block
totalhazards = 0
for alp in xrange(bind.countblocks()):
logging.info("build_dep:alp="+str(alp))
care,insts = parseinst(bind.getblock(alp))
for i in insts:
logging.info("build_dep:Returned:"+i.rawtxt)
logging.info("analyzing block "+str(alp))
analyze = 0 #analyze is if blocks have a hazard.
issues = [] #issues is an array of arrays. Each element in this array
#has two members start index , end index.
#the start index + 1 value represents the LW
#The end index represents until where to check
#@dev: lim not checked , handled outside.
#an array of arrays because there might be more than one hazard
#in the same block.
#Runs several times per block.if a caremuch issue exists
for each in care:
#If next instruction is valid
if len(insts) > each+1:
#If dependency exists
if insts[each].dest in insts[each+1].dep:
if insts[each+1].branchmuch ==0:
print alp , insts[each].rawtxt , insts[each+1].rawtxt
analyze = 1
issues.append([])
issues[len(issues)-1].append(each)
issues[len(issues)-1].append(each+instruction_granularity-1)
totalhazards = totalhazards + 1
else:
logging.CRITICAL("BUILDDEP:AVOIDED EDGE CASE - LD , JMP or LD , BR")
else:
logging.info( "\tNo optimizations possible in block "+str(alp))
#Runs once per block
if analyze == 1:
lel = graphit(insts,issues)
bind.overwriteblock(rawoverwrite(lel,alp,bind.getformatterstat()),alp)
print "Total Possible Hazards "+str(totalhazards)
logging.debug("Total Possible Hazards "+str(totalhazards))
bind.writetofile(args)
def connection_database(user, password, host, port, database):
try:
db = psycopg2.connect(user=user,
password=password,
host=host,
port=port,
database=database)
cursor = db.cursor()
logging.info('Successful connection')
return db, cursor
except:
logging.CRITICAL('Connection error')
def run(self):
log_file = os.path.join(self.base_dir, "i3geoweather.log")
handler = logging.handlers.RotatingFileHandler(log_file,
maxBytes=200000,
backupCount=2)
logging.basicConfig(
level=self.log_level,
format='%(asctime)s %(levelname)s: %(message)s',
handlers=(handler, ),
)
logging.debug("i3geoweather starting")
self.read_caches()
fname = os.path.join(self.base_dir, "i3geoweather.txt")
while True:
try:
lat, lon = self.geolocate()
if lat is not None and lon is not None:
self.latitude, self.longitude = (lat, lon)
location, temp = self.get_weather(self.latitude,
self.longitude)
if location is not None and temp is not None:
self.location, self.temperature = (location, temp)
sleep = WAIT_SUCCESS
else:
sleep = WAIT_FAILURE
if self.location is not None and self.temperature is not None:
self.write_weather(fname, self.location, self.temperature)
logging.debug("next update attempt in %d seconds" % sleep)
time.sleep(sleep)
except:
logging.CRITICAL("Unhandled exception")
logging.CRITICAL(traceback.format_exc())
fd, tmpname = tempfile.mkstemp()
os.write(fd, "i3geoweather error\n".encode())
os.close(fd)
os.rename(tmpname, fname)
logging.CRITICAL("i3geoweather stopping")
self.stop()
logging.CRITICAL("i3geoweather stopped")
break
def fetchReleaseAndPlatform(ctx, lines):
try:
line = lines[0]
except IndexError:
line = 'null'
newState = "MISSING_REL_PLAT"
return (newState, lines)
platform = ""
release = ""
z = re.search(r'ucs-(.*?)-huu-(.*?).iso', line)
if z:
platform = z.group(1)
release = z.group(2)
if release != "":
if release in ctx.finalData.keys():
if platform != "":
if platform in ctx.finalData[release].keys():
logging.critical('duplicate REL=%s PLAT=%s, skipping',
release, platform)
newState = 'DUPLICATE_REL_PLAT'
return (newState, lines[1:])
ctx.finalData[release][platform] = {}
else:
logging.critical("Error fetching 'Platform'")
sys.exit()
else:
ctx.finalData[release] = {}
if platform != "":
ctx.finalData[release][platform] = {}
else:
logging.critical("Error fetching 'Platform'")
sys.exit()
else:
logging.CRITICAL("Error fetching 'Release'")
sys.exit()
if platform != "" and release != "":
ctx.release = release
ctx.platform = platform
logging.info('RELEASE %s PLATFORM %s line %s', release, platform,
ctx.current_lineNo)
newState = "FETCH_COMPONENTS"
else:
newState = "FETCH_REL_PLAT"
return (newState, lines[1:])
def start_gui():
"""Initialize and start the tkinter GUI"""
# Hopefully this will catch any startupt errors tk might have
try:
root = tk.Tk()
except tk.TclError as exc:
logging.CRITICAL("Could not start GUI:" + exc)
sys.exit(3)
root.title("NetDash")
app = App(root)
root.mainloop()
def run_game(num_times):
print(num_times)
button = browser.find_element_by_class_name('retry-button')
while button.is_displayed() == False:
rand_udrl()
button.click()
if num_times > 0:
run_game(num_times - 1)
elif num_times < 0:
logging.CRITICAL("num_times must be larger than 0")
def loadCredentials(config):
if not config["tokenfile"]:
quit("You have to provide a token file.")
logging.CRITICAL("You have to provide a token file.")
else:
logging.debug(f"Reading token info from: <{config['tokenfile']}>")
with open(config["tokenfile"], "r") as f:
token = json.load(f)
config["access_token"] = token["access_token"]
config["refresh_token"] = token["refresh_token"]
token = JWT()
decoded_token = token.decode(config["access_token"],
do_verify=False,
algorithms="HS256")
config["user_id"] = decoded_token["user_id"]
def start_up(self):
"""
Will add the data from the json file to the linked list at startup
"""
json_path = str(self.get_json_path())
try:
if self.is_empty() is not True:
with open(json_path, "r") as fp:
loaded_json = json.load(fp)
for key, element in loaded_json.items():
string = element["Validated_string"]
di = {key: element}
self.add(di, string, state=True)
else:
pass
except json.JSONDecodeError as e:
logging.CRITICAL(e)
def read(self, filePath):
try:
self.iniFile.read(filePath)
if not self.iniFile.has_section(NBGMINIReader.COMMON):
logging.CRITICAL('Cannot find the section %s!' % COMMON)
return False
if not self.iniFile.has_section(NBGMINIReader.REGIONS):
logging.CRITICAL('Cannot find the section %s!' % REGIONS)
return False
if not self.iniFile.has_section(NBGMINIReader.FEATURE_TEST_LEVES):
logging.CRITICAL('Cannot find the section %s!' %
FEATURE_TEST_LEVES)
return False
waitTime = self.iniFile.getint(NBGMINIReader.COMMON, 'WaitTime')
self.waitTime = waitTime / 1000.0
ops = self.iniFile.options(NBGMINIReader.REGIONS)
if not ops:
logging.CRITICAL('Section [Regions] is empty!')
return False
regions = {}
for item in ops:
if item.find('map') != -1:
regions[item] = ''
for item in ops:
if item.find('input') != -1:
map_key = item.replace('input', 'map')
if regions.has_key(map_key):
regions[map_key] = item
for k, v in regions.iteritems():
mapPath = self.iniFile.get(NBGMINIReader.REGIONS, k).strip()
inputPath = self.iniFile.get(NBGMINIReader.REGIONS, v).strip()
if mapPath and inputPath:
self.regionList.append(Region(mapPath, inputPath))
testLevels = self.iniFile.options(NBGMINIReader.FEATURE_TEST_LEVES)
if not testLevels:
logging.CRITICAL('Section [Feature Test Levels] is empty!')
return False
for level in testLevels:
items = self.iniFile.get(NBGMINIReader.FEATURE_TEST_LEVES,
level).split(',')
data = []
for i in items:
data.append(LevelDspProp(i))
if data:
self.testLevels[level] = data
return True
except Exception, e:
print(e)
logging.CRITICAL('The ini file %s is invalid!' % filePath)
return False
def obtainCredentials(config):
logger.info("Getting auth token")
if config["verbose"]:
logging.info("Getting auth token")
if (config["clientid"] and config["clientsecret"] and config["username"]
and config["password"]):
if config["verbose"]:
logging.info("All required parameters passed for auth token")
url = "https://api.flumetech.com/oauth/token"
payload = ('{"grant_type":"password","client_id":"' +
config["clientid"] + '","client_secret":"' +
config["clientsecret"] + '","username":"******"username"] + '","password":"******"password"] +
'"}')
headers = {"content-type": "application/json"}
resp = requests.request("POST", url, data=payload, headers=headers)
logging.info(f"Response from server: {resp.text}")
dataJSON = json.loads(resp.text)
if dataJSON["http_code"] == 200:
logging.info("Got 200 response from auth token request.")
config["access_token"] = dataJSON["data"][0]["access_token"]
token = JWT()
decoded_token = token.decode(config["access_token"],
do_verify=False,
algorithms="HS256")
config["user_id"] = decoded_token["user_id"]
config["refresh_token"] = dataJSON["data"][0]["refresh_token"]
if config["tokenfile"]:
outline = {}
outline["access_token"] = config["access_token"]
outline["refresh_token"] = config["refresh_token"]
logging.info("Saving access and refresh token to : " +
config["tokenfile"])
logging.debug(outline)
f = open(config["tokenfile"], "w")
f.write(json.dumps(outline))
f.close()
else:
logging.CRITICAL("ERROR: Failed to obtain credentials")
def getHumblePic():
'''Finds random pick from recent pictures on hubblesite.org. Returns link
to image as a string. Returns None if there is a problem.'''
x = requests.get('http://hubblesite.org/images/gallery')
soup = bs4.BeautifulSoup(x.text, 'lxml')
pickList = []
for i in soup.find_all('a'):
if i.get('href') == None:
continue
if re.match(r'/image/\d{4}/', i.get('href')) != None:
pickList.append("http://hubblesite.org" + i.get('href'))
selected = pickList[random.randint(0, len(pickList) - 1)]
x = requests.get(selected)
soup = bs4.BeautifulSoup(x.text, 'lxml')
for i in soup.find_all('a'):
if 'http://imgsrc.' in i.get('href'):
return i.get('href')
logging.CRITICAL("getHumblePic --- Houston, we have a problem...")
return
def on_enter_Restart(self):
logging.debug("now on_enter_Restart")
logging.debug("restart Camera")
self.camera.close()
# Setup Camera
try:
self.camera = picamera.PiCamera()
except:
logging.CRITICAL("error initializing the camera - exiting")
raise SystemExit
self.camera.resolution = (self.photo_w, self.photo_h)
self.camera.hflip = self.flip_screen_h
self.camera.vflip = self.flip_screen_v
self.startpreview()
# load the Logo of the Photobooth and display it
self.overlayscreen_logo = self.overlay_image_transparency(self.screen_logo, 0, 5)
self.to_Start()
def download_mp3(download_url, s, path_filename):
"""
Download a song from z1.fm.
Args:
download_url (str): url to load the mp3 from
s (requests.Session): session with already stored headers for z1.fm
Returns:
flag, if the down load was successful
"""
# Download and save mp3
# Get the link
try:
song_request_response = s.get(download_url)
except Exception as e:
logger.error(f"The following error was encountered: {e}")
logger.CRITICAL(download_url)
with open(os.path.join(path_filename), "wb") as f:
f.write(song_request_response.content)
def log(_level: str, _log: str) -> None:
if _level == "debug":
logging.DEBUG(_log)
return
elif _level == "info":
logging.INFO(_log)
return
elif _level == "warning":
logging.WARNING(_log)
return
elif _level == "error":
logging.ERROR(_log)
return
elif _level == "critical":
logging.CRITICAL(_log)
return
else:
return
def main():
# Get the arguments from the command-line except the filename
argv = sys.argv[1:]
params = get_params(argv)
print('Program started, input file: %s' % params['filepath'])
if 'debug' in params.keys():
if params['debug'] == '1':
print('Setting debug level: Debug')
logging.getLogger().setLevel(logging.DEBUG)
else:
print('Setting debug level: Warnings')
logging.getLogger().setLevel(logging.WARNING)
else:
logging.getLogger().setLevel(logging.INFO)
params['data_params'], type_dict = reader.get_data_settings(params['config_file'])
header, raw_data = reader.get_data(params)
type_selector, converters = reader.validate_data_format(params['data_params'], header)
key_fails, failed_rows, surveys,quality_assessment, out_keys,meta, raw_surveys = data_processor.process_rows(raw_data, header, params, converters)
if 'logfile' in params:
if params['logfile'].endswith('txt'):
writer.write_log(logfiler.write_txt_log(params, key_fails, raw_data, failed_rows, meta), params['logfile'], 'Log:')
elif params['logfile'].endswith('csv'):
writer.write_log(logfiler.create_pbi_log(surveys,quality_assessment, meta['attribute_quality'], meta, failed_rows,params), params['logfile'], ['Key', 'Value'])
else:
logging.CRITICAL('Logfile not written, wrong file extension provided')
out_header = surveys[0].keys()
if params['outfile'].endswith('.csv'):
writer.write_data(surveys, out_header, params,rounding=9,raw_surveys=raw_surveys)
if len(quality_assessment) > 0:
writer.write_data(quality_assessment, quality_assessment[0].keys(), params, sub_file='group_qual')
if len(meta['attribute_quality']) > 0 and 'logfile' in params:
writer.write_data(meta['attribute_quality'], meta['attribute_quality'][0].keys(), params,
sub_file='attr_qual')
else:
logging.critical("Your output filename: %s must end with .csv" % params['outfile'])
}
uniq_names = get_uniq_names(NAMES_FILE)
logging.debug('by max_latitude: %s', by_coordinates.max_latitude())
logging.debug("by min_latitude: %s", by_coordinates.min_latitude())
logging.debug("by max_longitude: %s", by_coordinates.max_longitude())
logging.debug("by min_longitude: %s", by_coordinates.max_longitude())
logging.info('Creating the database connection')
try:
db = Database()
cursor = db.cursor()
db.create_tables()
except Exception as e:
logging.CRITICAL("Unable to create the database: %s", e)
for nationality in NATIONALITIES:
for i in range(1000):
name = random.choice(uniq_names)
random_lat = random.uniform(
NATIONAL_COORDINATES[nationality].min_latitude(),
NATIONAL_COORDINATES[nationality].max_latitude()
)
random_long = random.uniform(
NATIONAL_COORDINATES[nationality].min_longitude(),
NATIONAL_COORDINATES[nationality].max_longitude()
)
cursor.execute(
url2 = url + str(year) + month + day
return url2
def obtain_titles(list_of_urls):
driver = webdriver.Chrome()
for i in range(0, len(list_of_urls)):
dia = list_of_urls[i][-2:]
mes = list_of_urls[i][-5: -3]
ano = list_of_urls[i][-10: -6]
driver.get(list_of_urls[i])
lista_titulares = driver.find_elements_by_class_name('noticia')
print('\n\n' + " [+] Los titulares del día " + str(dia) + " de " + str(mes) + " de " + str(ano) + '\n\n')
for j in range(0, len(lista_titulares)):
titular = lista_titulares[j].text
logging.critical(' [!] ' + titular)
lista_titulares.clear()
# sleep(2)
driver.close()
for i in range(2):
listaweb.append(create_url(i,month[8], year[2])) #Primeros dos dias de Septiembre de 2018
obtain_titles(listaweb)
logging.CRITICAL(' ---- End of the program ---- ')
import logging
import json
import requests
import re
import os
import sys
import opencc
from slackbot import settings
from slackbot.bot import respond_to
from slackbot.bot import listen_to
from slackbot_utils import *
appid = os.getenv('EMOTIBOT_APPID', None)
if not appid:
logging.CRITICAL(
'no Emotibot AppId is found. Make sure EMOTIBOT_APPID is set')
sys.exit(1)
url = 'http://idc.emotibot.com/api/ApiKey/openapi.php'
userid_db = {}
userid_db_file = 'emotibot_userid_db.json'
userid_db_loaded = False
def emotibot_register():
register_data = {"cmd": "register", "appid": appid}
r = requests.post(url, params=register_data)
response = json.dumps(r.json(), ensure_ascii=False)
jsondata = json.loads(response)
datas = jsondata.get('data')
if completion == True:
break
# Now that the query is done, get the results.
timestart = time.time()
fw = open("output.json", "w+")
print("Getting results...")
rows = 0
while True:
getres = 'qryGetResults?startPos={}&numRows=1000000&reverse=false'.format(
rows)
data3 = {"resultID": resultID2}
try:
r3 = client.post(url + getres, headers=headers, json=data3)
except requests.exceptions.RequestException as e:
logging.CRITICAL(e)
print(e)
sys.exit(1)
rows = rows + 10000
# Write the results to a file
fw.write(r3.text)
print("Running for %s seconds." % (round(time.time() - timestart)))
#TODO: This is really hacky. Find a better way of doig this (once I have another SIEM to work with).
# fsize = os.stat('./output.json')
# lastrow = str(r3.json()['columns'])
# if fsize.st_size > 10000 and re.search('name', lastrow):
# break
# Close the result so the ESM doesn't get jammed up
close = 'qryClose?resultID=' + resultID2
try:
def reindex_archive(self, ffnet_url, fandom_name, isXover, start_page_num):
logging.debug('')
self._is_xover = isXover
self._Fandom = fandom_name
oDB = FanFicSql(self._Path)
oDB.FilePath = self._Path
logging.debug('DB: ' + self._Path)
logging.debug('lastDate: ' + str(0))
oUrl = FanfictionNetUrlBuilder(ffnet_url, "http://",
"www.fanfiction.net/")
# cnt = 810
cnt = 3
fic_cnt = 0
sUrl = oUrl.generate_page_url(1)
logging.debug('surl: ' + sUrl)
html = urlopen(sUrl)
bsObj = BeautifulSoup(html, "html5lib")
if not isXover:
self._Fandom = self.get_fandom(bsObj)
print('fandom: ' + self._Fandom)
logging.debug('Fandom: ' + self._Fandom)
icnt = self.get_fandom_length(bsObj)
logging.debug('Length: ' + str(icnt))
icnt2 = 0
for x in range(start_page_num, icnt):
sUrl = oUrl.generate_page_url(x)
logging.debug('surl: ' + sUrl)
try:
html = urlopen(sUrl)
except:
print('sleep')
time.sleep(60)
try:
html = urlopen(sUrl)
except:
logging.CRITICAL("html = urlopen(sUrl) failed" + sUrl)
print("ERROR")
return fic_cnt
bsObj = BeautifulSoup(html, "html5lib")
try:
_icnt = self.get_fandom_length(bsObj)
except:
pass
logging.debug('Length: ' + str(_icnt))
if _icnt > 0:
icnt2 = _icnt
fic_list = self.get_fic_from_page(bsObj)
fic_cnt += len(fic_list)
self.save_fic_list(fic_list)
logging.debug('fic count: ' + str(fic_cnt))
print('page_num : ' + str(x))
# time.sleep(6)
time.sleep(5)
if icnt2 > icnt:
for a in range(icnt, icnt2):
sUrl = oUrl.generate_page_url(a)
html = urlopen(sUrl)
bsObj = BeautifulSoup(html, "html5lib")
fic_list = self.get_fic_from_page(bsObj)
fic_cnt += len(fic_list)
self.save_fic_list(fic_list)
print('page_num: ' + str(a))
time.sleep(5)
return fic_cnt
import logging
logging.basicConfig(level=logging.INFO)
# 注入 500mb 的内存
def exhaust_mem(num=500, unit='MB', duration=3000):
if unit == 'MB':
s = ' ' * (num * 1024 * 1024)
else:
s = ' ' * (num * 1024 * 1024 * 1024)
time.sleep(duration)
# 注入 500mb 的内存泄漏
if __name__ == '__main__':
try:
threads = []
thread_num = 1
for i in range(0, thread_num):
thread = threading.Thread(target=exhaust_mem, args=(500, 'MB',))
threads.append(thread)
for t in threads:
t.start()
for t in threads:
t.join()
except Exception as e:
logging.exception(e)
logging.CRITICAL("Error: unable to start thread")
def __init__(self):
# create the card objects
self.layout = [PhotoCard(), PhotoCard()]
self.initStateMachine()
logging.debug("Read Config File")
self.readConfiguration()
logging.debug("Config GPIO")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.pin_button_right, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.pin_button_left, GPIO.IN, pull_up_down=GPIO.PUD_UP)
if self.pin_flash >= 0 :
GPIO.setup(self.pin_flash, GPIO.OUT)
GPIO.add_event_detect(self.pin_button_right, GPIO.FALLING, callback=self.Button2pressed, bouncetime=500)
GPIO.add_event_detect(self.pin_button_left, GPIO.FALLING, callback=self.Button1pressed, bouncetime=500)
logging.debug("Set TimeStamp for Buttons")
self.time_stamp_button1 = time.time()
self.time_stamp_button2 = time.time()
self.button1active = False
self.button2active = False
logging.debug("Setup Camera")
# Setup Camera
try:
self.camera = picamera.PiCamera()
except:
logging.CRITICAL("error initializing the camera - exiting")
raise SystemExit
self.camera.resolution = (self.photo_w, self.photo_h)
self.camera.hflip = self.flip_screen_h
self.camera.vflip = self.flip_screen_v
self.startpreview()
self.photonumber = 1
self.cycleCounter = 0
# load the Logo of the Photobooth and display it
self.overlayscreen_logo = self.overlay_image_transparency(self.screen_logo, 0, 5)
# find the USB Drive, if connected
self.PhotoCopyPath = self.GetMountpoint()
# path for saving photos on usb drive
if self.PhotoCopyPath is not None:
self.PhotoCopyPath = self.PhotoCopyPath + "/Fotos"
logging.debug("Photocopypath = " + self.PhotoCopyPath)
if not os.path.exists(self.PhotoCopyPath):
logging.debug("os.mkdir(self.PhotoCopyPath)")
os.mkdir(self.PhotoCopyPath)
else:
logging.debug("self.PhotoCopyPath not Set -> No USB Drive Found")
# find the USB Drive with card layout configuration
self.CardConfigFile = self.GetMountpoint()
# read card config data
if self.CardConfigFile is not None:
self.CardConfigFile = self.CardConfigFile + '/Fotobox/card.ini'
logging.debug("Config file for Card creating:")
logging.debug(self.CardConfigFile)
else:
self.CardConfigFile = os.path.join(REAL_PATH, 'Templates/Default/card.ini')
logging.debug("Default Config file for Card creating:")
logging.debug(self.CardConfigFile)
# read card configuration if config exists
if not os.path.exists(self.CardConfigFile):
self.CardConfigFile = os.path.join(REAL_PATH, 'Templates/Default/card.ini')
# load the Card Layout
self.readCardConfiguration(self.CardConfigFile)
# Start the Application
self.on_enter_PowerOn()
# Author: Thor Schueler
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
import sys
import logging
from controllerMenu import ControllerMenu
logging.basicConfig(level=logging.DEBUG)
try:
if __name__ == '__main__':
menu = ControllerMenu()
menu.Run()
except:
logging.CRITICAL("Oops! Exception occured:", exc_info=True)
def generate_reports_from_json(indir, outdir=""):
# Returns a DataFrame object representing the basic analysis report (overview)
# If outdir is specified it creates HTML reports
# Need to deactivate the linewidth limit
pd.set_option('display.max_colwidth', -1)
basic_reports = dict()
analyzed_apps = 0
analyzable_apps = 0
for file in os.listdir(indir):
if file.endswith(".json"):
try:
json_file = open(os.path.realpath(indir) + '/' + file, "r")
# Format a single report for each JSON file
app_dict = format_single_analysis(json.loads(json_file.read()))
analyzed_apps += 1
# If outdir specified create report in it
report = generate_report(
app_dict, ((outdir + "reports/") if outdir else ""))
del app_dict
basic_reports.update(report)
try:
d = pd.DataFrame(
basic_reports,
index=[
"Analyzable", "Target SDK", "Declared Permissions",
"Permissions asked up-front",
"Permissions educated up-front",
"Permissions asked in-context",
"Permissions educated in-context",
"Non-backtracable asked permissions",
"Non-backtracable educated permissions"
]).T
# For testing purposes (does not influence runtime heavily)
x = d.to_html(escape=False)
del d
del x
except:
logging.CRITICAL(
"Error when creating DataFrame caused by report: %s" %
report)
# Can only be a set with one element
report_key = list(report.keys())[0]
if report[report_key]["Analyzable"]:
analyzable_apps += 1
json_file.close()
except:
print("Could not load %s" % file)
# Change orientation s.t. app names form lines
df = pd.DataFrame(basic_reports).T
if outdir:
# Write overall report to output directory
with open(os.path.realpath(outdir) + "/index.html", "w") as index:
try:
report_html = df.to_html(escape=False)
html = "<h1>Report from %s</h1>\n" \
"<p>Out of overall %d apps, %d were successfully analyzed.</p>\n" \
"<h2>Report Overview:</h2>\n" \
"%s" % (datetime.now().strftime('%Y-%m-%d %H:%M:%S'), analyzed_apps, analyzable_apps,
report_html)
index.write(html)
return df
except:
(ex_type, ex_value, tb) = sys.exc_info()
traceback.print_exception(ex_type, ex_value, tb)
logging.error("Analyzed apps: %d" % analyzed_apps)
logging.error("Error when writing the overall HTML Report")
else:
return df
