def __init__(self,
inputs,
threshold=0,
weight=None,
activation=None,
input_values=None):
""" initialize the Neuron """
Logger.log("initializing neuron with {0} inputs".format(inputs))
self.weights = []
self.input_values = []
if activation == None:
self.activate = self.__activateSign
else:
self.activate = activation
self.threshold = threshold
w = 0
if (weight == None):
# Set all the weights and threshold levels of the network to random numbers uniformly distributed inside a small range (Haykin, 1999):
# meaning only one random number / number of inputs
w = random.uniform(-0.5, 0.5)
w = round(w / float(inputs), 2)
else:
w = round(weight / float(inputs), 2)
for x in range(inputs):
self.weights.append(w)
def __init__(self, layers, threshold=0):
""" initialize a new network
:param layers: list containing number of neurons in each layer with optionally associated weights
"""
self.layers = []
self.threshold = threshold
layer_number = 0
self.outputs = []
# initialize input layer
input_layer = layers[0]
inputs = 1
if isinstance(input_layer, int):
Logger.log(
"appending {0} neurons to input layer".format(input_layer),
"green")
self.layers.append([])
for x in range(input_layer):
self.layers[0].append(Neuron(inputs, self.threshold, 0))
# initialize all hidden and output layers
inputs = len(self.layers[0])
for (layer_number, layer) in enumerate(layers[1:]):
if isinstance(layer, int):
Logger.log(
"appending {0} neurons to layer {1}".format(
layer, layer_number + 1), "green")
self.layers.append([])
for x in range(layer):
self.layers[-1].append(Neuron(inputs, self.threshold))
inputs = layer
def retrieve(self, probe):
bipolar = make_bipolar(probe)
flat_probe = [item for sublist in bipolar for item in sublist]
Logger.log("retrieving probe:{0}".format(probe))
# stuff with 0's - incomplete information
while len(flat_probe) < len(self.neurons):
flat_probe.append(0)
Logger.log("probe:{0}".format(flat_probe))
# initial state
counter = 0
y = flat_probe
test = []
while test != self.state_vector:
Logger.log("state vector:{0} is not equal to retrieval:{1}".format(unmake_bipolar(self.state_vector, len(charset[probe[0]])), unmake_bipolar(y, len(charset[probe[0]]))))
import random
r = random.randint(0, len(self.state_vector)-1)
self.neurons[r].retrieve(y)
y = self.state_vector
test = [neuron.test(self.state_vector) for neuron in self.neurons]
counter += 1
Logger.log("stable state after {1}:epochs retrieved:{0}".format(self.state_vector, counter))
Logger.log("stable state unbipolarized:{0}".format(unmake_bipolar(self.state_vector, len(charset[probe[0]]))))
def weight_train(self, desired, layer, output):
"""
calculates the error gradient
desired is either the desired pattern or the error gradient
"""
if output:
self.error_signal = desired - self.output
self.error_gradient = self.output * (
1 - self.output) * self.error_signal
# dont apply them yet, we need them for further backpropagation
self.weight_corrections = [
self.learning_rate * y.output * self.error_gradient
for y in layer
]
else:
self.error_signal = desired
self.error_gradient = self.output * (
1 - self.output) * self.error_signal
self.weight_corrections = [
self.learning_rate * y.output * self.error_gradient
for y in layer
]
Logger.log(
"trained output Neuron to signal:{0}, gradient:{1} and delta:{2}".
format(self.error_signal, self.error_gradient,
self.weight_corrections))
def initialize():
Logger.createNewLog(purgeLogs)
# GUI already initialized on import resolution
Client.startClient()
Server.startServer()
# ControllerClient.startControllerForwarding()
Logger.log("DriverStation initialized")
def handleConn(typeOfMessage: messageType, data):
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
attemptedConnections = 0
while True:
try:
s.connect((IP, PORT))
except ConnectionRefusedError:
# if connection refused (server not online, wait for it to start) timeout = 3 sec (NOTE: if experiencing memory/CPU intensive ops this is very memory intensive (1 thread per frame of camera :^)) )
attemptedConnections += 1
if (attemptedConnections >= 3):
Logger.log(
f"Connection to {(IP, PORT)} refused. Is the server online?"
)
return
time.sleep(1)
continue
else:
break
if (typeOfMessage != messageType.camera):
# if it is not a camera, it is string
s.sendall(typeOfMessage.value.encode() +
messageEncoder.encode(data) + EOM)
else:
s.sendall(typeOfMessage.value.encode() +
imageEncoder.encode(data[0], data[1]))
def __init__(self, layers, learning_rate=1, threshold=None):
Logger.log("initializing MLP with {0} layers".format(len(layers)))
# sum of all neurons in the mlp
self.F = sum(layers)
self.layers = [
Layer(neurons, self.F, learning_rate, threshold)
for neurons in layers
]
def __combineInputs(self, inputs):
""" lineary combine the neurons input """
x = sum(
int(value) * float(self.weights[index])
for (index, value) in enumerate(inputs))
x -= self.threshold
Logger.log("activation x = " + str(x) + ", threshold: " +
str(self.threshold) + ", weight: " + str(self.weights))
return x
def learn(self, input_vector, neuron_index, state):
""" generalized hebbian learning rule """
for j, weight in enumerate(self.weights):
if j != neuron_index:
dw = 0
if state == input_vector[j]: dw = 1
else: dw = -1
self.weights[j] += dw
Logger.log("for weight i:{0} j:{1} - dw = {2} and weight = {3}".format(neuron_index, j, dw, self.weights[j]))
def startControllerServer():
Logger.log("Controller Server Started")
while True:
try:
doServer()
except ConnectionAbortedError:
Logger.logError(format_exc())
time.sleep(2)
continue
def activate(self, pattern):
""" activates the layer using the patterns """
for i, neuron in enumerate(self.neurons):
# input layer
if not neuron.weights:
neuron.output = pattern[i]
# processing layers
else:
neuron.activate(pattern)
Logger.log("activated layer: {0}".format(self.output))
def activate(self, pattern):
""" activates the layer using the patterns """
for i, neuron in enumerate(self.neurons):
# input layer
if not neuron.weights:
neuron.output = pattern[i]
# processing layers
else:
neuron.activate(pattern)
Logger.log("activated layer: {0}".format(self.output))
def calibrate(self):
Logger.log(
"Calibrating IMU, ensure this occured at a time when robot is completely still"
)
last = time.time()
while (not self.BNO055.calibrated):
if (time.time() - last >= 1):
results = self.BNO055.calibration_status
print(
f"\n\nSys status: {results[0]}\nGyro status: {results[1]}\nAccel status: {results[2]}\nMagn status: {results[3]}"
)
pass
def initialize():
"""Initialize all relevant robot components/tools here"""
Logger.createNewLog(purgeLogs)
# create daemons
# Client.startClient()
# Server.startServer()
# Cameras.start()
# initialize all components here
components.append(Drive())
components.append(Manipulator())
Logger.log("Components initialized")
def subscribe(fn): # create wrapper function to manipulate wrapped fn
if(not inspect.iscoroutinefunction(fn)): # ensure function has been defined as async def name(): ... (could add functionality for both but would add like 50 lines and its easy enough to write an asynchronous function that does not need to wait on anything :P)
raise SubscriptionException("Cannot subscribe synchronous function to asynchronous event system")
if not event_type in subscribers: # add subscribed event to subscription tracker
subscribers[event_type] = []
if fn in subscribers[event_type]: # ensure no function is subscribed twice
try:
raise SubscriptionException("Cannot subscribe function twice")
except SubscriptionException:
Logger.logError(format_exc())
return fn
subscribers[event_type].append(fn) # add function to subscribed event in tracker
Logger.log(fn, "successfully subscribed to event " + event_type.__name__) # DEBUG log
return fn
def activate(self, inputs=None):
""" calculate the network's output, this is the first step in backpropagation learning """
if inputs != None:
self.assignInput(inputs)
inputs = None
for (index, layer) in enumerate(self.layers):
self.outputs = []
self.outputs.extend(neuron.output(inputs) for neuron in layer)
inputs = self.outputs
Logger.log("layer {0} output = {1}".format(index, self.outputs))
return self.outputs
def learn(self, M, epochs=1, learning_rate = .1, forgetting_factor = .01):
"""
a method for network learning
M - the patterns
"""
for e in range(epochs):
for m in M:
for i, neuron in enumerate(self.neurons):
bipolar = make_bipolar(m)
flat_input = [item for sublist in bipolar for item in sublist]
neuron.learn(flat_input, i, flat_input[i])
Logger.log("I've learned:")
for i, neuron in enumerate(self.neurons):
Logger.log("w{0}: {1}".format(i, neuron.weights))
def __init__(self, F, learning_rate, threshold):
"""
F - number of all neurons in the network
"""
self.weights = []
import random
if not threshold:
self.threshold = random.uniform(-2.4 / F, 2.4 / F)
else:
self.threshold = threshold
self.output = None
self.learning_rate = learning_rate
Logger.log("initializing Neuron")
def __init__(self, F, learning_rate, threshold):
"""
F - number of all neurons in the network
"""
self.weights = []
import random
if not threshold:
self.threshold = random.uniform(-2.4/F, 2.4/F)
else:
self.threshold = threshold
self.output = None
self.learning_rate = learning_rate
Logger.log("initializing Neuron")
def weight_train(self, desired, layer, output):
"""
calculates the error gradient
desired is either the desired pattern or the error gradient
"""
if output:
self.error_signal = desired - self.output
self.error_gradient = self.output * (1 - self.output) * self.error_signal
# dont apply them yet, we need them for further backpropagation
self.weight_corrections = [self.learning_rate * y.output * self.error_gradient for y in layer]
else:
self.error_signal = desired
self.error_gradient = self.output * (1 - self.output) * self.error_signal
self.weight_corrections = [self.learning_rate * y.output * self.error_gradient for y in layer]
Logger.log("trained output Neuron to signal:{0}, gradient:{1} and delta:{2}".format(self.error_signal, self.error_gradient, self.weight_corrections))
def post_event(event_type: Event, *args, **kwargs):
"""Post event and notify subscribers"""
if not event_type in subscribers:
print(f"Event '{event_type}' was posted, but either does not exist or has no subscribers")
return
# create list of coroutines to run
coros:list[Coroutine] = []
for fn in subscribers[event_type]:
try:
coros.append(fn(*args, **kwargs)) # create coroutines and add to list
except TypeError: # if type error happens, attempted to create coroutine with arguments not accepted by it (not a big deal, log and move on)
Logger.log(f"Attempted to create coroutine from function {fn} with arguments: {args} , {kwargs}")
continue
res = asyncio.run(__doCoros(coros)) # run all coroutines
for i, result in enumerate(res):
if result is not None: # if coroutine returned value, log and move on
Logger.log(f"Function: {subscribers[event_type][i]} returned {result} when called on event bus")
def initialize(self):
""" initializes the neuron weights """
for i, layer in enumerate(self.layers):
try:
layer.assign_weights(self.layers[i+1], self.F)
Logger.log("assigned weights to layer {0}".format(i+2))
except IndexError:
Logger.log("finished assigning weights")
for i, layer in enumerate(self.layers):
Logger.log("initialized layer {0}".format(i+1))
for j, n in enumerate(layer.neurons):
Logger.log("neuron {0}:{1} weights {2}".format(i+1, j+1, n.weights))
def __init__(self):
# Grab the relevant servos from the map
self.elbow_servo = MANIP_SERVOS["MANIP_ELBOW_SERVO"]
self.elbow_servo2 = MANIP_SERVOS["MANIP_ELBOW_SERVO_2"]
self.level_servo = MANIP_SERVOS["MANIP_LEVEL_SERVO"]
self.wrist_servo = MANIP_SERVOS["MANIP_WRIST_SERVO"]
self.clamp_servo = MANIP_SERVOS["MANIP_CLAMP_SERVO"]
self.enabled = False
self.chicken = False
self.clamp = False
self.elbow_angle = 90
self.elbow_angle_old = 90
self.wrist_angle = 90
self.wrist_angle_old = 90
self.level_angle = 90
self.level_angle_old = 90
self.elbow_tune = 11
self.elbow_tune2 = 12
self.level_tune = 0
self.wrist_tune = 15
self.x_velocity = 0
self.y_velocity = 0
self.VELOCITY_SCALING_FACTOR = .1 # SUBJECT TO CHANGE
self.VELOCITY_IGNORE = .1 # Tunes how sensitive joystick is to changes
self.ELBOW_ANGLE_MAX = 180
self.ELBOW_ANGLE_MIN = 0
self.LEVEL_ANGLE_MAX = 180
self.LEVEL_ANGLE_MIN = 0
self.WRIST_ANGLE_MAX = 180
self.WRIST_ANGLE_MIN = 0
self.wrist_servo.angle = 90 + self.wrist_tune
self.elbow_servo.angle = 90 + self.elbow_tune
self.elbow_servo2.angle = 90 + self.elbow_tune2
self.level_servo.angle = 90 + self.level_tune
self.clamp_servo.angle = 85
Logger.log("MANIPULATOR CONSTRUCTED")
def initialize(self):
""" initializes the neuron weights """
for i, layer in enumerate(self.layers):
try:
layer.assign_weights(self.layers[i + 1], self.F)
Logger.log("assigned weights to layer {0}".format(i + 2))
except IndexError:
Logger.log("finished assigning weights")
for i, layer in enumerate(self.layers):
Logger.log("initialized layer {0}".format(i + 1))
for j, n in enumerate(layer.neurons):
Logger.log("neuron {0}:{1} weights {2}".format(
i + 1, j + 1, n.weights))
def test(self, fundamental_memories):
fundamental_memories.append("abcd.efg")
for fundamental_memory in fundamental_memories:
Logger.log("testing fundamental memory:{0} with state vector:{1}".format(fundamental_memory, self.state_vector))
corelation = []
bipolar = make_bipolar(fundamental_memory)
flat_memory = [item for sublist in bipolar for item in sublist]
Logger.log("{0} length: {1}".format(fundamental_memory, len(flat_memory)))
for i in flat_memory:
x_mi = i
# there is no sign function in python... :D
y_mi = self.neurons[i].test(flat_memory)
if x_mi == y_mi:
corelation.append(True)
response = [n.test(flat_memory) for n in self.neurons]
Logger.log("{0}: {1}".format(fundamental_memory, unmake_bipolar(response, len(charset[fundamental_memory[0]]))))
Logger.log("{0}: {1}".format(fundamental_memory, len(corelation)))
def backpropagate(self, pattern):
Logger.log("beginning backpropagation of pattern {0}".format(pattern[1]))
Logger.log("training output layer")
self.layers[-1].backpropagate(pattern[1], self.layers[-2], True)
current = self.layers[-1]
backward = self.layers[1:-1]
backward.reverse()
for i, layer in enumerate(backward):
Logger.log("training hidden layer {0}".format(len(self.layers)-i-1))
layer.backpropagate(None, current)
current = layer
for layer in self.layers[1:]:
for neuron in layer.neurons:
neuron.update_weight()
def backpropagate(self, pattern):
Logger.log("beginning backpropagation of pattern {0}".format(
pattern[1]))
Logger.log("training output layer")
self.layers[-1].backpropagate(pattern[1], self.layers[-2], True)
current = self.layers[-1]
backward = self.layers[1:-1]
backward.reverse()
for i, layer in enumerate(backward):
Logger.log(
"training hidden layer {0}".format(len(self.layers) - i - 1))
layer.backpropagate(None, current)
current = layer
for layer in self.layers[1:]:
for neuron in layer.neurons:
neuron.update_weight()
def doControllerForwarding():
# try to connect to server
while True:
try:
Logger.log("Attempting to connect to Controller Server")
SOC.connect((IP, PORT))
time.sleep(
.01
) # wait 10 milliseconds before sending anything (no reason, just be safe i guess)
Logger.log(
"Sucessfully connected to Controller Server......starting controller"
)
break
except: # in case of error (such as server not running yet), retry connection in 5 seconds
Logger.log(
"Connection unable to be established. Retrying in 2 seconds")
time.sleep(2)
continue
# after ensuring connection to controller server, start sending data
asyncio.run(run_forward())
# initialize Robot
initialize()
# Start Robot
try:
# Define initial state
STATE = State.idle
last = time.time()
while True:
# place update methods for things that should be updated at idle here
Controller.updateController()
if (STATE == State.idle):
# when idle, continue doing nothing (Daemon's/other threads of control will continue to run)
continue
# when not idle, decide what to do
if (STATE == State.teleop):
for component in components:
component.update()
elif (STATE == State.auto):
for component in components:
component.autoUpdate()
else:
raise IllegalStateException("Robot state is undefined")
except:
# Log Exception (removes \n from the end)
Logger.logError(format_exc()[0:-1])
finally:
Logger.log("Killing Components")
for component in components:
component.kill()
def __init__(self, neurons, F, learning_rate, threshold):
Logger.log("initializing Layer with {0} neurons".format(neurons))
self.neurons = [
Neuron(F, learning_rate, threshold) for neuron in range(neurons)
]
def activate(self, pattern):
""" activates the mlp using the patterns """
Logger.log("activating input layer")
self.layers[0].activate(pattern[0])
for i, layer in enumerate(self.layers[1:]):
layer.activate(self.layers[i].output)
def doServer():
# create new socket object
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind((HOST, PORT)) # bind our socket to our port
s.listen() # listen for connections
# outside loop to enable restarting the server
while True:
conn, addr = s.accept(
) # once connection available, accept it (THIS IS BLOCKING)
try:
with conn:
# Start by getting controller information json (first packet received)
# print("Connected to", addr) # print who we are connected with
data: bytes = b""
while not data:
data += conn.recv(4096)
# if message post-curser not found, keep polling the socket
if (EOM not in data):
continue
split = data.index(EOM)
controllerInformation = data[:split]
data = data[split + len(EOM):]
controllerInformation = controllerInformation.decode()
try:
controllerInformation = json.loads(
controllerInformation)
except JSONDecodeError: # JSONDecode error here is FATAL, abort the connection (and retry connection)
Logger.logError(format_exc())
s.close()
raise ConnectionAbortedError
# TODO: MAKE OBSOLETE
# parse any events grabbed from socket at this time
events: List[List] = []
while EOM in data:
split = data.index(EOM)
try:
events.append(
json.loads(data[:split].decode().replace(
'\n', '')))
except JSONDecodeError:
Logger.logError(format_exc())
data = data[split + len(
EOM
):] # if we cut off data, leave cut off data in buffer
# once we start getting data, get the first thing sent (our controller information)
devices_json = controllerInformation
devices = []
for device_json in devices_json:
capabilities = {}
for k, v in device_json['capabilities'].items(
): # parse capabilities json
capabilities[int(k)] = [
x if not isinstance(x, list) else
(x[0], evdev.AbsInfo(**x[1])) for x in v
]
# create new EVDev device
devices.append(
evdev.UInput(capabilities,
name=device_json['name'],
vendor=device_json["vendor"],
product=device_json["product"],
version=device_json["version"]))
Logger.log('Controller Device created')
# while we are connected read controller data (and try not to miss any events)
while True:
# poll the socket
start = time.time()
while EOM not in data: # grab data until EOM character reached
data += conn.recv(4096)
if (not data and time.time() - start > 60
): # 60 second timeout for controller server
raise ConnectionResetError
# parse data
# deocde, remove EOM character, split events into list
dataLST: List[str] = data.decode()[:len(data) -
len(EOM)].split(
'\n')
for possibleEvent in dataLST:
if (possibleEvent == ''
): # check if event is valid
continue
try:
events.append(
json.loads(possibleEvent.replace('\n', ''))
) # get rid of unwanted \n's if they exist
except JSONDecodeError: # Error here is not FATAL, ignore the event and continue parsing events
Logger.logError(format_exc())
continue
# apply pending events
for event in events:
if (event == ''):
continue
# write events to applicable device
devices[int(event[0])].write(
int(event[1]), int(event[2]), int(event[3]))
events = []
# connection was reset from other side (or maybe your network dropped)
except ConnectionResetError:
Logger.logError(format_exc())
time.sleep(1) # wait second before retrying connection
continue
def activate(self, pattern):
""" activates the mlp using the patterns """
Logger.log("activating input layer")
self.layers[0].activate(pattern[0])
for i, layer in enumerate(self.layers[1:]):
layer.activate(self.layers[i].output)
def __init__(self, neurons, F, learning_rate, threshold):
Logger.log("initializing Layer with {0} neurons".format(neurons))
self.neurons = [Neuron(F, learning_rate, threshold) for neuron in range(neurons)]
def __init__(self, layers, learning_rate = 1, threshold = None):
Logger.log("initializing MLP with {0} layers".format(len(layers)))
# sum of all neurons in the mlp
self.F = sum(layers)
self.layers = [Layer(neurons, self.F, learning_rate, threshold) for neurons in layers]
class Collection(object):
def __init__(self, rootdir, dbname='jukepoksi'):
self.rootdir = os.path.abspath(os.path.expandvars(os.path.expanduser(rootdir)))
self.db = pymongo.Connection()[dbname]
self.f_id = []
self.d_id = []
self.logger = Logger()
#for t in self.db.tracks.find():
#self.ids.append(t['_id'])
def _insert(self, collection, entry):
entry.update(entry_id = len(self.ids))
try:
oid = self.db[collection].insert(entry)
print 'DEBUG: Inserted entry %s into collection %s' % (entry, collection)
self.ids.append(oid)
except pymongo.errors.InvalidStringData:
pass
def _file_entry(self, path):
assert os.path.isfile(path)
filedir = os.path.dirname(path)
filename = os.path.basename(path)
filetype = os.path.splitext(filename)[1]
entry = { 'f_id' : len(self.f_id),
'fpath' : path,
'fname' : filename,
'ftype' : filetype }
try:
f = mutagen.File(path, easy=True)
except:
f = None
if f:
fileinfo = { 'album' : f.tags.get('album'),
'artist' : f.tags.get('artist'),
'bitrate' : getattr(f.info, 'bitrate', 0),
'description' : f.tags.get('description'),
'genre' : f.tags.get('genre'),
'length' : getattr(f.info, 'length', 0.0),
'mtime' : mtime(path),
'title' : f.tags.get('title'),
'tracknumber' : f.tags.get('tracknumber') }
entry.update(fileinfo)
return entry
def _dir_entry(self, path, dirs, files):
assert os.path.isdir(path)
entry = { 'd_id' : len(self.d_id),
'dname' : path,
'dirs' : dirs,
'files' : files,
'mtime' : mtime(path) }
return entry
def _insert_file(self, path):
assert os.path.isfile(path)
self.logger.inc()
self.logger.log('Adding file: %s ... ' % (path), newline=False)
f_entry = self._file_entry(path)
try:
f_oid = self.db.files.insert(f_entry)
self.f_id.append(f_oid)
self.logger.log('Done')
except InvalidStringData:
self.logger.log('ERROR, paskaa')
f_oid = None
finally:
self.logger.dec()
return f_oid
def _insert_dir(self, dirname):
assert os.path.isdir(dirname)
self.logger.inc()
self.logger.log('Entering dir: %s' % (dirname))
files = []
dirs = []
for fname in os.listdir(dirname):
path = os.path.join(dirname, fname)
if os.path.isfile(path):
if is_supported(path):
f_oid = self._insert_file(path)
if f_oid:
files.append(f_oid)
elif os.path.isdir(path):
d_oid = self._insert_dir(path)
if d_oid:
self.d_id.append(d_oid)
dirs.append(d_oid)
d_entry = self._dir_entry(dirname, dirs, files)
d_oid = self.db.dirs.insert(d_entry)
self.logger.log('Leaving dir: %s' % (dirname))
self.logger.dec()
return d_oid
def update(self):
self.logger.inc()
self.logger.log('Starting database update')
self.db.files.drop()
self.db.dirs.drop()
self._insert_dir(self.rootdir)
self.logger.log('Database update done')
self.logger.dec()
def open(self, f_id):
f_oid = self.f_id[f_id]
ffile = self.db.files.find_one(f_oid)
print 'DEBUG: Opening file: %s' % (ffile['fpath'])
return audiofile(ffile['fpath'].encode('utf-8'))
def kill(self) -> None:
for servo in MANIP_SERVOS.values():
servo.angle = None
Logger.log("Manipulator Servos Successfully Killed")
from tools import Logger
from tools.network import Client, Server
from gui import GUI
from traceback import format_exc
import cv2
# Debug Tools
purgeLogs = True
def initialize():
Logger.createNewLog(purgeLogs)
# GUI already initialized on import resolution
Client.startClient()
Server.startServer()
# ControllerClient.startControllerForwarding()
Logger.log("DriverStation initialized")
initialize()
try:
while True:
# always update GUI (prevent OS from thinking program has stalled)
GUI.rootWindow.update()
GUI.updateWidgets()
except:
Logger.logError(format_exc()[0:-1])
finally:
Logger.log("Shutting down")
