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)