def start(self):
Module.start(self)
self._agent.setPin(self._cfg.get('pin', None))
self.setState(False) # Disabling interface to set the SSP
self.setSSP(
False
) # Secure Simple Pairing - if enabled will disable pin pairing (not supported) (not secure)
self.setState(self._cfg.get('enabled', True))
self.setDeviceClass('0x200420')
self.setDeviceName(self._cfg.get('name', 'tracker-1'))
self.setAFH(self._cfg.get('afh', True))
self.setEncryption(self._cfg.get('encrypt', True))
self.setVisibility(self._cfg.get('visible', False))
self.setAuth(self._cfg.get('auth', False))
self.setFastConnection(self._cfg.get('fast', True))
manager = dbus.Interface(self._bus.get_object(BUS_NAME, '/org/bluez'),
AGENT_MANAGER_INTERFACE)
manager.RegisterAgent('/tracker/agent', 'NoInputNoOutput')
manager.RequestDefaultAgent('/tracker/agent')
self._listener = self._bus.add_signal_receiver(
self._devicePropertyChanged,
bus_name=BUS_NAME,
signal_name='PropertiesChanged',
path_keyword='device_path',
interface_keyword='interface')
self.restoreLastConnection()
def set_detector_rz_collection(self, list_of_detids):
# Create detector patches
self.patches_rz = []
n_failed = 0
for detid in list_of_detids:
module = Module(detid)
partner_detid = Module(detid).partnerDetId()
if partner_detid not in self.det_geom.getData().keys():
# print("{} not found from {} (isLower = {}, isInverted = {})".format(partner_detid, detid, module.isLower(), module.isInverted()))
n_failed += 1
continue
else:
# print("{} found from {} (isLower = {}, isInverted = {})".format(partner_detid, detid, module.isLower(), module.isInverted()))
pass
six_faces = self.get_six_faces(
self.det_geom.getData()[detid],
self.det_geom.getData()[partner_detid])
for face in six_faces:
points = [[x[0], math.sqrt(x[1]**2 + x[2]**2)] for x in face]
polygon = Polygon(np.array(points), True)
self.patches_rz.append(polygon)
def postStart(self):
'''Checking the current state of the listening GPIO's and do the configured actions'''
Module.postStart(self)
# Init listen GPIO's in poststart
# We need to be sure that listen isn't triggered until all the modules was started
for name, item in self._cfg.get('listen', {}).iteritems():
log.info("Attaching GPIO listener %s to pin %d" %
(name, item['pin']))
self._pin_map[item['pin']] = name
gpio.setup(item['pin'], gpio.IN)
while self.isActive():
# Sometimes event detection is can't be set up - so need retries
try:
gpio.add_event_detect(item['pin'],
gpio.BOTH,
callback=self._listenTrigger)
except RuntimeError:
log.error(
'Detected unable to set event detection for GPIO %s, retrying...'
% item['pin'])
self.waitActive(1.0)
continue
break
for pin in self._pin_map:
self._listenTrigger(pin)
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
self._data = {}
self._data_lock = threading.Lock()
self._data_send_timer = None
self._send_interval = None
def stop(self):
Module.stop(self)
if self._data_send_timer:
self._data_send_timer.cancel()
self._data_send_timer = None
self._send_interval = None
self.sendData()
def get_modules(session):
print("Getting modules...\n")
modules = []
resp = session_get('{0}/courses/{1}/modules'.format(CANVAS_URL, COURSE_ID),
session)
tree = html.fromstring(resp.content)
moduleNodes = tree.xpath(
"//div[contains(@class, 'context_module') and contains(@class, 'item-group-condensed')]"
)
# Last element is a blank module
moduleNodes.pop()
for moduleNode in moduleNodes:
module = Module()
module.name = moduleNode.attrib['aria-label']
print("Found Module ", module.name)
module.items = get_items(moduleNode)
modules.append(module)
print("")
return modules
def start(self):
Module.start(self)
# Init socket GPIO's
for action in self._cfg.get('sockets', []).keys():
if hasattr(self, action):
log.error("Unable to redefine existing function by socket %s" %
action)
continue
socket = self._cfg['sockets'][action]
log.info("Registering socket action %s for pin %d..." %
(action, socket['pin']))
gpio.setup(socket['pin'],
gpio.OUT,
initial=socket.get('default', False))
socket_type = socket.get('type', 'switch')
if socket_type == 'switch':
setattr(self,
action,
lambda self=self, pin=socket['pin'], value=None: self.
sendChange(pin, value))
elif socket_type == 'pulse':
setattr(self,
action,
lambda self=self, pin=socket['pin'], duration=socket.
get('duration', None): self.sendPulse(pin, duration))
else:
log.warn("GPIO type %s unsupported for socket %s" %
(socket_type, action))
def exec(self, args, **kwargs):
parse_args = Command.Command.PARSER.parse_args(args)
module = Module(parse_args.command, parse_args.interval,
parse_args.signal, parse_args.align, parse_args.order)
modules.append(module)
module.exec(shell)
epoll.register(module)
return b'Ok'
def __init__(self):
Module.__init__(self)
self.add_method('printout', self.printout)
self.add_method('assert', self.assertion)
self.add_method('retract', self.retract)
self.add_method('bind', self.bind)
self.add_method('test', self.test)
self.add_method('strategy', self.strategy)
def __init__(self):
Module.__init__(self)
self.add_method('printout', self.printout)
self.add_method('assert', self.assertion)
self.add_method('retract', self.retract)
self.add_method('bind', self.bind)
self.add_method('test', self.test)
self.add_method('strategy', self.strategy)
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
self._raw_data = {}
self._raw_data_lock = threading.Lock()
self._map_data = {}
self._map_data_lock = threading.Lock()
self._thread_control = threading.Thread(target=self._readRawDataThreadWrapper)
def test_progress_module(self):
module = Module("test_module", 600)
current_time = datetime.datetime(2014, 1, 1, 0, 0, 0)
module.calc_deadline(current_time, 10, 0)
for i in range(60):
current_time += datetime.timedelta(hours=1)
module.progress_module(10, current_time)
self.assertTrue(module.progress >= 500 or module.progress <= 700)
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
self._ignition = None
self._ignition_lock = threading.Lock()
self._ignition_off_timer = None
self._power_outage = None
self._critical_battery_voltage = None
self._low_battery_voltage = None
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
self._bus = dbus.SystemBus()
self._agent = Agent(self._bus, "/tracker/agent")
self._listener = None
self._last_device = None
self._resume_playing = None
self._connected_devices = {}
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
self._server = Server((self._cfg.get('address', ''), self._cfg.get('port', 9000)))
self._registerHandlers()
self._server_proc = Thread(target=self._server.serve)
self._server_proc.daemon = True
self._server_proc.start()
def __init__(self):
Module.__init__(self)
self.add_method('eq', self.equal)
self.add_method('neq', self.not_equal)
self.add_method('<', self.less_than)
self.add_method('<=', self.less_equal)
self.add_method('>', self.greater_than)
self.add_method('>=', self.greater_equal)
self.add_method('and', self.logical_and)
self.add_method('or', self.logical_or)
self.add_method('not', self.logical_not)
def test_calc_deadline(self):
module = Module("test_module", 600)
start_time = datetime.datetime(2014, 1, 1, 0, 0, 0)
deadline = datetime.datetime(2014, 1, 22, 0, 0, 0)
module.calc_deadline(start_time, 10, 0)
print module.deadline
self.assertTrue(module.deadline == deadline)
module.calc_deadline(start_time, 600, 0)
self.assertTrue(module.deadline == start_time)
def __init__(self):
Module.__init__(self)
self.add_method('eq', self.equal)
self.add_method('neq', self.not_equal)
self.add_method('<', self.less_than)
self.add_method('<=', self.less_equal)
self.add_method('>', self.greater_than)
self.add_method('>=', self.greater_equal)
self.add_method('and', self.logical_and)
self.add_method('or', self.logical_or)
self.add_method('not', self.logical_not)
def test_calc_progress(self):
current_time = datetime.datetime(2014, 1, 1, 0, 0, 0)
team = Team("test_team", 10)
module = Module("test_module", 800)
module.calc_deadline(current_time, 10, 0)
team.module = module
while team.module and not team.module.completed:
current_time += datetime.timedelta(hours=1)
team.calc_progress(current_time)
self.assertTrue(team.completed_modules and team.completed_modules[0] == module)
def stop(self):
Module.stop(self)
self._bus.remove_signal_receiver(self._listener)
for addr in self._connected_devices.keys():
self.stopDev(addr)
manager = dbus.Interface(self._bus.get_object(BUS_NAME, '/org/bluez'),
AGENT_MANAGER_INTERFACE)
try:
manager.UnregisterAgent('/tracker/agent')
except:
pass
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
if not hasattr(self, "_command"):
self._command = None
if not hasattr(self, "_command_cwd"):
self._command_cwd = None
self._process = None
self._client = None
self._timer_processcheck = None
self._pidpath = kwargs.get('pidpath')
self.start()
def LmodModuleList(paths):
import string
moduleList = []
output = pexpect.run(MODULE_COMMAND + ' ' + string.join(paths, ':'))
import json
output_js = json.loads(output)
if "jsonSoftwarePage" in MODULE_COMMAND:
for elem in output_js:
for v in elem["versions"]:
name = v["full"]
help = "-"
prereq = "-"
if v.has_key("help"):
help = v["help"]
if v.has_key("parent"):
prereq = string.join(v["parent"], " or ").replace(
"default:", "").replace("default",
"").replace(":", " and ")
newModule = Module(name, help, "-", prereq)
if newModule.version[0] != ".":
moduleList.append(newModule)
elif "spider-json" in MODULE_COMMAND:
# print(str(output_js))
for module_name in output_js:
data = output_js[module_name]
for path in data:
module_data = data[path]
# print(str(module_data))
if module_data.has_key("fullName"):
name = module_data["fullName"]
help = "-"
prereq = "-"
if module_data.has_key("Description"):
help = module_data["Description"]
if module_data.has_key("parentAA"):
prereq = string.join(module_data["parentAA"][0], " and ")
newModule = Module(name, help, "-", prereq)
if newModule.version[0] != ".":
found = False
for n, m in enumerate(moduleList):
if m.name == newModule.name:
newModule = Module(name, help, "-",
m.prereq + " or " + prereq)
moduleList[n] = newModule
found = True
break
if not found:
moduleList.append(newModule)
return moduleList
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
if not hasattr(self, "_command"):
self._command = None
if not hasattr(self, "_command_cwd"):
self._command_cwd = None
self._process = None
self._client = None
self._timer_processcheck = None
self._pidpath = kwargs.get('pidpath')
self.start()
def main():
## create patient schedule
patientList = []
personA = Person('A', 0)
patientList.append(personA)
personB = Person('B', 4)
patientList.append(personB)
personC = Person('C', 10)
patientList.append(personC)
## module schedule (from a file)
moduleList = []
module1 = Module(0, 2)
moduleList.append(module1)
module2 = Module(1, 3)
moduleList.append(module2)
moduleCount = len(moduleList)
## need a nursing scheduler as nurses could be different than modules.
## intialize simulation parameters
counter = 0
completed = 0
## simulation loop
while completed < len(patientList):
print('Time Step: {0}'.format(counter))
for mod in moduleList:
for pat in patientList:
if pat.location == mod.location and pat.serviceTime > 0:
mod.serve(pat)
break
if pat.location == mod.location and pat.serviceTime == -1:
# This should be a method in the module class.
print('Location {0} now serving Patient {1}'.format(
mod.location, pat.name))
pat.serviceTime = mod.completionTime
break
completed = 0
# condition to check if all patients have completed the clinic (Can we close?)
for pat in patientList:
if pat.location == moduleCount:
completed += 1
counter += 1
def set_detector_etaphi_collection(self, list_of_detids):
# Create detector patches
self.patches_etaphi = []
n_failed = 0
for detid in list_of_detids:
module = Module(detid)
bound_points = self.det_geom.getData()[detid]
points = []
for bp in bound_points:
x = bp[1]
y = bp[2]
z = bp[
0] # The index is weird because that's how it is saved in det_geom
phi = math.atan2(y, x)
print(x, y, phi)
# print(x, y, z)
eta = math.copysign(
-math.log(
math.tan(
math.atan(math.sqrt(y**2 + x**2) / abs(z)) / 2.)),
z)
points.append([eta, phi])
polygon = Polygon(np.array(points), True)
self.patches_etaphi.append(polygon)
def git_init(repo):
os.mkdir(repo)
tmp = Module(repo, True)
os.chdir(tmp.url)
os.system('git init')
os.chdir(work_path)
return tmp
def get_modules(self):
self.modules = []
self.bad_modules = []
# Get possible files that could contain a module
module_filenames = []
x = '/' if os.path.sep == '/' else r'\\'
pattern = re.compile(f'^.{x}modules{x}[^{x}]+$')
for subdir, _, files in os.walk(os.path.join(os.curdir, 'modules')):
if pattern.match(subdir):
if 'main.py' in files:
module_filenames.append(os.path.join(subdir, 'main.py'))
else:
self.bad_modules.append((subdir.split(os.path.sep)[-1], 'No main.py file'))
# Go through files and try to import a class
for filename in module_filenames:
spec = importlib.util.spec_from_file_location(filename[2:-3].replace(os.path.sep, '.'), filename)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
if not hasattr(module, 'export'):
self.bad_modules.append((filename.split(os.path.sep)[-2], 'No exported class in main.py'))
elif not Module.is_valid(module.export):
self.bad_modules.append((filename.split(os.path.sep)[-2], 'Exported module is invalid'))
else:
self.init_module(module.export)
for module_name, reason in self.bad_modules:
self.logger.warning(f'Installed module `{module_name}` cannot be loaded: {reason}')
def __init__(self):
rooms = [["GD923", 60], ["GD924", 60], ["GD926", 60], ["GD929", 60],
["GD933", 60]]
meeting_times = [["1. Block", "08:00 – 09:50"],
["2. Block", "10:00 – 11:50"],
["3. Block", "13:00 – 14:50"],
["4. Block", "15:00 – 16:50"]]
dosens = [
["HTS", "Humasak Simanjuntak"],
["SGS", "Samuel Situmeang"],
["JUN", "Junita Amalia"],
["MSS", "Mario Simaremare"],
["THS", "Tennov Simanjuntak"],
["DWS", "Devis Wawan Saputra"],
["BLT", "Bonar Lumban Tobing"],
["IUS", "Iustisia Simbolon"],
["PAT", "Parmonangan Togatorop"],
]
self._rooms = []
self._meeting_times = []
self._dosens = []
self.fill_objects(rooms, meeting_times, dosens)
module1 = Module("BASDATLAN", "Advanced Database",
[self.get_dosen("HTS")])
module2 = Module("CERTAN", "Artificial Intelligence",
[self.get_dosen("SGS")])
module3 = Module("PROBSTAT", "Probability and Statistics",
[self.get_dosen("JUN"),
self.get_dosen("THS")])
module4 = Module("PPW", "Web Application Programming and Testing",
[self.get_dosen("MSS")])
module5 = Module("ALSTRUDAT", "Algorithms and Data Structures", [
self.get_dosen("THS"),
self.get_dosen("HTS"),
self.get_dosen("PAT"),
self.get_dosen("SGS")
])
module6 = Module("TEKNO", "Technopreneurship", [self.get_dosen("DWS")])
module7 = Module("ATI", "Religion and Ethics", [self.get_dosen("BLT")])
module8 = Module("RPL", "Software Engineering",
[self.get_dosen("IUS")])
module9 = Module("MPSI", "Information System Project Management",
[self.get_dosen("PAT")])
self._modules = [module1, module2, module3, module4, module5, module6]
course1 = Course("11SI", [module1, module3, module4, module7], 59)
course2 = Course("12SI", [module2, module4, module5, module8], 50)
course3 = Course("13SI", [module4, module5, module6, module9], 56)
course4 = Course("14SI", [module5, module3, module1, module9], 48)
self._courses = [course1, course2, course3, course4]
def printPixelMap_v1():
import os
dirpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
det_geom = DetectorGeometry(
"/data2/segmentlinking/phase2_2020_0428.txt".format(dirpath))
super_bins = {}
neta = 40.
nphi = 72.
isuper_bin = 0
pt_bounds = [0.9, 2.0, 4.0, 10., 50.]
# pt_bounds = [0.9, 2.0]
for ipt in xrange(len(pt_bounds) - 1):
pt_lo = pt_bounds[ipt]
pt_hi = pt_bounds[ipt + 1]
for ieta in xrange(int(neta)):
eta_lo = -2.6 + (5.2 / neta) * ieta
eta_hi = -2.6 + (5.2 / neta) * (ieta + 1)
for iphi in xrange(int(nphi)):
phi_lo = -math.pi + (2 * math.pi / nphi) * iphi
phi_hi = -math.pi + (2 * math.pi / nphi) * (iphi + 1)
super_bins[isuper_bin] = (pt_lo, pt_hi, eta_lo, eta_hi, phi_lo,
phi_hi)
isuper_bin += 1
print(len(super_bins))
maps = {}
for layer in [1, 2, 3, 4, 5, 6]:
for subdet in [4, 5]:
for isuper_bin in super_bins.keys():
bounds = super_bins[isuper_bin]
maps[isuper_bin] = []
for detid in det_geom.getDetIds():
if Module(detid).layer() == layer and Module(
detid).isLower() == 1 and Module(detid).moduleType(
) == 0 and Module(detid).subdet() == subdet:
if det_geom.isConnected(detid, bounds[2], bounds[3],
bounds[4], bounds[5],
bounds[0], bounds[1], -30, 30):
maps[isuper_bin].append(detid)
print(isuper_bin, layer, subdet, bounds[2], bounds[3],
bounds[4], bounds[5], maps[isuper_bin])
def modules_save():
user = current_user.id
name = request.form['name']
version = request.form['version']
m = Module(user, name, version)
m.encrypt = request.form['encrypt']
m.decrypt = request.form['decrypt']
m.hack = request.form['hack']
m.comms = request.form['comms']
return jsonify(module=dict(
user=user,
name=name,
version=version,
encrypt=m.encrypt,
decrypt=m.decrypt,
hack=m.hack,
comms=m.comms))
def getModules(self, elements, libraryDict, converter):
for element in elements:
elementPackage = element.get("package")
elementLib = element.get("library")
libNode = libraryDict.get(elementLib).get(elementPackage)
modContacts = self.contacts.get(element.get("name"))
module = Module(libNode, converter, element, modContacts)
self.elements.append(module)
def get_module_objects(self):
module_objs = [
Module(module, self.configs, self.verbosity)
for module in self.module_path_list
]
if len(module_objs) > 1 and self.verbosity > 1:
print("[" + str(len(module_objs)) + "]")
return module_objs
def hangup(fileno):
if fileno in self.conn_table:
self.epoll.unregister(fileno)
self.conn_table[fileno].close()
self.conn_table.pop(fileno)
else:
module = Module.find_modules_by_fileno(self.modules, fileno)
module.reap()
self.epoll.unregister(module)
def __init__(self):
Module.__init__(self)
self.add_method('+', self.addition)
self.add_method('-', self.subtraction)
self.add_method('*', self.multiplication)
self.add_method('/', self.division)
self.add_method('%', self.module)
self.add_method('**', self.power)
self.add_method('abs', self.abs)
self.add_method('min', self.minimum)
self.add_method('max', self.maximum)
self.add_method('strcat', self.strcat)
self.add_method('substr', self.substr)
self.add_method('strlen', self.strlen)
self.add_method('strindex', self.strindex)
self.add_method('symcat', self.symcat)
self.add_method('randint', self.randint)
random.seed(time.time())
def __init__(self):
Module.__init__(self)
self.add_method('+', self.addition)
self.add_method('-', self.subtraction)
self.add_method('*', self.multiplication)
self.add_method('/', self.division)
self.add_method('%', self.module)
self.add_method('**', self.power)
self.add_method('abs', self.abs)
self.add_method('min', self.minimum)
self.add_method('max', self.maximum)
self.add_method('strcat', self.strcat)
self.add_method('substr', self.substr)
self.add_method('strlen', self.strlen)
self.add_method('strindex', self.strindex)
self.add_method('symcat', self.symcat)
self.add_method('randint', self.randint)
random.seed(time.time())
def addModule(self, inputData, register, output):
"""Add a module to the module list
Parameters:
input - (DataContainer) input variables and results from preparatory modules
register - (DataContainer) registry data of this module
output - (DataContainer) with output requirements for this module
"""
module = Module(inputData, register, output)
self.moduleList.append(module, )
return
def start(self):
Module.start(self)
self._c = serial.Serial(self.getDevice(), self.getRate(), timeout=1.0)
self.powerOn()
# Disabling echo
self.execAT('ATE0')
# Check the device before running
if self.checkVersion() != True:
log.error(
'Unable to run GSMGPS module due to device version is unsupported: %s'
% self.checkVersion())
self.stop()
if self._cfg.get('net', {}).get('enabled', False):
self.enableNetwork()
if self._cfg.get('gps', {}).get('enabled', False):
self.enableGPS()
def __init__(self, **kwargs):
Module.__init__(self, **kwargs)
self.setState(self._cfg.get('enabled', False))
self.setDeviceClass("0xAA040B")
self.setDeviceName(self._cfg.get('name', 'OneButton'))
self.setEncryption(self._cfg.get('encrypt', True))
self.setVisibility(self._cfg.get('visible', False))
self._bus = dbus.SystemBus()
# Required bluez >= 5.40 due to fix in profiles connections
self._agent = Agent(self._bus, "/onebutton/agent")
manager = dbus.Interface(self._bus.get_object(BUS_NAME, "/org/bluez"), "org.bluez.AgentManager1")
manager.RegisterAgent("/onebutton/agent", "NoInputNoOutput")
manager.RequestDefaultAgent("/onebutton/agent")
self._btservice = BTService(self._bus, 'OneButton')
self.registerService('localhost', 9000, 'OneControl')
self.registerService('localhost', 8881, 'Guitarix RPC')
self.registerService('localhost', 8000, 'Guitarix WEB')
self.registerService('localhost', 22, 'SSH')
def __init__(self):
super().__init__()
# Get all modules and add client to their variables
with open("data/config.json", "r") as f:
self.args = json.loads(f.read())
# discord.opus.load_opus(self.args["opus"])
self.htmlsocketserver = htmlsocketserver.Htmlsocketserver(self)
self.db = pymongo.MongoClient().jaa
self.modules = [subclass(self) for subclass in Module.__subclasses__()]
def modules_get(user, name, version):
if not (user == current_user.id or current_user.isadmin or (version is not None and version.endswith('p'))):
return jsonify(error='Not authorised'), 403
if not Module.exists(user, name, version):
return jsonify(error='no module of that name'), 404
m = Module(user, name, version)
return jsonify(module=dict(
user=user,
name=name,
version=version,
encrypt=m.encrypt,
decrypt=m.decrypt,
hack=m.hack,
comms=m.comms))
def start_element(self, name, attrs):
"""
Function called when the start of an XML element is found
"""
if name == "module":
self.current_module = Module(attrs['name'])
self.current_module.add_id(attrs['id'])
elif name == "dependency":
self.in_dependency = True
elif name == "param":
self.current_param = Parameter()
elif name == "description":
self.in_description = True
elif name == "value":
self.in_value = True
elif name == "command":
self.in_command = True
elif name == "id":
self.in_id = True
elif name == "child":
self.in_child = True
self.parent = self.current_module
def test_get_task(self):
module = Module("test_module", 600)
task = module.get_task("design")
self.assertTrue(
task
and task.name == "design"
and task.actual_cost >= int(90 * 0.75)
and task.actual_cost <= int(90 * 1.25)
and task.module == module
)
task = module.get_task("implementation")
self.assertTrue(
task
and task.name == "implementation"
and task.actual_cost >= int(90 * 0.75)
and task.actual_cost <= int(90 * 1.25)
and task.module == module
)
task = module.get_task("unit_test")
self.assertTrue(
task
and task.name == "unit_test"
and task.actual_cost >= int(60 * 0.75)
and task.actual_cost <= int(60 * 1.25)
and task.module == module
)
task = module.get_task("integration")
self.assertTrue(
task
and task.name == "integration"
and task.actual_cost >= int(90 * 0.75)
and task.actual_cost <= int(90 * 1.25)
and task.module == module
)
task = module.get_task("system_test")
self.assertTrue(
task
and task.name == "system_test"
and task.actual_cost >= int(90 * 0.75)
and task.actual_cost <= int(90 * 1.25)
and task.module == module
)
task = module.get_task("deployment")
self.assertTrue(
task
and task.name == "deployment"
and task.actual_cost >= int(90 * 0.75)
and task.actual_cost <= int(90 * 1.25)
and task.module == module
)
task = module.get_task("acceptance_test")
self.assertTrue(
task
and task.name == "acceptance_test"
and task.actual_cost >= int(90 * 0.75)
and task.actual_cost <= int(90 * 1.25)
and task.module == module
)
task = module.get_task("not_a_task")
self.assertTrue(not task)
def test_productive_time_on_task(self):
module = Module("test_module", 600)
self.assertTrue(module.productive_time_on_task() == 0)
module.hours_taken += 10
self.assertTrue(module.productive_time_on_task() == 10)
def test_wall_clock_time(self):
module = Module("test_module", 600)
self.assertTrue(module.wall_clock_time() == 0)
module.total_hours += 10
self.assertTrue(module.wall_clock_time() == 10)
def index():
current_user.modules = list(Module.getall(current_user))
return render_template('index.html', user=current_user, page='index', rooms=list(Room.getall()))
def __init__(self, parent):
Module.__init__(self, parent, name = 'admin', trigger = None)
self.config = {}
execfile('config', {}, self.config)
return
def __init__(self, parent, name = 'seen', trigger = '!seen'):
Module.__init__(self, parent, name, trigger)
self.seen = {}
self.lockdb = thread.allocate_lock()
return
def __init__(self):
Module.__init__(self)
def __init__(self, parent):
Module.__init__(self, parent, name = 'apk', trigger = '!apk')
return
def __init__(self, parent, name = 'megahal', trigger = None):
Module.__init__(self, parent, name, trigger)
mh_python.initbrain()
return
def __init__(self, application):
Module.__init__(self, application)
self.token = hashlib.md5("%f%f"%(random.random(), time.time())).hexdigest()
def __init__(self, parent):
Module.__init__(self, parent, name = 'gaffel', trigger = '!g')
return
def modules_list():
return jsonify(modules=Module.getall(current_user))
def __init__(self, parent, name = 'httptitle', trigger = None):
Module.__init__(self, parent, name, trigger)
return
class ModuleXMLParser:
"""
ModuleXMLParser will parse a list of modules and returns it.
"""
def __init__(self):
self.module_list = []
self.param_list = []
self.current_module = None
self.current_param = None
self.cdata = ""
self.parent = None
self.in_description = False
self.in_command = False
self.in_value = False
self.in_id = False
self.in_child = False
self.in_dependency = False
def start_element(self, name, attrs):
"""
Function called when the start of an XML element is found
"""
if name == "module":
self.current_module = Module(attrs['name'])
self.current_module.add_id(attrs['id'])
elif name == "dependency":
self.in_dependency = True
elif name == "param":
self.current_param = Parameter()
elif name == "description":
self.in_description = True
elif name == "value":
self.in_value = True
elif name == "command":
self.in_command = True
elif name == "id":
self.in_id = True
elif name == "child":
self.in_child = True
self.parent = self.current_module
def end_element(self, name):
"""
Function called when the end of an XML element is found
"""
if name == "description":
self.in_description = False
if self.current_param:
# Parser is inside a parameter, add the description to it
self.current_param.add_description(self.cdata)
else:
self.current_module.add_description(self.cdata)
self.cdata = ""
elif name == "dependency":
self.current_module.dependencies.append(int(self.cdata))
self.in_dependency = False
self.cdata = ""
elif name == "value":
self.in_value = False
self.current_param.add_value(self.cdata)
self.cdata = ""
elif name == "command":
self.in_command = False
self.current_module.add_command(self.cdata)
self.cdata = ""
elif name == "id":
self.in_id = False
self.current_param.add_id(self.cdata)
self.cdata = ""
elif name == "param":
self.param_list.append(self.current_param)
self.current_param = None
elif name == "module":
self.module_list.append(self.current_module)
elif name == "child":
# TODO: Allow having more than one child
self.parent.children = self.current_module
self.current_module = self.parent
self.in_child = False
def char_data(self, data):
"""
Function called when some character data within an XML element is found
"""
data = data.strip()
if data:
if self.in_description or self.in_id or self.in_command or self.in_value or self.in_dependency:
self.cdata = self.cdata + data
def parse(self, text):
"""
Sets up expat with the correct custom parser functions and parses text
"""
parser = expat.ParserCreate()
parser.StartElementHandler = self.start_element
parser.EndElementHandler = self.end_element
parser.CharacterDataHandler = self.char_data
parser.Parse(text, 1)
return (self.module_list, self.param_list)
def __init__(self, parent):
Module.__init__(self, parent, 'weather', '!w')
return
def __init__(self, parent):
Module.__init__(self, parent, 'weatherforcast', '!wf')
return
def __init__(self, parent):
Module.__init__(self, parent, 'f1', '!f1')
return
