def get_bridges(self):
"""Return a list of all Bridges from Asterisk"""
result = self._api.call('bridges', http_method='GET')
# Temporary until method is implemented
result_list = [Bridge(self._api), Bridge(self._api)]
#bridges = [Bridge(x) for x in result]
return result_list
def main():
pygame.init()
screen_size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption(GAME_NAME)
done = False
clock = pygame.time.Clock()
#TEST
db.create_connection(DB_PATH)
c = db.connect(DB_PATH)
b = Bridge("b1", 1, 1, 1, 1, 1, 1, 1, 1)
db.add_bridge(c, b)
#/TEST
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
screen.fill((0, 0, 0))
clock.tick(60)
pygame.display.flip()
pygame.quit()
def __init__(self):
r'''Create a new simulator interface.
'''
# Simulator ID.
self.sid = None
# DBW activation status.
self.dbw_enable = False
# Message buffer.
self.msgs = {}
# Bridge object between ROS and simulator.
self.bridge = Bridge(conf, self.send)
# Enforce use of eventlet for asynchronous operations.
self.sio = socketio.Server(async_mode='eventlet')
# Register event handlers
self.sio.on('connect', self.connect)
self.sio.on('telemetry', self.telemetry)
self.sio.on('control', self.control)
self.sio.on('obstacle', self.obstacle)
self.sio.on('lidar', self.lidar)
self.sio.on('trafficlights', self.trafficlights)
self.sio.on('image', self.image)
def main():
rospy.init_node('tr_hat_bridge')
bridge = Bridge()
rospy.spin()
def __init__(self):
self.width = 1400
self.screenWidth = 170
self.height = 45
self.grid = [[' ' for i in range(self.width)]
for j in range(self.height)]
self.getch = getInput._getChUnix()
self.bricks = []
self.enemies = []
self.smartEnemies = []
self.bullets = []
self.bridge = Bridge()
self.boss = Boss()
self.coins = []
self.bossBullets = []
self.springs = []
self.black = '\u001b[30;1m'
self.red = '\u001b[31;1m'
self.green = '\u001b[32;1m'
self.yellow = '\u001b[33;1m'
self.blue = '\u001b[34;1m'
self.magenta = '\u001b[35;1m'
self.cyan = '\u001b[36;1m'
self.white = '\u001b[37;1m'
self.reset = '\u001b[0m'
def init_adv(adv_env_id, disable_adv=False, env_kwargs=None):
bridge = Bridge()
default_env_kwargs = {
'renders' if 'CartPole' in adv_env_id else 'render': render
}
if env_kwargs is None:
env_kwargs = {}
env_kwargs.update(default_env_kwargs)
env = make_vec_env(adv_env_id, env_kwargs=env_kwargs, seed=seed)
env = VecNormalize(env)
prot_agent = PPO('MlpPolicy',
env,
verbose=verbose,
seed=seed,
n_steps=ts,
bridge=bridge,
is_protagonist=True)
if disable_adv:
bridge.link_agents(prot_agent, None)
else:
adv_agent = PPO('MlpPolicy',
env,
verbose=verbose,
seed=seed,
n_steps=ts,
bridge=bridge,
is_protagonist=False)
bridge.link_agents(prot_agent, adv_agent)
return prot_agent, env
def __init__(self,screen):
self.screen = screen
# get everything set up
self.clock = pygame.time.Clock()
self.font = pygame.font.Font(None, 18) # font object
#self.canvas = olpcgames.canvas
self.joystickobject = None
self.debug = True
# create the name --> instance map for components
self.tb_rects = {}
self.toolList = {}
for c in tools.allTools:
self.toolList[c.name] = c(self)
self.currentTool = self.toolList[tools.allTools[0].name]
# set up the world (instance of Elements)
self.world = elements.Elements(self.screen.get_size())
self.world.renderer.set_surface(self.screen)
# set up static environment
#self.world.add.ground()
self.world.run_physics = False
self.bridge = Bridge(self)
self.bridge.create_world()
def main_loop(server_ip, server_port, bridge_name, physical_interface_name,
tap_name, mac_address, ip_address, netmask):
if tap_name is None:
tap_name = b'\x00'
if type(physical_interface_name) is str:
physical_interface_name = physical_interface_name.encode()
print(f"[*] Connecting to server:{server_ip}:{server_port}")
capturer_client_ssl, capturer_client = create_ssl_socket(
server_ip, server_port)
injector_client_ssl, injector_client = create_ssl_socket(
server_ip, server_port)
try:
with Tap(tap_name, ip_address, netmask, mac_address) as device:
print_device_info(device)
with Bridge(bridge_name) as bridge:
print(f"[*] Created device: {bridge}")
bridge.add_interface(physical_interface_name)
bridge.add_interface(device.tap_name)
init_client_injector_socket(injector_client_ssl)
init_client_capturer_socket(capturer_client_ssl)
try:
communication_loop(device, injector_client_ssl,
capturer_client_ssl)
finally:
print(f"\n[*] Closing tap device: {device}")
finally:
print("[*] Closing server connection!")
# Close all sockets
capturer_client_ssl.close()
capturer_client.close()
injector_client_ssl.close()
injector_client.close()
def startup():
# Set up the Flask server we'll be using
# Set up the DB/Box/Kobo bridge
global datastore
global server
bridge = Bridge("env/config.toml")
# Load the data if it exists, otherwise populate from
# online resources
if os.path.exists(SAVE_FILE):
with open(SAVE_FILE, "rb") as handle:
datastore = pickle.load(handle)
else:
datastore.sites, datastore.labs = get_labs(bridge)
get_submissions(datastore.sites, bridge, datastore)
print(datastore.sites.keys())
# get_kobo_forms(bridge)
datastore.save(SAVE_FILE)
for site_code in datastore.sites:
print(datastore.sites[site_code].submissions.keys())
for subj in datastore.sites[site_code].submissions:
print(site_code, subj, datastore.sites[site_code].submissions[subj])
# Create a server to show the data
app.run()
def run():
bg = Bridge(show, "/usb_cam/image_raw", resize=0.75)
try:
rospy.spin()
except KeyboardInterrupt:
print "Exiting..."
cv2.destroyAllWindows()
def create_bridge(self, params):
"""In Asterisk, bridge two or more channels. Return the Bridge."""
result = self._api.call('bridges', http_method='POST',
parameters=params)
# Temporary until method is implemented
result = Bridge(self._api)
return result
def add_bridge(self, cfg: Config) -> None:
"""
Adds a new bridge based on the settings specified in the Config *cfg*.
"""
self.bridge_lock.acquire()
self.bridges.append(Bridge(cfg))
self.bridge_lock.release()
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.create_request()
else:
self.result_error('Invalid data provided')
def get_bridge(self, object_id):
"""Return Bridge specified by object_id."""
result = self._api.call('bridges', http_method='GET',
object_id=object_id)
# Temporary until method is implemented
result = Bridge(self._api)
#bridge = Bridge(result)
return result
def add_bridges(self, cfgs: List[Config]) -> None:
"""
Adds new bridges based on the settings supplied in the list of Config
objects in *cfgs*.
"""
self.bridge_lock.acquire()
for cfg in cfgs:
self.bridges.append(Bridge(cfg))
self.bridge_lock.release()
def __init__(self, input):
self.base_url = "https://api.openai.com/v1/engines/davinci/completions"
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def create_bridge(self, tg_group_id, irc_server_description, channel, token, validated=False, save_to_db=False,
only_add_channel=False):
irc_connection = self.irc_connections.get_or_create_irc_server_by_description(irc_server_description)
irc_channel = irc_connection.join_channel(channel, only_add=only_add_channel)
bridge = Bridge(irc_channel, tg_group_id, validated, self, token)
self.bridges[tg_group_id] = bridge
if save_to_db:
dbc = DatabaseConnection()
dbc.add_bridge(bridge)
return True
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.hashtag = self.request_data.get('hashtag', '')
self.username = self.request_data.get('username', '')
self.create_request()
else:
self.result_error('No data provided')
def __init__(self, input):
self.id = input.get('id', '1')
self.request_data = input.get('data')
self.result_json = "N/A"
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def __init__(self, input, secret_key: str = None):
self.id = input.get('id', '1')
self.secret_key = secret_key
self.request_data = input.get('data')
if self.validate_request_data() and self.secret_key:
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error(
'No data or API secret key provided for the adapter')
def restart_bridge_on_error(bridge) -> None:
try:
message = bridge.cfg.q_manage_out.get_nowait()
if message == 'Error':
cfg = bridge.cfg
name = cfg.name
print('Error in {0}, restarting...'.format(name))
bridge = Bridge(bridge.cfg)
print('Restarted {0}!'.format(name))
except Empty:
pass
def __init__(self, input, image_checker, image_manager):
self.image_cheker = image_checker
self.image_manager = image_manager
self.id = input.get('id', '1')
self.result = "" #kostil
self.request_data = input.get('data')
if self.validate_request_data():
self.bridge = Bridge()
self.set_params()
self.create_request()
else:
self.result_error('No data provided')
def fromDeck(deck, L, anchorOffset, H, q, qArch, segments=None):
if type(deck) == list:
deckCoords = map(lambda v: v - Vector(y=anchorOffset), deck)
else:
if segments == None:
raise Exception("segments needed if deck is function")
deckCoords = getDeckCoords(deck, L, segments, anchorOffset)
archCoords = getStartingArch(deckCoords)
sgsm = iterate(archCoords, deckCoords, H, q, qArch, .01)
bridge = Bridge(sgsm, deckCoords)
return bridge
def __init__(self, wss):
self.wss = wss
self.bridge = Bridge(conf, self)
self.dbw_enable = False
self.clients = get_clients()
self.steer_data = {}
self.throttle_data = {}
self.brake_data = {}
self.path_data = {}
self.path_init = False
self.brake_init = False
self.throttle_init = False
self.steer_init = False
def __init__(self, laz_file, shp_file, output, interpolation=0):
self.interpolation = interpolation # if 0 cosine interpolation, if 1 hermite interpolation
self.laz = LazManipulator(laz_file)
self.output = output
shp = ShapefileReader(shp_file)
self.bridges_shp = shp.bridgesInsideCoords(self.laz.x_min,
self.laz.y_min,
self.laz.x_max,
self.laz.y_max)
self.bridges = [Bridge(br) for br in self.bridges_shp]
# shp.writeBridges(self.laz.x_min, self.laz.y_min, self.laz.x_max, self.laz.y_max, "CESTE_SHORT3")
print("Reading points now")
self.points = self.getRelevantLazPoints(self.bridges, self.laz.laz)
def main():
config = dict(
sharedmem_path="config/sharedmem.json",
accel_offset_x=1.01112,
accel_offset_y=1.00765,
accel_offset_z=0.96534,
gyro_offset_x=2.843,
gyro_offset_y=-6.056,
gyro_offset_z=-1.603,
wheel_diameter_m=0.0545,
)
bridge = Bridge(**config)
bridge.run()
def __main__(self, running, socket=None):
if socket is not None:
manager = Manager()
bridge = Bridge(manager, socket=socket)
self.register(manager)
manager.start()
try:
self.run()
finally:
if socket is not None:
while bridge or manager:
pass
manager.stop()
bridge.stop()
def __init__(self, system_settings, websocket, snmp_websocket, **kwargs):
super(SleepyMeshBase, self).__init__(**kwargs)
if 'last_syncs' not in self._defaults:
self._defaults.update({'last_syncs': list()})
# Internal Members #
self._mesh_awake = True
self._sync_type = 'timeout'
self._save_in_progress = False
self._sync_average = None
self._delay_average = None
# Instances #
# TODO: Eliminate as many dependencies as possible
self.system_settings = system_settings
self.websocket = websocket
self.snmp_websocket = snmp_websocket
self.modbus_server = ModbusServer()
self.snmp_server = SNMPTrapServer(self)
self.update_interfaces = UpdateInterfaces(self)
self.update_in_progress = self.update_interfaces.update_in_progress
self.bridge = Bridge(self.system_settings)
self.uploader = Uploader(self)
self.nodes = Nodes(self.system_settings)
self.platforms = Platforms(self.nodes)
self.networks = Networks(self)
self.error = BaseError(self.system_settings)
if self.system_settings.modbus_enable:
system_settings_dict = self.system_settings.attr_dict()
# LOGGER.debug('Modbus Attribute Dictionary: ' + str(system_settings_dict))
self.modbus_server.start(system_settings_dict)
if self.system_settings.snmp_enable:
self.snmp_server.start()
# Overload Node Error Methods (SNMP Error Methods)#
NodeError.send_snmp = self.snmp_server.send_snmp
NodeError.clear_snmp = self.snmp_server.clear_snmp
def parsing(self, value):
if 'vertices' in value:
for i in value['vertices']:
tmpVertex = Vertex()
tmpVertex.parsing(i)
self.verticesList.append(tmpVertex)
if 'streets' in value:
for i in value['streets']:
tmpStreet = Street()
tmpStreet.parsing(i)
self.streetsList.append(tmpStreet)
if 'bridges' in value:
for i in value['bridges']:
tmpBridge = Bridge()
tmpBridge.parsing(i)
self.bridgesList.append(tmpBridge)
if 'weight' in value:
self.weight.parsing(value['weight'])
class Map(object):
scenes = {
'central_corridor': CentralCorridor(),
'death': Death(),
'finished': Planet(),
'armory': Armory(),
'bridge': Bridge(),
'pod': EscapePod()
}
def __init__(self, start_scene):
self.start_scene = start_scene
def next_scene(self, scene_name):
val = Map.scenes.get(scene_name)
return val
def opening_scene(self):
return self.next_scene(self.start_scene)
