def __train_epoch(self, epoch):
# Keep track of the batch number.
batch = 0
# Training loss is the cumulative loss across an epoch.
training_loss = 0
# Process all training data.
for images, labels in self.train_data:
# Increment the batch number.
batch += 1
if batch % self.validate_every == 0:
Logger.log(f"Epoch: {epoch}. Batch: {batch}. Training...", color='m')
# Train on the batch.
loss = self.__train_batch(images, labels)
training_loss += loss
if batch % self.validate_every == 0:
# Average the training loss across the number of batches of training we've done.
loss = training_loss / (batch)
Logger.log(f"Training loss: {loss:.3f}. Validating...", indent=1)
self.__validate()
# Save a checkpoint.
self.__create_checkpoint(epoch)
def __validate(self):
# Put model into evaluation mode, this stops dropout.
self.model.eval()
# Keep track of the batch number.
batch = 0
# Keep track of the validation loss so we can average over the number of batches and compare
# to our training loss.
validation_loss = 0
# Track how many we got right.
num_correct = 0
for images, labels in self.valid_data:
# Increment the batch number.
batch += 1
# Validate against the batch.
loss, correct = self.__validate_batch(images, labels)
validation_loss += loss
num_correct += correct
# Calculate the validation loss.
loss = validation_loss / batch
Logger.log(f"Validation loss: {loss:.3f}.", indent=1)
# Calculate the validation accuracy.
accuracy = 100 * num_correct / self.valid_data.num_samples()
Logger.log(f"Validation accuracy: {accuracy:.3f}%", indent=1)
# Put model back into training mode.
self.model.train()
def main(args):
logger = Logger(args.output_dir)
args.logger = logger
trainer = Trainer(args)
evaluator = Evaluator(trainer)
for i_epoch in range(0, args.epoch + 1):
# train
log_dict = {
'i_epoch': i_epoch,
'train_losses': [], # per batch
'test_bleus': []
} # per sample
trainer.train_one_epoch(log_dict)
# evaluation and logging
logger.log('%d th epoch' % i_epoch)
evaluator.bleu(log_dict)
evaluator.sample_translation()
log_dict_mean = {
'i_epoch': log_dict['i_epoch'],
'train_loss': np.mean(log_dict['train_losses']),
'test_bleu': np.mean(log_dict['test_bleus'])
}
logger.dump(log_dict_mean)
trainer.save_best(log_dict_mean)
logger.log('-' * 10)
def handle_channel_msg(self, data):
# normal msg doesn't contain subtype => F**K, normal msg contain subtype now.
#if data.get("subtype"):
# return
# filter mismatch channel
c_id = data.get("vchannel_id")
if c_id != self.bc_default_channel:
return
sender_id = ""
name = ""
# get sender
if data.get("subtype") == "robot":
sender_id = data.get("robot_id")
name = Cache.get_robot_true_name(sender_id)
else:
sender_id = data.get("uid")
name = Cache.get_user_en_name(sender_id)
# filter sender
if sender_id in self.id_filter:
Logger.log("sender %s (%s) in the filter list, abort msg" % (name, sender_id))
return
msg = data.get("text")
# filter msg
if msg.startswith(self.msg_enable_pre):
msg = msg.split(self.msg_enable_pre, 1)[-1:][0]
self.send_irc_msg(name, msg)
else:
Logger.log("bc msg (%s) was not the standardized format, abort forwarding" % (msg))
def send_ping(self, ws):
msg_id = 0
while not self.exit_all:
try:
msg = '{"type":"ping","call_id":%d}' % msg_id
Logger.log_bc_ws(">>> %s" % msg)
ws.send(msg)
msg_id += 1
time.sleep(5)
except Exception as exc:
Logger.log("[send_ping]catch exception: %s" % str(exc))
break
def start_server(self):
api = BC_API()
api.login()
ws_url = api.get_ws_url()
ws = create_connection(ws_url)
Logger.log("connected to bc server")
# send ping thread
threading.Thread(target=self.send_ping, args=(ws, )).start()
# loop worker
self.server_loop(ws)
def server_loop(self, ws):
while not self.exit_all:
result = ws.recv()
if len(result):
self.connect_live = True
data = json.loads(result)
Logger.log_bc_ws("<<< %s" % result)
self.handle_msg(data)
else:
Logger.log("recv empty msg, connected: ", ws.connected)
if not ws.connected:
Logger.log("**=** recv empty msg, ws conn may be kicked by bc server")
break
def exe(command):
if not len(command):
return False
try:
process = subprocess.Popen([command],
stdout=subprocess.PIPE,
shell=True)
(out, error) = process.communicate()
out = out.decode("utf-8")
if len(out):
Logger.log(out)
if error:
Logger.error(error)
except Exception as error:
Logger.error(error)
def serve(self):
settings = dict(
template_path=rel('./web/templates'),
static_path=rel('./web'),
debug=True
)
app = Application([
(r"/", Homepage, dict(kiwi=self.kiwi)),
(r"/emotion", Emotions, dict(kiwi=self.kiwi)),
(r"/freehand", Freehand, dict(kiwi=self.kiwi)),
(r"/independant", Independant, dict(kiwi=self.kiwi)),
(r"/settings", Settings, dict(kiwi=self.kiwi)),
], **settings)
http_server = tornado.httpserver.HTTPServer(app)
port = config.get('server', 'port')
http_server.listen(port=port)
Logger.log("... kiwi GUI is serving under 127.0.0.1:{}.".format(port))
class ProcWrapper:
def __init__(self, args, id, logger_name, sleep_timeout=80):
self.__args = args
self.__id = id
self.__name = logger_name
self.__sleep_time = 0
self.__last_sleep_time = 0
self.__sleep_timeout = sleep_timeout
self.proc_logger = Logger(name=self.__name, color=True)
def run(self, shell=True):
self.__process = psutil.Popen(self.__args, shell=shell)
self.proc_logger.log("%s proc start with pid %s" % (self.__name, self.__process.pid))
@property
def is_run(self):
status = self.__process.status()
if status == psutil.STATUS_SLEEPING:
if self.__last_sleep_time:
self.__sleep_time += time() - self.__last_sleep_time
self.__last_sleep_time = time()
# self.proc_logger.log_console("Sleep time: %s" % self.__sleep_time, status='!')
else:
self.__last_sleep_time = 0
self.__sleep_time = 0
# if self.__name == "Consumer" and status != psutil.STATUS_SLEEPING:
# self.proc_logger.log_console("Status %s" % status, status='!')
if status == psutil.STATUS_STOPPED or status == psutil.STATUS_DEAD or status == psutil.STATUS_ZOMBIE or \
self.__sleep_time > self.__sleep_timeout:
return False
return True
def stop(self):
try:
self.__process.terminate()
except OSError:
pass
def __checking_live_thread(self):
while True:
time.sleep(20)
Logger.log("checking server live...")
if self.bc_server.connect_live:
Logger.log("server is alive")
self.bc_server.connect_live = False
else:
Logger.log("server is not alive, restart server...")
self.__restart()
class RunManager:
def __init__(self, consumer_sh=None, producer_sh=None):
self.run_logger = Logger(name="RunManager", logfile="data/logs/runmanager.log")
self.__producers_list = []
self.__consumers_list = []
self.__consumer_sh_path = consumer_sh
self.__producer_sh_path = producer_sh
def start(self, producers_count, consumers_count, from_systemd=False):
self.run_logger.log("Start producers. Count of producers %s" % producers_count)
if from_systemd:
fd = open("data/systemd/consumer.service")
consumer_data = fd.read()
fd.close()
fd = open("data/systemd/producer.service")
producer_data = fd.read()
fd.close()
for index in range(producers_count):
fd = open("/etc/systemd/system/producer%s.service" % (index + 1), "w")
fd.write(producer_data)
fd.close()
os.system("systemctl start producer%s.service" % (index + 1))
for index in range(consumers_count):
fd = open("/etc/systemd/system/consumer%s.service" % (index + 1), "w")
fd.write(consumer_data)
fd.close()
os.system("systemctl start consumer%s.service" % (index + 1))
return
if self.__consumer_sh_path is None or self.__producer_sh_path is None:
self.run_logger.log_console("Shell script does not set", status='~')
return
for index in range(producers_count):
pr = ProcWrapper([self.__producer_sh_path], index, "Producer")
pr.run(shell=False)
self.__producers_list.append(pr)
for index in range(consumers_count):
pr = ProcWrapper([self.__consumer_sh_path], index, "Consumer")
pr.run(shell=True)
self.__consumers_list.append(pr)
while True:
delete_list = []
for proc in self.__consumers_list:
if not proc.is_run:
proc.proc_logger.log("Proc end")
proc.stop()
delete_list.append(proc)
for proc in delete_list:
self.__consumers_list.remove(proc)
to_run = consumers_count - len(self.__consumers_list)
for index in range(to_run):
pr = ProcWrapper([self.__consumer_sh_path], index, "Consumer")
pr.run(shell=True)
self.__consumers_list.append(pr)
def stop(self, producers_count, consumers_count, from_systemd=True):
self.run_logger.log("Stop producers. Count of producers %s" % producers_count)
if from_systemd:
for index in range(producers_count):
os.system("systemctl stop producer%s.service" % (index + 1))
for index in range(consumers_count):
os.system("systemctl stop consumer%s.service" % (index + 1))
def delete(self, producers_count, consumers_count, from_systemd=True):
self.run_logger.log("Delete producers and counters")
if from_systemd:
for index in range(producers_count):
os.system("rm /etc/systemd/system/producer%s.service" % (index + 1))
for index in range(consumers_count):
os.system("rm /etc/systemd/system/consumer%s.service" % (index + 1))
class MNISTF1Trainer:
def __init__(self, config):
self.config = config
self.device = torch.device('cuda' if torch.cuda.
is_available() else 'cpu')
self.logger = Logger(config["stats folder"])
def _load_checkpoint(self, model):
start_epochs = 0
if self.config["checkpoint path"]:
start_epochs = int(Path(self.config["checkpoint path"]).stem)
model.load_state_dict(
torch.load(Path(self.config["checkpoint path"])))
return start_epochs
def _save_checkpoint(self, epoch, model, retain=False):
checkpoint_filename = str(epoch + 1) + ".ckpt"
checkpoint_path = Path(self.config["checkpoints folder"],
checkpoint_filename)
torch.save(model.state_dict(), checkpoint_path)
if not retain:
prev_checkpoint_filename = str(epoch) + ".ckpt"
prev_checkpoint_path = Path(self.config["checkpoints folder"],
prev_checkpoint_filename)
if os.path.exists(prev_checkpoint_path):
os.remove(prev_checkpoint_path)
def run(self):
# Training set
trainset = MNISTF1(
self.config["dataset path"], train=True, download=True)
train_loader = DataLoader(
trainset, shuffle=True, batch_size=self.config["batch size"])
# Validation set
valset = MNISTF1(
self.config["dataset path"], train=False, download=True)
val_loader = DataLoader(valset, batch_size=self.config["batch size"])
# Model
model = FFNetF1().to(self.device)
# Load checkpoint if exists
start_epochs = self._load_checkpoint(model)
# Constants
num_positives = train_loader.dataset.num_positives
# Primal variables
tau = torch.rand(
len(train_loader.dataset), device=self.device, requires_grad=True)
eps = torch.rand(1, device=self.device, requires_grad=True)
w = torch.rand(1, device=self.device, requires_grad=True)
# Dual variables
lamb = torch.zeros(len(train_loader.dataset), device=self.device)
lamb.fill_(0.001)
mu = torch.zeros(1, device=self.device)
mu.fill_(0.001)
gamma = torch.zeros(len(train_loader.dataset), device=self.device)
gamma.fill_(0.001)
# Primal Optimization
var_list = [{
"params": model.parameters(),
"lr": self.config["learning rate"]
}, {
"params": tau,
"lr": self.config["eta_tau"]
}, {
"params": eps,
"lr": self.config["eta_eps"]
}, {
"params": w,
"lr": self.config["eta_w"]
}]
optimizer = torch.optim.SGD(var_list)
# Dataset iterator
train_iter = iter(train_loader)
# Count epochs and steps
epochs = 0
step = 0
# Cache losses
total_loss = 0
total_t1_loss = 0
total_t2_loss = 0
# Train
for outer in tqdm(range(start_epochs, self.config["n_outer"])):
model.train()
for inner in tqdm(range(self.config["n_inner"])):
step += 1
# Sample
try:
X, Y = next(train_iter)
except StopIteration:
train_iter = iter(train_loader)
X, Y = next(train_iter)
# Forward computation
X, Y = X.to(self.device), Y.to(self.device)
y0_, y1_ = model(X)
y0 = Y[:, 0]
y1 = Y[:, 1]
i = Y[:, 2]
# Compute loss
t1_loss = F.cross_entropy(y0_, y0)
t2_loss = lagrange(num_positives, y1_, y1, w, eps, tau[i],
lamb[i], mu, gamma[i])
loss = t1_loss + (self.config["beta"] * t2_loss)
# Store losses for logging
total_loss += loss.item()
total_t1_loss += t1_loss.item()
total_t2_loss += t2_loss.item()
# Backpropagate
loss.backward()
optimizer.step()
optimizer.zero_grad()
# Project eps to ensure non-negativity
eps.data = torch.max(
torch.zeros(1, dtype=torch.float, device=self.device),
eps.data)
# Log and validate per epoch
if (step + 1) % len(train_loader) == 0:
epochs += 1
# Log loss
avg_loss = total_loss / len(train_loader)
avg_t1_loss = total_t1_loss / len(train_loader)
avg_t2_loss = total_t2_loss / len(train_loader)
total_loss = 0
total_t1_loss = 0
total_t2_loss = 0
self.logger.log("epochs", epochs, "loss", avg_loss)
self.logger.log("epochs", epochs, "t1loss", avg_t1_loss)
self.logger.log("epochs", epochs, "t2loss", avg_t2_loss)
# Validate
model.eval()
total = 0
correct = 0
with torch.no_grad():
for X, Y in val_loader:
X, Y = X.to(self.device), Y.to(self.device)
y0_, y1_ = model(X)
y0 = Y[:, 0]
y1 = Y[:, 1]
_, predicted = torch.max(y0_.data, 1)
total += y0.size(0)
correct += (predicted == y0).sum().item()
accuracy = 100. * correct / total
self.logger.log("epochs", epochs, "accuracy", accuracy)
# Graph
self.logger.graph()
# Checkpoint
self._save_checkpoint(epochs, model)
# Dual Updates
with torch.no_grad():
mu_cache = 0
lamb_cache = torch.zeros_like(lamb)
gamma_cache = torch.zeros_like(gamma)
for X, Y in tqdm(train_loader):
# Forward computation
X, Y = X.to(self.device), Y.to(self.device)
_, y1_ = model(X)
y1 = Y[:, 1]
i = Y[:, 2]
# Cache for mu update
mu_cache += tau[i].sum()
# Lambda and gamma updates
y1 = y1.float()
y1_ = y1_.view(-1)
lamb_cache[i] += (
self.config["eta_lamb"] * (y1 * (tau[i] - (w * y1_))))
gamma_cache[i] += (
self.config["eta_gamma"] * (y1 * (tau[i] - eps)))
# Update data
mu.data += self.config["eta_mu"] * (mu_cache - 1)
lamb.data += lamb_cache
gamma.data += gamma_cache
def _log(self, log_message, log_type='info', log_data=None):
Logger.log(QPidController.subsys, log_message, log_type, log_data)
class ProxyManager(Cacheable):
def __init__(self, config, timeout=None, cache_url=None):
self.__config = config
self.__timeout = timeout if timeout else 5
self.__logger = Logger(name="ProxyManager", color=True)
self.__check_counter = 0
self.__check_progress_bar = None
self.__check_proxy_count = 0
self.__proxy_load_time = 0
self.__pool = []
super().__init__(cache_url)
def crawl_proxy(self, no_check=False):
db = DBWorker(self.__config)
db.run_sql("TRUNCATE TABLE proxy;")
self.__logger.log_console("Fetch proxy from %s" %
self.__config["producer"]["proxy_url"],
status='+')
proxy_data = None
try:
proxy_data = [
x.rstrip("\n\r") for x in requests.get(
self.__config["producer"]["proxy_url"]).text.split("\n")
]
except requests.exceptions.ReadTimeout:
self.__logger.log(
"Proxy url request. Timeout",
status="~",
mformat=["%s" % self.__config["producer"]["proxy_url"]])
return False
except requests.exceptions.ConnectionError:
self.__logger.log(
"Connection Error to proxy url. Down",
status="~",
mformat=["%s" % self.__config["producer"]["proxy_url"]])
return False
except requests.exceptions.InvalidHeader:
self.__logger.log(
"Invalid header from proxy server. Invalid header return",
status="~",
mformat=["%s" % self.__config["producer"]["proxy_url"]])
return False
except requests.exceptions.ContentDecodingError:
self.__logger.log(
"Proxy url request. Decode error",
status="~",
mformat=["%s" % self.__config["producer"]["proxy_url"]])
except IOError:
self.__logger.log(
"Can't open proxy fetch file",
status="~",
mformat=["%s" % self.__config["producer"]["proxy_url"]])
return False
self.__logger.log_console("Fetch %s proxies" % len(proxy_data),
status='+')
if no_check:
self.__check_proxy_count = len(proxy_data)
workers = []
for chunk in chunks(proxy_data, 10000):
pr = Process(target=to_db, args=(
chunk,
self.__config,
))
pr.start()
workers.append(pr)
self.__logger.log_console("Processes created. Count %s" %
(len(workers)),
status='+')
self.__check_progress_bar = self.__logger.progress_bar(status='?')
self.__check_proxy_count = len(proxy_data)
next(self.__check_progress_bar)
for worker in workers:
worker.join()
self.__check_counter += 1000
if self.__check_counter % math.floor(
self.__check_proxy_count / 100) == 0:
next(self.__check_progress_bar)
try:
next(self.__check_progress_bar)
except StopIteration:
pass
self.__logger.log_console("No check data saved")
return True
self.__logger.log_console("Check proxies", status='+')
checked_proxy = 0
self.__check_progress_bar = self.__logger.progress_bar(status='?')
self.__check_proxy_count = len(proxy_data)
next(self.__check_progress_bar)
loop = asyncio.get_event_loop()
for chunk in chunks(proxy_data, 100):
results = loop.run_until_complete(self._check_many(chunk, loop))
for item in results[0]:
result_check_record = item.result()
if result_check_record["result"]:
db.run_sql(sql_insert_proxy, [
result_check_record["ip"], result_check_record["port"],
result_check_record["elapsed"]
])
checked_proxy += 1
try:
next(self.__check_progress_bar)
except StopIteration:
pass
self.__logger.log_console("Checked %s/%s" %
(checked_proxy, len(proxy_data)))
return True
async def _check_many(self, proxies, loop):
tasks = [
loop.create_task(self.async_check(proxy)) for proxy in proxies
]
return await asyncio.wait(tasks)
async def async_check(self, proxy):
start_time = time.time()
try:
ip, port = proxy.split(":")
pr_connector = ProxyConnector(remote_resolve=True,
verify_ssl=False)
with aiohttp.ClientSession(connector=pr_connector, request_class=ProxyClientRequest) as session, \
aiohttp.Timeout(self.__timeout):
async with session.get('http://www.httpbin.org/get?show_env=1',
proxy="socks5://%s:%s" %
(ip, port)) as resp:
await resp.json()
result_dict = {
'ip': ip,
'port': port,
'result': True,
'elapsed': time.time() - start_time,
'exc': None
}
except BaseException as exc:
result_dict = {
'ip': None,
'port': None,
'result': False,
'elapsed': -1,
'exc': exc
}
self.__check_counter += 1
if self.__check_counter % math.floor(
self.__check_proxy_count / 100) == 0:
next(self.__check_progress_bar)
return result_dict
def __load_proxies(self):
db = DBWorker(self.__config)
with db.cursor() as cursor:
cursor.execute("select*from proxy order by delay;")
self.__proxy_load_time = time.time()
return cursor.fetchall()
def get(self):
"""
Returns random proxy from the pool.
"""
if not self.__pool or time.time(
) - self.__proxy_load_time > 30 * ONE_MINUTE:
while True:
pool = self.__load_proxies()
self.__logger.log('Load proxy complete . Length %s' %
len(pool))
if len(pool) > 1000:
self.__pool = pool
break
time.sleep(ONE_MINUTE)
result = random.choice(self.__pool)
return result
def remove_from_pool(self, proxy):
self.__pool.remove(proxy)
def get_all(self):
"""
Returns proxy, real IP address, timezone & language from the pool.
"""
while True:
try:
_, ip, port, delay = self.get()
answer = requests.get('http://httpbin.org/get?show_env=1',
proxies=dict(http="socks5://%s:%s" %
(ip, port)),
timeout=self.__timeout).json()
check_proxy = requests.get('http://www.iconspedia.com/',
proxies=dict(http="socks5://%s:%s" %
(ip, port)),
timeout=5)
proxy = "%s:%s" % (ip, port)
if "http" not in proxy:
proxy = "http://" + proxy
ip_address = answer["origin"]
timezone, country, language = self.get_timezone_and_language(
ip_address)
if country in BAD_COUNTRIES:
raise BadProxy
self.__logger.log('Chosen proxy: %s with external ip %s' %
(proxy, ip_address))
#open("/root/clickbot2/check_connect/good_"+str(os.getpid())+".txt","w")
return proxy, ip_address, timezone, language
except BadProxy:
#open("/root/clickbot2/check_connect/bad_proxy_error_"+str(os.getpid())+".txt","w")
print("Bad proxy")
pass
except requests.exceptions.ReadTimeout:
#open("/root/clickbot2/check_connect/timeout_error_"+str(os.getpid())+".txt","w")
print("Timeout")
pass
except requests.exceptions.ConnectionError:
#open("/root/clickbot2/check_connect/connection_error_"+str(os.getpid())+".txt","w")
print("Connection error")
pass
except requests.exceptions.InvalidHeader:
#open("/root/clickbot2/check_connect/header_error_"+str(os.getpid())+".txt","w")
print("InvalidHeader")
pass
except requests.exceptions.ContentDecodingError:
#open("/root/clickbot2/check_connect/decoding_error_"+str(os.getpid())+".txt","w")
print("Decoding error")
pass
@cache()
def get_timezone_and_language(self,
ip_address,
default_time_zone_offset=0,
default_language='en'):
"""
Returns timezone for IP address or default if nothing was found.
"""
db = DBWorker(self.__config)
value = convert_ip_address(ip_address)
with db.cursor() as cursor:
cursor.execute(
'SELECT time_zone_offset, country_code, language FROM ip_data WHERE ip_range @> %s::BIGINT',
[value])
try:
time_zone_offset, country, language = cursor.fetchone()
if time_zone_offset is None:
time_zone_offset = default_time_zone_offset
if language is None:
language = default_language
self.__logger.log('Timezone offset for %s: %s' %
(ip_address, time_zone_offset))
self.__logger.log('Language for %s: %s' %
(ip_address, language))
return time_zone_offset, country, language
except (ProgrammingError, TypeError) as ex:
# No results to fetch.
return default_time_zone_offset, None, default_language
def _log(self, log_message, log_type='info', log_data=None):
Logger.log(KPSerialInterface.subsys, log_message, log_type, log_data)
def operate_independant(self):
Logger.log("Alright, then i'll do what i want :-P")
return 500
iterations[-1].target_number_of_segments = INITIAL_TARGET_NUMBER_OF_SEGMENTS
for this_bin in iterations[-1].bins:
this_bin.target_number_of_segments = iterations[-1].target_number_of_segments
this_bin.sample_region = iterations[-1].isInSampleRegion(this_bin.getCoordinateIds())
#TODO: check if all files are present
else:
iterations.append(initiate.createInitialIteration(STARTING_STRUCTURES,
WORKDIR,
JOBNAME,
INITIAL_TARGET_NUMBER_OF_SEGMENTS,
INITIAL_BOUNDARIES,
INITIAL_SAMPLE_REGION,
md_module,
START_BIN_COORDINATE_IDS))
logger.log(iterations[0], CONFIGFILE)
# Create an instance of the resampling module
resampler = resampling.Resampling(md_module, RESAMPLING_MODE, CLOSEST_MERGE_THRESHOLD,
PRIMARY_COORDINATE, SPLIT_FORWARD_NUMBER_OF_CHILDREN,
SPLIT_REGION, FRONT_INTERVAL)
# Handle the deletion/compression of MD output files
cleaner = cleanup.Cleanup(md_module, NUMBER_OF_THREADS, COMPRESS_ITERATION,
COMPRESS_CLOSEST_MASK, KEEP_COORDS_FREQUENCY,
KEEP_COORDS_SEGMENTS, DEBUG)
#############################
# Main Loop #
#############################
for iteration_counter in range(iterations[-1].getId() + 1, MAX_ITERATIONS + 1):
from lib.logger import Logger
from lib.gps import GPSReader
def drone_signal():
input()
return True
def drone_next_position():
print("Going to next position")
if __name__ == '__main__':
file_path = os.path.dirname(__file__)
file_path = os.path.abspath(os.path.join(file_path, "log.log"))
log = Logger(file_path)
log.log('Initializing objects', level=1, days_to_remain=5)
imu = ImuReader()
lidar = Lidar()
image_manager = ImageManager()
db_manager = DatabaseManager()
gps = GPSReader()
savePath = os.path.dirname(__file__)
picID = "test_"
iteration = 1
log.log('Objects successfully initialized', level=1, days_to_remain=5)
while True:
if drone_signal() is True:
log.log('Drone signal received', level=1, days_to_remain=5)
status = image_manager.aquire_picture(picID, savePath, iteration)['status']
#!/usr/bin/env python3
from lib.checks import Checker
from lib.logger import Logger
from lib.system_functions import System
# Initialize Checker
checker = Checker()
# Check python version
checker.check_python_version()
# Initialize Logger
logger = Logger()
# Initialize System Functions
system = System()
# Start the bot
if __name__ == "__main__":
logger.log()
system.quit()
def _log(self, log_message, log_type='info', log_data=None):
Logger.log(KPMissionProgramsDatabase.subsys, log_message, log_type,
log_data)
def _log(self, log_message, log_type='info', log_data=None):
Logger.log(KPSerialInterface.subsys, log_message, log_type, log_data)
def __init__(self, start_mode):
Logger.log('Initializing the kiwi system, press Ctrl-C to quit...')
SoundEffect.play('hello')
self.operation_mode = config.get('kiwi', 'start_mode')
def set_operation_mode(self, mode, command=None):
Logger.log('Received order for operation-mode change. Going to: ' +
mode + ' mode...')
self.operation_mode = mode
self.command_to_execute = command
def __init__(self):
self.logger = Logger()
self.main_loop = MainLoop()
self.usb = Usb()
self.action = Action()
Logger.log('Init RemoteApp', True)
def _log(self, log_message, log_type='info', log_data=None):
Logger.log(KPFlightController.subsys, log_message, log_type, log_data)
def operate_on_command(self):
Logger.log("Yes, master. I'm executing your order: " +
self.command_to_execute)
self.operation_mode = 'waiting_for_command'
return 500
def __create_checkpoint(self, epoch):
filepath = os.path.join(self.save_dir, "checkpoint_{}.pth".format(epoch))
Checkpoint.create(self.model, filepath)
Logger.log('Model saved.', color='r')
def _log(self, log_message, log_type='info', log_data=None):
Logger.log(KPMissionProgramsDatabase.subsys, log_message, log_type, log_data)
