def main():
heater = device.Device("heater")
fan = device.Device("fan")
while True:
current_temp = get_temperature()
print("The current temperature is {} degrees.".format(current_temp))
time.sleep(2)
if current_temp > MAX_TEMP:
fan.set_power(True)
time.sleep(1)
heater.set_power(False)
time.sleep(1)
print("\n")
elif current_temp < MIN_TEMP:
fan.set_power(False)
time.sleep(1)
heater.set_power(True)
time.sleep(1)
print("\n")
else:
fan.set_power(False)
time.sleep(1)
heater.set_power(False)
time.sleep(1)
print("\n")
time.sleep(5)
def __init__(self, json_data):
print json_data
self.sender = device.Device('my laptop')
self.receiver = device.Device(json_data['receiver'])
self.command = json_data['command']
def __init__(self, appcommand,message):
#print json_data
self.sender = device.Device('My laptop')
self.receiver = device.Device('Mobile')
self.command = appcommand
self.write(message)
def __init__(self, json_data):
print "json data = " + `json_data[0]`
self.received_data = json_data[0]
self.sender = device.Device(json_data[0]['receiver'])
self.receiver = device.Device(json_data[0]['receiver'])
self.req_id = json_data[0]['data']['requestId']
self.command = json_data[0]['command']
def gettree(host, trunk="id", branches="children"):
'''
returns None if SNMP failed, or a dict with device info and neighbours.
'''
# List of devices we've already checked.
global checked
c = {trunk: host}
try:
d = device.Device(host)
d.snmpConfig(oid, snmpVersion, args.community)
except:
return c
neighbours = d.getNeighbours()
if not neighbours:
return c
children = []
# Have we already checked this device? Loop prevention.
for x in neighbours.values():
if x and (x not in checked):
logger.debug("%s has neighbour %s", host, x)
# Recurse!
checked.append(x)
children.append(gettree(x))
if children:
c[branches] = children
return c
def gather_roku_devices(self, makeonlydevicecurrent):
print("Looking for Roku devices...")
if self.connection:
ips = self.connection.get_devices()
self.devices = []
# Create devices
# send each device its most recent state and apps
if len(ips) == 0:
self.current_device = None
return
for i in ips:
# Get device info
apps = appgetter.doparse(
self.connection.send_command(i, "query/apps", True))
info = appgetter.doparsedeviceinfo(
self.connection.send_command(i, "query/device-info", True))
# Create a Device
self.devices.append(device.Device(i, apps, info))
# d.set_state(state)
# d.set_apps(apps)
# print(info)
# print(apps)
if makeonlydevicecurrent:
if len(self.devices) == 1:
self.select_roku_device(self.devices[0])
def set_mute(dev, is_mute):
'''
get device whether mute
@param dev: a device path
@param is_mute: whether is mute, a bool type
'''
device.Device(dev).set_mute(is_mute)
def handle_cmd():
appdb.collect_apps("../apks/")
serial = sys.argv[1]
cmd = sys.argv[2]
args = sys.argv[3:]
dev = device.Device(serial=serial, no_uimon=True)
if cmd == "clear":
if args[0] == 'all':
for app in appdb.apps:
clear(dev, appdb.get_app(app))
else:
clear(dev, appdb.get_app(args[0]))
elif cmd == "install":
appname = args[0]
install(dev, appname)
elif cmd == "uninstall":
appname = args[0]
uninstall(dev, appname)
elif cmd == "version":
appname = args[0]
apk_version(appname)
elif cmd == "dver":
appname = args[0]
ret = check_dev_version(dev, appname)
if ret:
sys.exit(0)
else:
sys.exit(1)
def get_mute(dev):
'''
get device whether mute
@param dev: a device path
@return: a bool type
'''
return device.Device(dev).get_mute()
def init_dev_list(dev_list, dev_type):
global PA_DEVICE
global PA_CHANNELS
global PA_CARDS
for d in dev_list:
dev = device.Device(d)
if dev_type == 'sink':
if not dev.get_ports() and d != CURRENT_SINK: # if the device does not have any ports, ignore it
continue
else:
if not dev.get_ports() and d != CURRENT_SOURCE: # if the device does not have any ports, ignore it
continue
PA_DEVICE[d] = dev
dev_channels = {}
channels = PA_DEVICE[d].get_channels()
dev_channels["channel_num"] = len(channels)
dev_channels["left"] = []
dev_channels["right"] = []
dev_channels["other"] = []
i = 0
while i < dev_channels["channel_num"]:
if channels[i] in LEFT_CHANNELS:
dev_channels["left"].append(i)
elif channels[i] in RIGHT_CHANNELS:
dev_channels["right"].append(i)
else:
dev_channels["other"].append(i)
i += 1
try:
cards = dev.get_card()
PA_CARDS[cards][dev_type].append(dev)
except:
traceback.print_exc()
PA_CHANNELS[d] = dev_channels
def get_individual_host(self, name):
self.ip = resolveUser.resolveUser(name)
self.url = 'https://%s/api/v1/host?hostIp=%s' \
% (settings.dnacIP, self.ip)
self.response_json = self.get_api(self.url)
self.message = ''
for host in self.response_json['response']:
#print host
self.message += 'User is connected to Network ' + u'\u2705' \
+ ' \n'
self.message += '[Host IP: ' + host['hostIp'] \
+ ', Host Mac: ' + host['hostMac'] + '] \n'
try:
apic_device = device.Device()
self.connected_device = \
apic_device.resolve_device_id(host['connectedNetworkDeviceId'
])
del apic_device
self.message += 'Connected to device: %s \n' \
% self.connected_device
if host['connectedInterfaceName']:
self.message += 'Connected to port: %s \n' \
% host['connectedInterfaceName']
if host['vlanId']:
self.message += 'Connected to vlan: %s \n' \
% host['vlanId']
else:
self.message += ' '
except:
print "No Attached Device"
return self.message
def get_device_list(db_conn, devices_conf_dir):
devices = {}
config_parser = ConfigParser()
for conf_file in os.listdir(devices_conf_dir):
if conf_file.startswith("."):
continue
conf = StringIO.StringIO()
conf.write('[__main__]\n')
conf.write(open(os.path.join(devices_conf_dir, conf_file)).read())
conf.seek(0)
config_parser.readfp(conf)
device_name = config_parser.get("__main__", "hostname")
reset_command = config_parser.get("__main__", "hard_reset_command")
off_command = config_parser.get("__main__", "power_off_cmd")
serial_command = config_parser.get("__main__", "connection_command")
devices[device_name] = device.Device(device_name, reset_command,
off_command, serial_command)
db_cursor = db_conn.cursor()
try:
db_cursor.execute("INSERT INTO devices VALUES (?)",
(device_name, ))
db_cursor.execute("INSERT INTO reservations VALUES (?, ?, ?, ?)",
(device_name, 0, None, 0))
db_conn.commit()
except sqlite3.IntegrityError:
pass
finally:
db_cursor.close()
return devices
def cleanup_workers(self, include_calibrators=False):
self.poll()
for miner_name in self.miners.keys():
for algorithm in self.miner_state[miner_name]['algorithms']:
kill = True
if not include_calibrators and len(algorithm['pools']) > 0:
login = algorithm['pools'][0]['login']
user, password = login.split(':')
if user[-5:] == 'CALIB':
kill = False
if kill:
if len(algorithm['workers']) > 0:
nvidia.Nvidia().set_default_profile(
device.Device({
"id":
int(algorithm['workers'][0]['device_id'])
}))
self.miners[miner_name].do_command(
'algorithm.remove', [str(algorithm['algorithm_id'])])
def main():
dev = device.Device('192.168.1.123', 'admin', 'Cisco.com', 'FakeTest2')
cmd_mgr = cmdmgr.CommandManager()
commands = cmd_mgr.get_commands()
facts = Facts(dev, commands)
facts.process_facts()
def monitor_devices():
print("do the monitor thing!")
while globVar.continueProcessing == 1:
# Get list of devices
result = subprocess.check_output(["arp-scan", "-l"])
# Parse list so it's in the form we want
result = result.partition(")\n")[2]
result = result.partition("\n\n")[0]
machines = result.split("\n")
for machine in machines:
sections = machine.split("\t")
mac = sections[1]
name = sections[2]
if already_in_lists(
mac
) == 0: # If it's not in the lists already, add to grey list
d = device.Device(mac, name)
globVar.greyListMutex.acquire()
try:
globVar.greyList.append(d)
finally:
globVar.greyListMutex.release()
# Also add it to the database
globVar.dbMutex.acquire()
try:
dbStuff.add_to_table(2, d)
finally:
globVar.dbMutex.release()
def set_colors(*colordef):
l = list(colordef)
defs = {}
while len(l) > 0:
key_target = l.pop(0).split(",")
col = l.pop(0)
for tgt in key_target:
if tgt == '--':
# special: applies color to all yet unused colors
for keycode in keys.others(defs.keys()):
defs[keycode] = colors.get(col)
for keycode in keys.get(tgt):
if keycode is None:
continue
defs[keycode] = colors.get(col)
if len(defs) == 0:
raise Exception("could not determine any color definitions")
COLOR_PAYLOAD = []
for keycode, color in defs.items():
COLOR_PAYLOAD += [keycode]
COLOR_PAYLOAD += color
with device.Device() as dev:
dev.send_colors(COLOR_PAYLOAD)
def test_part_one(self):
"Test part one example of Device object"
# 1. Create Device object from text
myobj = device.Device(text=aoc_16.from_text(PART_ONE_TEXT))
# 2. Check the part one result
self.assertEqual(myobj.part_one(verbose=False), PART_ONE_RESULT)
def __init__(self, args):
super().__init__()
self.device = dev.Device(args.dev, args.cfg)
if not self.device.cfg:
if __debug__:
log.error('Config was not loaded')
exit(-1)
def test_part_two(self):
"Test part two example of Device object"
# 1. Create Device object from text
myobj = device.Device(part2=True, text=aoc_16.from_text(PART_TWO_TEXT))
# 2. Check the part two result
self.assertEqual(myobj.part_two(verbose=False), PART_TWO_RESULT)
def __init__(self, context, prev, next, install):
Gtk.VBox.__init__(self)
self.prev = prev
self.next = next
self.install = install
self.context = context
intro_card = intro.Intro(self.context)
device_card = device.Device(self.context)
partition_card = partition.Partition(self.context)
timezone_card = timezone.Timezone(self.context)
locale_card = locale.Locale(self.context)
user_card = user.User(self.context)
root_card = root.Root(self.context)
finalinfo_card = finalinfo.FinalInfo(self.context)
status_card = status.Status(self.context)
self.card_names = [
'intro_card', 'device_card', 'partition_card', 'timezone_card',
'locale_card', 'user_card', 'root_card', 'finalinfo_card',
'status_card'
]
self.cards = [
intro_card, device_card, partition_card, timezone_card,
locale_card, user_card, root_card, finalinfo_card, status_card
]
self.the_stack = Gtk.Stack()
self.the_stack.set_hexpand(True)
self.the_stack.set_vexpand(True)
self.context['the_stack'] = self.the_stack
self.pack_start(self.the_stack, True, True, 0)
self.set_name('stack')
# add the cards to the stack
self.the_stack.add_titled(intro_card, 'intro_card', 'Introduction')
self.the_stack.add_titled(device_card, 'device_card', 'Device')
self.the_stack.add_titled(partition_card, 'partition_card',
'Partition')
self.the_stack.add_titled(timezone_card, 'timezone_card', 'Timezone')
self.the_stack.add_titled(locale_card, 'locale_card', 'Locale')
self.the_stack.add_titled(user_card, 'user_card', 'User')
self.the_stack.add_titled(root_card, 'root_card', 'Root')
self.the_stack.add_titled(finalinfo_card, 'finalinfo_card',
'Confirmation')
self.the_stack.add_titled(status_card, 'status_card', 'Status')
self.prev.connect('clicked', self.nav_prev)
self.next.connect('clicked', self.nav_next)
self.current_card = self.card_names[0]
self.current_index = 0
self.prev.set_sensitive(False)
self.install.set_sensitive(False)
def main():
cmd_mgr = cmdmgr.CommandManager()
commands = cmd_mgr.get_commands()
devices = cmd_mgr.get_devices()
for currentDevice in devices:
dev = device.Device(currentDevice['IP'],currentDevice['User'],currentDevice['Password'],currentDevice['DeviceName'])
print dev
devFactsRetriever = facts.Facts(dev, commands)
devFactsRetriever.process_facts()
def populate_lists():
conn = sqlite3.connect('compSec_db.sqlite')
cur = conn.cursor()
# cur.execute('DROP TABLE greyList')
# conn.commit()
# Create the tables if they don't exist
cur.execute('CREATE TABLE IF NOT EXISTS blackList(macAddress VARCHAR, name VARCHAR)')
conn.commit()
cur.execute('CREATE TABLE IF NOT EXISTS allowedList(macAddress VARCHAR, name VARCHAR)')
conn.commit()
cur.execute('CREATE TABLE IF NOT EXISTS greyList(macAddress VARCHAR, name VARCHAR)')
conn.commit()
# Populate blackList
cur.execute('SELECT * FROM blackList')
data = cur.fetchall()
for datum in data:
macAddress = datum[0]
name = datum[1]
d = device.Device(macAddress, name)
globVar.blackList.append(d)
# Populate allowedList
cur.execute('SELECT * FROM allowedList')
data = cur.fetchall()
for datum in data:
macAddress = datum[0]
name = datum[1]
d = device.Device(macAddress, name)
globVar.allowedList.append(d)
# Populate greyList
cur.execute('SELECT * FROM greyList')
data = cur.fetchall()
for datum in data:
macAddress = datum[0]
name = datum[1]
d = device.Device(macAddress, name)
globVar.greyList.append(d)
conn.close()
def test_empty_init(self):
"Test the default Device creation"
# 1. Create default Device object
myobj = device.Device()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
self.assertEqual(myobj.obs, None)
self.assertEqual(myobj.program, None)
def test_text_init(self):
"Test the Device object creation from text"
# 1. Create Device object from text
myobj = device.Device(text=aoc_16.from_text(EXAMPLE_TEXT))
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 9)
self.assertEqual(len(myobj.obs), 1)
self.assertEqual(len(myobj.program), 3)
def init(cfg, channel):
dev = device.Device(cfg.get("room"))
sensors = load_sensors(cfg)
for s in sensors:
room = cfg.get("room")
channel.sensor_init(sensor_id=s.id(),
device=dev.template(),
templates=s.templates(dev.id(), room),
room=room)
return sensors
def print_uievents(serial):
# mon = monitor.monitor_cmd(["adb", "shell", "uiautomator", "events"],
# functools.partial(event_output_cb, cb))
import device
dev = device.Device(serial, no_uimon=True)
mon = monitor_uievent(print_event, dev=dev)
while True:
cmd = input(">")
if cmd == 'q':
mon.kill()
os._exit(0)
else:
mon.input(cmd)
def check_act_once(serial):
subprocess.call("adb -s %s shell input keyevent HOME" % serial, shell=True)
dev = device.Device(serial=serial, no_uimon=True)
actname = sense.grab_actname(dev)
if actname is None:
print("can't get activity name")
return False
if 'launcher' in actname:
print("at launcher")
return True
else:
print("at %s, not launcher" % actname)
return False
def __init__(self, cores):
self.device = device.Device(cores)
self.dirs = []
self.files = {'/ctrl': self.device.ctrl}
for i in range(cores):
self.dirs.append('/unit{}'.format(i))
self.files[self.dirs[-1] + '/lram'] = self.device.units[i].lram
self.files[self.dirs[-1] + '/pram'] = self.device.units[i].pram
creation_time = time.time()
common_fields = dict(st_uid=os.getuid(), st_gid=os.getgid(), **{x:creation_time for x in ['st_ctime', 'st_mtime', 'st_atime']})
self.dir_stat = dict(st_mode=(S_IFDIR | 0o755), st_nlink=1, **common_fields)
self.file_stat = dict(st_mode=(S_IFREG | 0o644), st_nlink=1, st_size=0, **common_fields)
def move_to_blacklist():
#get selection
index = greyTab.curselection()[0]
selection = greyTab.get(index)
#remove from grey tab, add to black tab
greyTab.delete(index)
blackTab.insert(tkinter.END, selection)
#remove from grey data table, add to black data table
device_info = selection.split(" ", 1)
obj = device.Device(device_info[0], device_info[1])
dbStuff.remove_from_table(2, obj)
dbStuff.add_to_table(0, obj)
def del_device(self):
"""
delete all devices
"""
global deviceList
deviceList = []
common.Log.info("delete all devices")
deviceObj = device.Device(app_type)
deviceObj.del_device()
for i in range(2):
self.device.setItem(i, 0, QTableWidgetItem(""))
for j in range(2):
self.device.setItem(i, j, QTableWidgetItem(""))
self.statusEdit.setText("")
