class MazeApp(App):
started = BooleanProperty(False)
'''Indicates if has finished the build()
'''
app_settings = ObjectProperty(None)
'''Reference of :class:`~designer.designer_settings.DesignerSettings`.
:data:`designer_settings` is a :class:`~kivy.properties.ObjectProperty`
'''
title = 'Supermarket Maze V{}'.format(__version__)
def on_stop(self, *args):
pass
def on_request_close(self, *args):
print('Requesting a close from app..')
return False
def build(self):
self.bind(on_start=self.post_build_init)
self.root = Shell()
self.dir = os.path.join(os.path.dirname(__file__))
self.app_settings = AppSettings()
self.app_settings.pre_load_settings()
self.app_settings.load_settings()
self._setup()
def post_build_init(self, ev):
win = self._app_window
win.bind(on_keyboard=self._key_handler)
win.bind(on_request_close=self.on_request_close)
def _key_handler(self, *args):
key = args[1]
# 27 is "escape" on computers
print('key pressed: ', key)
def _setup(self, *args):
'''To setup the properties of different classes
'''
print('Setting up App environment..')
self.root.statusbar.bind(height=self.root.on_statusbar_height)
self.root.actionbar.bind(height=self.root.on_actionbar_height)
self.root.app_settings = self.app_settings
self.root.setup()
idx = self.root.screen_names.index('Game')
self.root.go_screen(idx)
self.started = True
def _cancel_popup(self, *args):
'''EventHandler for all self._popup when self._popup.content
emits 'on_cancel' or equivalent.
'''
self._popup.dismiss()
def build(self):
self.bind(on_start=self.post_build_init)
self.root = Shell()
self.dir = os.path.join(os.path.dirname(__file__))
self.app_settings = AppSettings()
self.app_settings.pre_load_settings()
self.app_settings.load_settings()
self._setup()
def dbInit():
sqlPaths = [
AppSettings().dropSQLTablePath,
AppSettings().createSQLTablePath,
AppSettings().fillSQLTablesPath
]
with open(AppSettings().allSqlCommandsPath, 'w') as total:
for sqlPath in sqlPaths:
with open(sqlPath, 'r') as f:
content = f.read()
total.write(content + '\n')
applySQLcommands(AppSettings().allSqlCommandsPath)
def generate(self):
dna = Chromosome()
cfg = AppSettings()
if not os.path.exists("reports"): # pragma: no cover
os.makedirs("reports")
f = open("reports/_" + str(int(time.time())) + ".txt", "w")
f.write("==========================\n" +
"==========================\n" + "==\n"
"== Genetics\n\n" + "nucleotides: " + dna.nucleotides() +
"\n" + "expected length: " +
str(cfg.genetics.chromosome_length) + "\n\n" + "Examples: \n")
for i in range(1, 10):
dna = Chromosome()
f.write(dna.sequence + "\n")
lengths = []
for i in range(1, 1000):
dna = Chromosome()
lengths.append(len(dna.sequence))
f.write(f"\n\nmean_length (standard deviation): " + \
f"{statistics.mean(lengths)} " + \
f"({statistics.stdev(lengths)})")
f.close()
def init_application(config_path=None):
"""
Set up the 3 main classes: Configuration, Personality and Context
This should be something that we can setup a unit test with
:param config_path:
:return:
"""
global app_config
global terminal_old_settings
terminal_old_settings = termios.tcgetattr(sys.stdin)
app_config = AppSettings(config_path)
personality = PersonalitySettings(app_config)
states = personality.get_states()
context = UserContext(states, app_config, personality)
app_config.context = context
globalvars.app_context = context
def __init__(self):
self.appSettings = AppSettings()
self.lbtesting = os.getenv('LB-TESTING') or '0'
if self.lbtesting == '1':
# print('Using AppSettingsTest')
self.appSettings = AppSettingsTest()
self.process()
def __init__(self):
super().__init__()
self.settings = AppSettings()
self.d_print("XpathEva constructor")
self.filename = ""
self.xpath_query = ""
openFile = QAction(QIcon('open.png'), 'Open', self)
openFile.setShortcut('Ctrl+O')
openFile.setStatusTip('Open new File')
openFile.triggered.connect(self.show_dialog)
appQuit = QAction(QIcon('quit.png'), 'Quit', self)
appQuit.setShortcut('Ctrl+Q')
appQuit.setStatusTip('Quit')
appQuit.triggered.connect(self._quit)
menu_bar = self.menuBar()
fileMenu = menu_bar.addMenu('&File')
fileMenu.addAction(openFile)
fileMenu.addAction(appQuit)
self.filename_label_default_text = "Filename: "
self.filename_label = QLabel(self)
self.filename_label.setText(self.filename_label_default_text)
self.query_edit = QLineEdit()
self.query_result = QTextEdit()
self.evaluate_btn_filler = HSpaceFiller()
self.evaluate_button = QPushButton("Evaluate")
self.evaluate_button.clicked.connect(self.evaluate_query)
self.vbox = QVBoxLayout()
self.evaluate_button_layout = QHBoxLayout()
self.evaluate_button_layout.addWidget(self.evaluate_btn_filler)
self.evaluate_button_layout.addWidget(self.evaluate_button)
self.vbox.addWidget(self.filename_label)
self.vbox.addWidget(self.query_edit)
self.vbox.addWidget(self.query_result)
# self.vbox.addWidget(self.evaluate_button)
self.vbox.addLayout(self.evaluate_button_layout)
self.central_widget = QWidget()
self.central_widget.setLayout(self.vbox)
self.setCentralWidget(self.central_widget)
self.setGeometry(self.settings.x_position, self.settings.y_position,
self.settings.window_width,
self.settings.window_height)
self.setWindowTitle('XpathEva')
self.statusBar().showMessage('Ready')
self.show()
self.xpath_query_result = XpathQueryResult
def __init__(self, app, *args):
QWidget.__init__(self, *args)
self.session = None
self.repo = None
self.app = app
self.system = SystemSettings()
self.settings = AppSettings()
self.main_layout = QHBoxLayout()
self.setLayout(self.main_layout)
self.launcher = InitialPanel(self.system, self.settings)
self.main_layout.addWidget(self.launcher)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.launcher.on_settings_ready.connect(self.setSettings)
self.launcher.on_root_selection.connect(self.start_session)
def test_inversion_diffs(self):
cfg = AppSettings()
reps = 1000
deltas = [] # observed number of differences
for _ in range(0, reps):
dna = Chromosome()
old_seq = dna.sequence
dna.inversion()
deltas.append(
sum(1 for a, b in zip(old_seq, dna.sequence) if a != b))
pmfs = []
expected_deltas = [] # expected differences
# Assumes the length of an inversion is drawn from a negative binomial
# distribution. Calculates the probability of each length until
# 99.99% of the distribution is accounted for. The expected number of
# differences for each length is multiplied by the probability of that length
# and the sum of that gives the expected differences overall.
k = 0
while sum(pmfs) <= 0.9999:
pmf = nbinom.pmf(k, 1, (1 - cfg.genetics.mutation_length /
(1 + cfg.genetics.mutation_length)))
pmfs.append(pmf)
diffs = math.floor(
k / 2) * (1 - 1 / len(Chromosome.nucleotides())) * 2
expected_deltas.append(pmf * diffs)
k += 1
expected_delta = sum(expected_deltas)
# Since we are multiplying the binomial distribution (probably of differences at
# a given lenght) by a negative binomial distribution (probability of a length)
# we must compute the variance of two independent random variables
# is Var(X * Y) = var(x) * var(y) + var(x) * mean(y) + mean(x) * var(y)
# http://www.odelama.com/data-analysis/Commonly-Used-Math-Formulas/
mean_binom = cfg.genetics.mutation_length
var_binom = binom.var(mean_binom, 1 / (len(Chromosome.nucleotides())))
mean_nbinom = cfg.genetics.mutation_length
var_nbinom = nbinom.var(cfg.genetics.mutation_length,
mean_nbinom / (1 + mean_nbinom))
var = var_binom * var_nbinom + \
var_binom * mean_nbinom + \
mean_binom * var_nbinom
observed_delta = sum(deltas) / reps
conf_99 = ((var / reps)**(1 / 2)) * 5
assert expected_delta - conf_99 < observed_delta < expected_delta + conf_99
def substitutions(self):
"""Randomly changes charcters in the dna according to the poisson
distribution. expected changes length * mutation rate * nonsynomous
substitutions."""
cfg = AppSettings()
num = poisson.rvs(cfg.genetics.mutation_rate * len(self.sequence))
positions = nrand.randint(0, len(self.sequence), size=num)
for pos in positions:
self.sequence = self.sequence[:pos] + \
random.choice(self.nucleotides()) + \
self.sequence[(pos + 1):]
def getDb():
dbParams = AppSettings().dbParams()
db = QtSql.QSqlDatabase.addDatabase("QMYSQL")
db.setHostName(dbParams['host'])
db.setDatabaseName(dbParams['db'])
db.setUserName(dbParams['user'])
db.setPassword(dbParams['passwd'])
ok = db.open()
if not ok:
QtGui.QMessageBox.warning(None, "Error", "Invalid database!")
sys.exit(-1)
return db
def __init__(self, sequence=None):
if sequence is not None:
self.sequence = sequence
return
cfg = AppSettings()
self.sequence = ""
p = cfg.genetics.chromosome_length / (1 +
cfg.genetics.chromosome_length)
while (random.random() <= p):
self.sequence += random.choice(self.nucleotides())
def __init__(self):
super().__init__()
# use for testing, set os.environ['LB-TESTING'] = '1' to turn or '0' to turn off
self.appSettings = AppSettings()
self.lbtesting = os.getenv('LB-TESTING') or '0'
if self.lbtesting == '1':
#print('Using AppSettingsTest')
self.appSettings = AppSettingsTest()
self.data = None
self.copyFile = None
self.default_folder = None # '{}/temp'.format(str(Path.home()))
self.child_folder_dict = AppSettings().getProjectFolders()
# self.lbproject_name = os.getenv('LB_PROJECT_name') or 'example'
#self.lbproject_name =
self.working_folder_name_default = 'example'
self.env_default = 'dev'
self.description = ['NEED TO ADD DESCRIPTION']
self.fixEnv()
def deletion(self):
"""Deletes a random sequence of characters from a random position on the string.
The length is taken from the negative binomial distribution."""
# Prevents an out of bounds error for random.randint()
if (len(self.sequence) == 0):
return
pos = random.randint(0, len(self.sequence) - 1)
cfg = AppSettings()
p = cfg.genetics.mutation_length / (1 + cfg.genetics.mutation_length)
while (random.random() <= p):
self.sequence = self.sequence[:pos] + self.sequence[(pos + 1):]
def __init__(self, foldername=None, filename='context.template.list.json'):
super().__init__(foldername, filename)
self.tagid = 'templates'
self.lbtesting = os.getenv('LB-TESTING') or '0'
self.appSettings = AppSettings()
#print('lbtesting', self.lbtesting)
if self.lbtesting == '1':
self.appSettings = AppSettingsTest()
# default to source code resource, assume we are going to copy
#self.setFolderName(self.appSettings.getResourceFolder('shared'))
self.setFolderName((self.appSettings.getFolder('shared-folder')))
self.setFolderName(self.appSettings.getFolder('shared-folder'))
self.read()
def insertion(self):
"""Inserts a random length of random nucleotide characters into a sequence
at a random location. """
if (len(self.sequence) <= 1):
pos = 0
else:
pos = random.randint(0, len(self.sequence) - 1)
cfg = AppSettings()
p = cfg.genetics.mutation_length / (1 + cfg.genetics.mutation_length)
while (random.random() <= p):
self.sequence = self.sequence[:pos] + \
random.choice(self.nucleotides()) + \
self.sequence[pos:]
def inversion(self):
if (len(self.sequence) <= 1):
pos = 0
else:
pos = random.randint(0, len(self.sequence) - 1)
cfg = AppSettings()
p = cfg.genetics.mutation_length / (1 + cfg.genetics.mutation_length)
length = nbinom.rvs(
1,
cfg.genetics.mutation_length / (1 + cfg.genetics.mutation_length))
self.sequence = self.sequence[:pos] + \
self.sequence[pos:(pos + length)][::-1] + \
self.sequence[(pos + length):]
def test_random_chromosome_length(self):
"""Ensures that random chromosomes are created at the correct average
length."""
reps = 1000
cfg = AppSettings()
lengths = []
for _ in range(0, reps):
chrom = Chromosome()
lengths.append(len(chrom.sequence))
mean_length = float(sum(lengths)) / len(lengths)
expected_length = cfg.genetics.chromosome_length
p = 1 - (expected_length / (1 + expected_length))
conf_99 = (nbinom.var(1, p) / reps)**(1 / 2) * 4
assert (expected_length - conf_99) <= mean_length <= (expected_length +
conf_99)
def test_say_and_save(self):
config = AppSettings.create()
p = PersonalitySettings.create(config.get_personality_path())
v = VoiceLibrary(config, p)
v.say("testing say", None, True)
item = v.get_saying("testing say")
print(item)
self.assertIn("file_path", item)
self.assertTrue(os.path.isfile(item["file_path"]))
self.assertIn("keep_while_exists", item)
self.assertIsNone(item["keep_while_exists"])
self.assertIn("text", item)
self.assertEqual("testing say", item["text"])
self.assertIn("timestamp", item)
self.assertIsNotNone(item["timestamp"])
os.remove(item["file_path"])
self.assertFalse(os.path.isfile(item["file_path"]))
def run(self):
self.quiz_data = self.read_quiz_data()
self.app_settings = AppSettings.from_file(self.settings_file_path)
disciplines: Set[str] = {
quiz_item.discipline
for quiz_item in self.quiz_data
}
chosen_discipline: str = self.menu_prompt.choose(disciplines)
topics: List[str] = [
quiz_item.topic for quiz_item in self.quiz_data
if quiz_item.discipline == chosen_discipline
]
chosen_topic: str = self.menu_prompt.choose(topics)
questions: List[QuizItem] = [
quiz_item for quiz_item in self.quiz_data
if quiz_item.topic == chosen_topic
]
QuestionPrompt(questions, self.app_settings).ask_question().show()
def test_insertion_length(self):
"""Tests that insertion mutations are of the correct length"""
cfg = AppSettings()
reps = 1000
deltas = []
for _ in range(0, reps):
dna = Chromosome()
init_length = len(dna.sequence)
dna.insertion()
deltas.append(len(dna.sequence) - init_length)
expected_delta = cfg.genetics.mutation_length
var = nbinom.var(
1,
cfg.genetics.mutation_length / (1 + cfg.genetics.mutation_length))
conf_99 = ((var / reps)**(1 / 2)) * 4
observed_delta = (sum(deltas) / reps)
assert (expected_delta - conf_99) < observed_delta < (expected_delta +
conf_99)
def test_say_seconds(self):
config = AppSettings.create()
p = PersonalitySettings.create(config.get_personality_path())
v = VoiceLibrary(config, p)
self.assertEqual("", v.convert_seconds_to_saying(0)) # 0 seconds
self.assertEqual("1 second",
v.convert_seconds_to_saying(1)) # 45 seconds
self.assertEqual("45 seconds",
v.convert_seconds_to_saying(45)) # 45 seconds
self.assertEqual("1 minute",
v.convert_seconds_to_saying(60)) # 2 minutes
self.assertEqual("2 minutes",
v.convert_seconds_to_saying(120)) # 2 minutes
self.assertEqual(
"2 minutes and 3 seconds",
v.convert_seconds_to_saying(123)) # 2 minutes and 3 seconds
self.assertEqual("1 hour",
v.convert_seconds_to_saying(1 * 60 * 60)) # 1 hour
self.assertEqual("2 hours",
v.convert_seconds_to_saying(2 * 60 * 60)) # 2 hours
self.assertEqual("2 hours and 1 minute",
v.convert_seconds_to_saying(2 * 60 * 60 +
60)) # 2 hours
self.assertEqual(
"2 hours and 34 minutes",
v.convert_seconds_to_saying(2 * 60 * 60 +
34 * 60)) # 2 hours and 34 minutes
self.assertEqual("2 hours 1 minute and 1 second",
v.convert_seconds_to_saying(2 * 60 * 60 + 60 +
1)) # 2 hours
self.assertEqual("2 hours 34 minutes and 15 seconds",
v.convert_seconds_to_saying(
2 * 60 * 60 + 34 * 60 +
15)) # 2 hours 34 minutes and 15 seconds
self.assertEqual(
"2 hours and 15 seconds",
v.convert_seconds_to_saying(
2 * 60 * 60 + 15)) # 2 hours 34 minutes and 15 seconds
def test_substitutions_changes(self):
"""Test that substitions occur at the expected rate."""
cfg = AppSettings()
reps = 1000
deltas = []
for _ in range(0, reps):
seq = "a" * 100
dna = Chromosome(seq)
dna.substitutions()
deltas.append(sum(1 for a, b in zip(seq, dna.sequence) if a != b))
# Expand the conf_99 to compensate for repeated mutations in the same place
expected_delta = cfg.genetics.mutation_rate * 100 * \
(1 - 1/len(Chromosome.nucleotides()))
# Because there is a little slop around synonymous substitions I multiply
# the confidence by 10 just to limit the number of failing tests.
conf_99 = ((poisson.var(cfg.genetics.mutation_rate * 100) / 1000)
**(1 / 2)) * 10
observed_delta = sum(deltas) / reps
assert (expected_delta - conf_99) < observed_delta < (expected_delta +
conf_99)
def test_deletion_length(self):
"""Test that deletions return the correct averge length"""
cfg = AppSettings()
reps = 1000
deltas = []
for _ in range(0, reps):
dna = Chromosome()
init_length = len(dna.sequence)
dna.deletion()
deltas.append(init_length - len(dna.sequence))
expected_delta = cfg.genetics.mutation_length
var = nbinom.var(
1,
cfg.genetics.mutation_length / (1 + cfg.genetics.mutation_length))
# Because there is a little slop around short strings or positions near the
# end of the string, I multiply
# the confidence by 10 just to limit the number of failing tests.
conf_99 = ((var / reps)**(1 / 2)) * 10
observed_delta = sum(deltas) / reps
assert (expected_delta - conf_99) < observed_delta < (expected_delta +
conf_99)
import time
from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient
#Define some globals
GPIO.setmode(GPIO.BCM)
camera = RCamera() #Camera connected to camera pins
credentials: Credentials = Credentials()
device_client: IoTCClient = None #IoTHubDeviceClient.create_from_connection_string(credentials.get_credentail_info(CredentialInfo.connection_string))
start_time = datetime.now()
tfclassifier = TFClassify()
tfclassifier2 = TFClassify2()
log: logging.Logger = app_logger.get_logger()
log.info(f"TensorFlow took {datetime.now() - start_time} seconds to load")
modelTier = "tier1"
_app_settings = AppSettings()
_app_settings.ensure_label_folders_exist(modelTier)
modelTier2 = "tier2"
_app_settings2 = AppSettings()
_app_settings.ensure_label_folders_exist(modelTier2)
# Set the trigger word for setting a sub tier model lookup
_subTierTrigger = _app_settings.get_SubTierTrigger(modelTier)
_subTierTrigger2 = _app_settings2.get_SubTierTrigger(modelTier2)
_USE_TEST_MODE = False
_USE_BLOB_STORGE = False
#_app_settings = AppSettings()
#These commands are sent by IoT Central to the device
def nucleotides():
"""Returns all the nucleotides that can be used in a dna string"""
cfg = AppSettings()
return (cfg.genetics.behaviors + cfg.genetics.gene_delimiter +
cfg.genetics.receptor_delimiter + cfg.genetics.wildcards)
def setUpClass(cls):
if os.path.exists(AppSettings()._cacheRoot):
shutil.rmtree(AppSettings()._cacheRoot)
def cacheRoot(self):
return os.path.join(AppSettings().cacheRoot, self.category)
from app_settings import AppSettings
import iot_events.iot_commands as iot_commands
#Define some globals
GPIO.setmode(GPIO.BCM)
move_sensor = MotionSensor(17) #Motion Sensor control connected to GPIO pin 17
red_led = LED(18) #LED connected to GPIO pin 18
camera = RCamera() #Camera connected to camera pins
credentials: Credentials = Credentials()
device_client: IoTCClient = None #IoTHubDeviceClient.create_from_connection_string(credentials.get_credentail_info(CredentialInfo.connection_string))
start_time = datetime.now()
tfclassifier = TFClassify()
log:logging.Logger = app_logger.get_logger()
#print(f"TensorFlow took {datetime.now() - start_time} seconds to load")
log.info(f"TensorFlow took {datetime.now() - start_time} seconds to load")
_app_settings = AppSettings()
_app_settings.ensure_label_folders_exist()
_USE_TEST_MODE = False
#These commands are sent by IoT Central to the device
_IoT_Commands = {
'DownloadModel': iot_commands.iot_download_model,
'UploadImages': iot_commands.iot_upload_images,
'Blink': iot_commands.iot_blink
}
async def send_iot_message(message=""):
await device_events.send_iot_message(device_client, message)
def movement_detected():
global start_time, _USE_TEST_MODE
import time
from lobe import ImageModel
#from lobe.signature import Signature
from lobe.signature import ImageClassificationSignature
import lobe
from app_settings import AppSettings
modelTier = "tier1"
_app_settings = AppSettings()
sigpath = _app_settings.get_SignaturePath(modelTier)
#sig:Signature = Signature(sigpath)
sig: ImageClassificationSignature = ImageClassificationSignature(sigpath)
#sig:Signature = Signature('./tf_models_lite/tier1/signature.json')
model: ImageModel = ImageModel.load_from_signature(sig)
#test_model: ImageModel = ImageModel.load_from_signature(Signature('./tf_models_lite/sig.json'))
#model_not_a_bee: ImageModel = ImageModel.load()
'''
The TFClassify class (Tensor Flow Classifier), takes a TensorFlow model and allows you
to pass multiple images to it via the addImage() or addImages() methods. It then
returns the predicted classification of the images as a DICT array
{
'image': '<image_path_sent_to_classifier>',
'prediction': 'output_prediction_from_TensorFlow'>
}
'''
class TFClassify:
