def main(): global connector global detector # Get port argument if len(sys.argv) < 2: raise Exception("Missing port argument") port = None try: port = int(sys.argv[1]) if type(port) is not int or port < 1 or port > 65535: raise Exception() except: raise TypeError( "Port argument must be an integer between 1 and 65535 (inclusive)") # Connect to server connector = Connector(port, message_received) # Start Detector detector = Detector(new_detections) detector.start_detections() # Notify server that the client has started connector.send_message(Message(100, "{}")) # Keep the program alive detector._thread.join()
def addConnectors(self): for i in range(self.mapBorder, self.width - self.mapBorder): for j in range(self.mapBorder, self.height - self.mapBorder): for k in range(-1, 2, 2): if self.tiles[i - 1][j] != self.tiles[ i + 1][j] and self.tiles[i][j] == 0 and self.tiles[ i - 1][j] != 0 and self.tiles[ i + 1][j] != 0 and self.tiles[ i - 1][j] != 1000 and self.tiles[ i + 1][j] != 1000: self.tiles[i][j] = 1000 self.connectors.append( Connector( len(self.connectors) + 1, i, j, self.tiles[i - 1][j], self.tiles[i + 1][j], 0)) if self.tiles[i][j - 1] != self.tiles[i][ j + 1] and self.tiles[i][j] == 0 and self.tiles[i][ j - 1] != 0 and self.tiles[i][ j + 1] != 0 and self.tiles[i][ j - 1] != 1000 and self.tiles[i][ j + 1] != 1000: self.tiles[i][j] = 1000 self.connectors.append( Connector( len(self.connectors) + 1, i, j, self.tiles[i][j + 1], self.tiles[i][j - 1], 0))
def __init__(self, type, id_zamowienia): super().__init__() self.setWindowTitle("Podgląd zamówienia") self.layout = QVBoxLayout() if type == "ekwipunek": info = create_info_box( '"Zamowienie-ekwipunek"', id_zamowienia, "id_zamowienia", int, ["id_zamowienia", "koszt", "data_zam", "deadline"]) numer_seryjny = Connector.get_filtered( "ekwipunek", ["numer_seryjny"], " WHERE id_zamowienia = " + str(id_zamowienia))[0][0] ekwipunek = create_info_box( "ekwipunek", numer_seryjny, "numer_seryjny", int, ["typ", "producent", "model", "numer_seryjny"]) ekwipunek.setTitle("Ekwipunek") self.layout.addWidget(info) self.layout.addWidget(ekwipunek) else: info = create_info_box( '"Zamowienie-pojazd"', id_zamowienia, "id_zamowienia", int, ["id_zamowienia", "koszt", "data_zam", "deadline"]) id_pojazdu = Connector.get_filtered( "pojazdy", ["id_pojazdu"], " WHERE id_zamowienia = " + str(id_zamowienia))[0][0] pojazd = create_info_box( "pojazdy", id_pojazdu, "id_pojazdu", int, ["rodzaj", "producent", "model", "id_pojazdu"]) pojazd.setTitle("Pojazd") self.layout.addWidget(info) self.layout.addWidget(pojazd) self.setMinimumSize(300, 230) self.setLayout(self.layout)
def __init__(self, server, options): Connector.__init__(self, "ig.com", server, options) self._host = "ig.com" self._base_url = "/api/v2/" self._timeout = 7 self._connected = False self._server = server # config self._host = options['connector'].get('host', "ig.com") self._account_id = options['connector'].get('accountId', "") self.__username = options['connector'].get('username', "") self.__password = options['connector'].get('password', "") self.__api_key = options['connector'].get('apiKey', "") self._session = None self._ig_service = None self._client_id = None self._lightstreamer = None self._account_type = "LIVE" if self._host == "api.ig.com" else "DEMO" self._cached_tick = {} # last cached tick when none value self._ig_tick_subscriptions = {} # tick subscriptions id per market id # trader capacity, instanciate it self._trader = IGTrader(self)
def __init__(self, id_jednostki): super().__init__() self.unit_id = id_jednostki self.setWindowTitle("Przydziały") self.setMinimumSize(400, 350) #self.listTab1 = None #self.refresh_eq_assignments() #self.listTab2 = None #self.refresh_vh_assignments() self.listTab1 = self.create_list_tab( ["Od", "Do", "PESEL oficera", "Numer seryjny"], Connector.get_filtered( '"Przydzial-ekwipunek"', ["data_od", "data_do", "pesel_oficera", "numer_seryjny"], " WHERE (SELECT id_jednostki FROM oficerowie WHERE pesel LIKE pesel_oficera) = " + self.unit_id + " AND (data_do >= current_date OR data_do is NULL) " + " ORDER BY data_od DESC"), "ekwipunek") self.insertTab(0, self.listTab1, "Ekwipunek") self.listTab2 = self.create_list_tab( ["Od", "Do", "PESEL oficera", "ID pojazdu"], Connector.get_filtered( '"Przydzial-pojazd"', ["data_od", "data_do", "pesel_oficera", "id_pojazdu"], " WHERE (SELECT id_jednostki FROM oficerowie WHERE pesel LIKE pesel_oficera) = " + self.unit_id + " AND (data_do >= current_date OR data_do is NULL) " + " ORDER BY data_od DESC"), "pojazdy") self.insertTab(1, self.listTab2, "Pojazdy") self.addWindow = None self.deleteWindow = None self.previewWindow = None self.setCurrentIndex(0)
def runConnectorRefused(): confi['configs'][0]['parameters'][0]['state'] = 'BEGIN' confi['configs'][0]['parameters'][0]['action'] = 'BEGIN' confi['configs'][0]['parameters'][0]['flags'] = 'RPA' con = Connector(confi, debug=3) con.runbg() return con
def setUp(self): c = omero.client( pmap=['--Ice.Config=' + (os.environ.get("ICE_CONFIG"))]) try: self.root_password = c.ic.getProperties().getProperty( 'omero.rootpass') omero_host = c.ic.getProperties().getProperty('omero.host') finally: c.__del__() blitz = Server.find(host=omero_host) if blitz is None: Server.reset() for s in settings.SERVER_LIST: server = (len(s) > 2) and unicode(s[2]) or None Server(host=unicode(s[0]), port=int(s[1]), server=server) Server.freeze() blitz = Server.find(server=omero_host) if len(blitz): self.server_id = blitz[0].id connector = Connector(self.server_id, True) self.rootconn = connector.create_connection( 'TEST.webadmin', 'root', self.root_password) if self.rootconn is None or not self.rootconn.isConnected( ) or not self.rootconn.keepAlive(): raise exceptions.Exception("Cannot connect") else: raise exceptions.Exception("'%s' is not on omero.web.server_list" % omero_host)
def confirm(self): rodzaj = self.rodzaj.currentText() producent = self.producent.text() model = self.model.text() masa = self.masa.text() zaloga = self.zaloga.text() zasieg = self.zasieg.text() rok = self.rok.text() rejestracja = self.rejestracja.text() if rejestracja == "": rejestracja = None id_zamowienia = None if self.id_pojazdu is not None: if (Connector.update_row("pojazdy", [ "rodzaj", "producent", "model", "rok_produkcji", "masa", "liczba_zalogi", "zasieg", "rejestracja", "status" ], [ rodzaj, producent, model, rok, masa, zaloga, zasieg, rejestracja, self.status ], self.id_pojazdu, "id_pojazdu", int)): self.commited.emit() self.close() else: if (Connector.create_vehicle([ rodzaj, producent, model, masa, zaloga, zasieg, self.status, rok, rejestracja, self.id_jednostki, id_zamowienia ])): self.commited.emit() self.close()
def create_info_box(tablename, id, idname, idtype, columns=None): box = QGroupBox("Informacje") layout = QFormLayout() if columns is not None: data = Connector.get_dict(tablename, columns, id, idname, idtype) else: data = Connector.get_dict(tablename, column_names[tablename], id, idname, idtype) if tablename == "pojazdy" and data["status"] == "Zamówiony": ex_columns = [ "rodzaj", "producent", "model", "rok_produkcji", "masa", "liczba_zalogi", "zasieg", "rejestracja", "id_jednostki", "status", "id_zamowienia" ] data = Connector.get_dict(tablename, ex_columns, id, idname, idtype) if tablename == "ekwipunek" and data["status"] == "Zamówiony": ex_columns = [ "typ", "producent", "model", "numer_seryjny", "data_produkcji", "data_waznosci", "status", "id_zamowienia" ] data = Connector.get_dict(tablename, ex_columns, id, idname, idtype) font = QFont() font.setBold(True) for k, v in data.items(): if v is None: label = QLabel(str("-")) else: label = QLabel(str(v)) label.setFont(font) layout.addRow(formatter[k] + ": ", label) box.setLayout(layout) return box
def test_loginFromForm(self): params = { 'username': '******', 'password': self.root_password, 'server':self.server_id, 'ssl':'on' } request = fakeRequest(method="post", params=params) server_id = request.REQUEST.get('server') form = LoginForm(data=request.REQUEST.copy()) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password'] server_id = form.cleaned_data['server'] is_secure = toBoolean(form.cleaned_data['ssl']) connector = Connector(server_id, is_secure) conn = connector.create_connection('OMERO.web', username, password) if conn is None: self.fail('Cannot connect') conn.seppuku() if conn.isConnected() and conn.keepAlive(): self.fail('Connection was not closed') else: errors = form.errors.as_text() self.fail(errors)
def __init__(self, slave = False, protocol = None, address = None, port = None, target_name = None): self.config = Configurator() self.is_connected = False self.is_slave = slave self.parameters = None self.datastream_queue = None self.datastream_poller = None self.datastream_collector = None self.signal_structure = None # Sets basic configurations if protocol: self.config.setAttr('protocol', protocol) if address: self.config.setAttr('address', address) if port: self.config.setAttr('port', port) if target_name: self.config.setAttr('target_name', target_name) # Initializes connection self.connection = Connector(self.config)
def confirm(self): data_od = self.data_od.text() data_do = self.data_do.text() oficer = self.oficerowie[self.oficer.currentIndex()][2] if self.type == "ekwipunek": ekwipunek = self.eq[self.ekwipunek.currentIndex()][3] if (Connector.insert_row( '"Przydzial-ekwipunek"', ["data_od", "data_do", "pesel_oficera", "numer_seryjny"], [data_od, data_do, oficer, ekwipunek])): if Connector.update_row("ekwipunek", ["status"], ["Przydzielony"], ekwipunek, "numer_seryjny", int): self.commited.emit() self.close() else: pojazd = self.vh[self.pojazdy.currentIndex()][2] if (Connector.insert_row( '"Przydzial-pojazd"', ["data_od", "data_do", "pesel_oficera", "id_pojazdu"], [data_od, data_do, oficer, pojazd])): if Connector.update_row("pojazdy", ["status"], ["Przydzielony"], pojazd, "id_pojazdu", int): self.commited.emit() self.close()
def upload_livery(): user = validate_request(request.headers) if not user: abort(401) if not os.path.exists(download_dir): os.mkdir(download_dir) filename = str(uuid.uuid4()) + '.zip' if not 'file' in request.files\ or not 'Name' in request.form\ or not 'Checksum' in request.form: abort(400) liv = Livery() liv.name = request.form['Name'][:50] # limited to 50 chars liv.checksum = request.form['Checksum'][:40] # limited to 40 liv.filename = filename liv.owner_id = user.id if Connector.get_livery_by_name(liv.name): abort(409) # livery duplicate liv = Connector.add_livery(liv) data = request.files['file'] data.save(download_dir + filename) return jsonify(liv.to_json())
def setUp (self): c = omero.client(pmap=['--Ice.Config='+(os.environ.get("ICE_CONFIG"))]) try: self.root_password = c.ic.getProperties().getProperty('omero.rootpass') omero_host = c.ic.getProperties().getProperty('omero.host') finally: c.__del__() blitz = Server.find(host=omero_host) if blitz is None: Server.reset() for s in settings.SERVER_LIST: server = (len(s) > 2) and unicode(s[2]) or None Server(host=unicode(s[0]), port=int(s[1]), server=server) Server.freeze() blitz = Server.find(server=omero_host) if len(blitz): self.server_id = blitz[0].id connector = Connector(self.server_id, True) self.rootconn = connector.create_connection('TEST.webadmin', 'root', self.root_password) if self.rootconn is None or not self.rootconn.isConnected() or not self.rootconn.keepAlive(): raise exceptions.Exception("Cannot connect") else: raise exceptions.Exception("'%s' is not on omero.web.server_list" % omero_host)
def post(self): # Region Set Up #create resultService object _resultsService = ResultsService() #load queries q = Queries() # create connection to postgres database _connector = Connector() conn = _connector.connect(1) # create cursor cur = conn.cursor() #define query parameters _failID = self.get_argument("_failureId") # endregion # Region main block cur.execute(q._email_failure, (_failID, )) _result = cur.fetchall() _result_to_json = _resultsService.parse(_result) self.render("emailMonitor.html", results=_result) cur.close() conn.close
async def check(self, proxy: ProxyModel): logger.debug('Start Verify Proxy: %s' % proxy) proxy.usable = False judge = self.https_judge if proxy.protocol == 'https' else self.http_judge content = None conn = Connector(proxy.ip, proxy.port) negotiator = NGTRS[proxy.protocol.upper()](conn) try: await conn.connect() await negotiator.negotiate(judge) headers, content, hdrs = await _send_test_request( self._method, conn, negotiator, judge) content = _decompress_content(headers, content) judge.parse_response(proxy, content, hdrs) except ProxyError: pass except JSONDecodeError: # Config.logger.error('Json decode error when using %s' % proxy) logger.debug(content) except Exception as e: logger.error('Error: %s, type: %s' % (proxy, type(e)), exc_info=True) finally: conn.close() proxy.verified_at = datetime.datetime.now() self.finished += 1 logger.debug('Finished Proxy: %s' % (proxy)) return proxy
def post(self): # Region Set Up #create resultService object _resultsService = ResultsService() #load queries q = Queries() # create connection to postgres database _connector = Connector() conn = _connector.connect(2) # create cursor cur = conn.cursor() #define query parameters _firstname = self.get_argument("_firstname_field") _lastname = self.get_argument("_lastname_field") _timenow = datetime.datetime.now() # endregion # Region main block _query = q._get_all_users cur.execute(_query) _result = cur.fetchall() _result_to_json = _resultsService.parse(_result) _query = q._create_new_user cur.execute(_query, (_firstname, _lastname, _timenow)) conn.commit() cur.close() conn.close self.redirect("/users")
def post(self): # Region Set Up _resultsService = ResultsService() _q = Queries() _connector = Connector() conn = _connector.connect(2) cur = conn.cursor() # endregion # Region Main Block cur.execute(_q._get_all_users) _result = cur.fetchall() _result_to_json = _resultsService.parse(_result) for item in _result: _rID = str(item[3]) _id = self.get_arguments("_checkbox") if _rID in _id: print("Deleting " + str(item[0])) cur.execute(_q._delete_user, (item[3], )) conn.commit() cur.close() conn.close() self.redirect("/users")
def poolLoadTSV((tsv, ks_minor, units, db, ksm_filter, ksm_id, rename, host, port, is_json)): """ This function is used by multiprocess.Pool to populate framespace with a new dataframe. """ try: # register vectors and get the dataframe object for insert conn = Connector(db, host=host, port=port) if is_json: df_id = conn.registerDataFrame(tsv, ks_minor, units, is_json=is_json) else: df_id = conn.registerDataFrame( getDataFrame(tsv, ksminor_id=ksm_id, ksminor_filter=ksm_filter, rename=rename), ks_minor, units) except Exception, e: traceback.print_exc(file=sys.stdout) print "Error processing" print str(e) return (-1, tsv)
def add_insta(received): username = received['username'] password = received['password'] user = received['user'] conn = Connector() result = conn.add_insta(username, password, user) return result['message']
def schedule_posting(received): user = received['user'] img = received['img'] binary_image = received['binary_image'] subtitle = received['subtitle'] location = received['location'] instagram = received['instagram'] date = received['date'] date_image = f'{datetime.now().year}-' + f'{datetime.now().month}-' + f'{datetime.now().day}' BASE_DIR = os.path.dirname(os.path.abspath(__file__)) img_path = os.path.join(BASE_DIR, f"uploads/{date_image}-{user}-{img}") if date < datetime.now(): return 'Horario invalido' conn = Connector() result = conn.add_schedule(img_path, subtitle, location, instagram, date, user) if result['status'] != None: # Salvando a imagem na pasta upload com o nome padrão : yyyy-mm-dd-email-name.jpeg with open((img_path), 'wb') as f: f.write(binary_image) f.close() scheduler() time.sleep(1) return 'success' # return send_api(received, img_path) return result['message']
def setupGraphics(self): n1 = Nand2(self, "N1", self.scale1((80, 30))) # Nand Gate i1 = Inv(self, "I1") # Inverter for n1.A i2 = Inv(self, "I2") # Inverter for n1.B # external connectorself. Same depth as xor circuit i1.align(i1.B, n1.A, -40, -20) # inverter precedes Nand i2.align(i2.B, n1.B, -40, 20) # inverter precedes Nand self.A = Connector(self, "A", ((i1.A.x(-20), i1.A.y()))) self.B = Connector(self, "B", ((i2.A.x(-20), i2.B.y()))) self.C = Connector(self, "C", ((n1.C.x( 20), n1.C.y()))) self.output = self.C # who is output self.gates = (i1, i2, n1) self.i1, self.i2, self.n1 = (i1, i2, n1) i1.B.addWire(n1.A) i2.B.addWire(n1.B) self.A.addWire(i1.A) self.B.addWire(i2.A) n1.C.addWire(self.C) if self.encapsulated(): # if encapsulated re-work externals self.A.pos, self.B.pos, self.C.pos = self.scaleM(( 0, 5), ( 0, 35), (20, 20))
def __init__(self): rospy.init_node('Gateway', log_level=rospy.DEBUG) server_config_file = rospy.get_param("~server_config_file") self.config = Config(server_config_file) self.pf = ProtocolFactory(self.config) self.run_id = rospy.get_param("run_id") print("runid = ", self.run_id) self.node_list = rosnode.get_node_names() self.timer = Timer() self.monitor = Monitor(self.node_list, self.timer) self._server_request = {} # stores server_request self._event_bus = Queue() self._heartbeat_timeout_job = None self._tele_report_job = None self._report_car_job = None self._report_task_job = None self._service = DrivingTaskService(self._event_bus) self.__client = Connector(self._event_bus, self.config.host, self.config.port) self._handler_map = {} self._event_handler_map = {} self._add_command_handler() self._add_event_handler() self._web_server = WebServer(self.monitor, self._service, self.config) self._tele_control_service = TeleControlService()
def create_tabs(self): self.listTab1 = self.create_list_tab(["Oznaczenie", "Rola"], Connector.get_filtered("budynki", ["oznaczenie", "rola_budynku"], " WHERE id_jednostki = " + self.unit_id + " AND (UPPER(oznaczenie) LIKE UPPER('%" + self.filter_budynki.text() + "%')" + " OR UPPER(rola_budynku) LIKE UPPER('%" + self.filter_budynki.text() + "%'))" + " ORDER BY oznaczenie ASC"), "budynki") self.insertTab(1, self.listTab1, "Budynki") self.listTab2 = self.create_list_tab(["ID", "Producent", "Model"], Connector.get_filtered("pojazdy", ["id_pojazdu", "producent", "model"], " WHERE id_jednostki = " + self.unit_id + " AND (UPPER(model) LIKE UPPER('%" + self.filter_pojazdy.text() + "%')" + " OR UPPER(producent) LIKE UPPER('%" + self.filter_pojazdy.text() + "%'))" + " ORDER BY id_pojazdu ASC"), "pojazdy") self.insertTab(2, self.listTab2, "Pojazdy") self.listTab3 = self.create_list_tab(["Imię", "Nazwisko", "PESEL"], Connector.get_filtered("oficerowie", ["imie", "nazwisko", "pesel"], " WHERE id_jednostki = " + self.unit_id + " AND (UPPER(imie) LIKE UPPER('%" + self.filter_oficerowie.text() + "%')" + " OR UPPER(nazwisko) LIKE UPPER('%" + self.filter_oficerowie.text() + "%')" + " OR UPPER(pesel) LIKE UPPER('%" + self.filter_oficerowie.text() + "%'))" + " ORDER BY nazwisko, imie ASC"), "oficerowie") self.insertTab(3, self.listTab3, "Oficerowie")
def fill_gen_assign_workshop_attendee(): connector = Connector() conn = connector.connect(secretpassword) cursor = conn.cursor() workshop_attendees = [] cursor.execute("select distinct Attendees.AttendeeID, WorkshopReservations.WReservationID " "from Attendees " "inner join Participation on Participation.AttendeeID = Attendees.AttendeeID " "inner join Reservations on Reservations.ReservationID = Participation.ReservationID " "inner join WorkshopReservations on WorkshopReservations.ReservationID = Reservations.ReservationID") row = cursor.fetchone() while row: workshop_attendees.append((row[0], row[1])) row = cursor.fetchone() filler = Connector() workshop_attendees_size = len(workshop_attendees) filler.apply_proc_multi('AssignParticipantToWorkshop', workshop_attendees, workshop_attendees_size) conn.close()
def _generate_token_list(): return [ Connector.build(TerminalSymbol.OPEN), Variable.build('x'), Connector.build(TerminalSymbol.PLUS), Variable.build('y'), Connector.build(TerminalSymbol.CLOSE) ]
def setUp(self): with patch('connector.create_engine') as mocked_engine: with patch('connector.MetaData') as mocked_metadata: with patch('connector.Table') as mocked_table: mocked_table.return_value.columns = [ "Table", 'name', 'somethingelse'] self.inst = Connector( 'somedb', 'sometable', 'someesindex', 'somedb_type')
def get(self): self.render("index.html") conn = Connector() session = conn.r_connect() test = session.query(object_type=Timesheet).where_in( "NumericID", [1800, 1799]) for ts in test: print(ts.tsStatus)
def makeRequestFavico(): con = Connector(config, debug=3) con.runbg() my_IPaddress = "http://%s" % (get_my_IPaddress('eth0')) r = requests.get(my_IPaddress + '/favicon.ico', timeout=5) return r.text
def makeRequest500(): con = Connector(config, debug=3) con.runbg() my_IPaddress = "http://%s" % (get_my_IPaddress(config['interface'])) r = requests.get(my_IPaddress + '/500', timeout=5) return r
def find_point(self, t, method='arc_connect'): assert 0 <= t <= 1, 't must be between 0 and 1' weights_model_new = getattr(Connector(self.weights_model1, self.weights_model2_permuted), method)(t=t)[1] B = self.get_b(self.model1, self.model2) B = getattr(Connector(B[:1], B[1:]), method)(t=t)[1] m = self.get_model_from_weights(weights_model_new, B[0], self.architecture) m.cuda(); return m
def main(): config = SafeConfigParser() config.read(PROPERTIES_FILE) ctor = Connector(config) report = ctor.get_result() prsr = Parser() prsr.parse(report) prsr.format()
def fetch_news_by_feed_list(self, news_data): conn = Connector() for n in news_data['news_items']: print("INF: Fetching news page for '{}'".format(n['link'])) news_item_page = conn.send_req('GET', url=n['link']) if news_item_page is None: continue self.__get_article_from_html__(n, news_item_page.data)
def runConnectorEHOSTUNREACH(): confi['configs'][0]['parameters'][0]['sub-category'] = 'icmz' confi['configs'][0]['parameters'][0]['state'] = 'ESTABLISHED' confi['configs'][0]['parameters'][0]['action'] = 'sendAck' confi['configs'][0]['parameters'][0]['type'] = 3 confi['configs'][0]['parameters'][0]['code'] = 1 con = Connector(confi, debug=3) con.runbg() return con
def loginAsUser(self, username, password): blitz = Server.get(pk=self.server_id) if blitz is not None: connector = Connector(self.server_id, True) conn = connector.create_connection('TEST.webadmin', username, password) if conn is None or not conn.isConnected() or not conn.keepAlive(): raise Exception("Cannot connect") return conn else: raise Exception("'%s' is not on omero.web.server_list" % self.omero_host)
class MainController: def __init__(self, app): self.deviceData = DeviceData() self.view = MainView(None) self.view.scanForDevices.Bind(wx.EVT_BUTTON, self.ScanForDevices) self.view.syncActivities.Bind(wx.EVT_BUTTON, self.SyncActivities) self.view.Bind(wx.EVT_MENU, self.OnAbout, self.view.aboutMenuItem) self.view.Bind(wx.EVT_MENU, self.OnExit, self.view.exitMenuItem) self.view.Show() self.scanner = Scanner() ## TODO Preferences for Selected Scanners self.scanner.addScanner(AntScanner()) self.connector = Connector() ## TODO Preferences for Selected Connectors self.connector.addConnector(GarminConnector()) pub.subscribe(self.ScanningStarted, "SCANNING STARTED") pub.subscribe(self.DeviceDetected, "DEVICE DETECTED") pub.subscribe(self.ActivityRetrieved, "ACTIVITY RETRIEVED") pub.subscribe(self.ScanningEnded, "SCANNING ENDED") pub.subscribe(self.SyncStarted, "SYNC STARTED") pub.subscribe(self.SyncEnded, "SYNC ENDED") pub.subscribe(self.LoginSuccesful, "LOGIN SUCCESFUL") pub.subscribe(self.LoginFailed, "LOGIN FAILED") pub.subscribe(self.ActivitiesUploaded, "ACTIVITIES UPLOADED") def ScanForDevices(self, evt): self.scanner.scan() def ScanningStarted(self, evt): self.view.setStatus("Scanning started") def ScanningEnded(self, evt): self.view.setStatus("Scanning ended") def DeviceDetected(self, evt): self.view.setStatus("Device detected") def ActivityRetrieved(self, evt): self.view.setStatus("Retrieved activity") def SyncActivities(self, evt): self.connector.sync() def SyncStarted(self, evt): self.view.setStatus("Sync started") def SyncEnded(self, evt): self.view.setStatus("Sync ended") def LoginSuccesful(self, evt): self.view.setStatus("Login Succesful") def LoginFailed(self, evt): self.view.setStatus("Login Failed") def ActivitiesUploaded(self, evt): self.view.setStatus("Activities Uploaded") def OnExit(self,e): self.Close(True) def OnAbout(self, event): dlg = wx.MessageDialog( self.view, "A community-developed Linux version of the ANT Agent. Supports Garmin-based fitness devices that communicate either over USB serial or via the ANT USB connector. Developed by Philip Whitehouse, based on work by Braiden Kindt, Gustav Tiger and Collin (cpfair). Copyright 2014", "About ANT Agent for Linux", wx.OK); dlg.ShowModal() dlg.Destroy()
def inject_metric(self,quiet): if self.value == None: self.load_value() if quiet == False: self.print_metric() cw = Connector() retval = cw.inject(self.metricname,self.namespace,self.value,self.units,self.dimensions) if retval == -1: sys.stderr.write("\033[91mERROR: Monitor [" + self.monid + "] failed to be injected into CloudWatch.\n") sys.stderr.write(" -- Check JSON entry and that command is returning proper value and format.\033[0m\n")
def __init__(self, p12_path, p12_password, p12_buffer=None, production=True, request_timeout=2.0, proxy=None): self.connector = Connector(p12_path=p12_path, p12_password=p12_password, p12_buffer=p12_buffer, production=production, request_timeout=request_timeout, proxy=proxy)
def setUp (self): c = omero.client(pmap=['--Ice.Config='+(os.environ.get("ICE_CONFIG"))]) try: self.root_password = c.ic.getProperties().getProperty('omero.rootpass') self.omero_host = c.ic.getProperties().getProperty('omero.host') self.omero_port = c.ic.getProperties().getProperty('omero.port') Server.reset() Server(host=self.omero_host, port=self.omero_port) finally: c.__del__() self.server_id = 1 connector = Connector(self.server_id, True) self.rootconn = connector.create_connection('TEST.webadmin', 'root', self.root_password) if self.rootconn is None or not self.rootconn.isConnected() or not self.rootconn.keepAlive(): raise Exception("Cannot connect")
def __init__(self, ip, port, automatic = True, control_buf_size = 32, data_buf_size = 128, \ m_to = 0.01, socket_to = 0.005): """ Constructor, initialize the modem and the connector. Connect the modem to the submerged node @param self pointer to the class object @param ip string cointaining the IP address of the TCP server @param port string with the port of the TCP server socket @param control_buf_size: int with the control buffer size, in bytes @param data_buf_size: int with the data buffer size, in bytes @param m_to: float value time out of the cycle, in [s] @param socket_to: time out of the socket checking operation, [s] """ self.conn = Connector(ip, port, control_buf_size, data_buf_size, socket_to) self.conn.connect() self.m_to = m_to self.status = Modem.Status.IDLE self.node_status = 0 self.automatic = automatic self.interpreter = Interpreter() self.mainPID = os.getpid() self.error_status = Modem.ErrorDict.NONE self.commands_queue = "".split(Interpreter.END_COMMAND) if automatic: thread.start_new_thread(self.run,())
def __init__(self, slave=False, protocol=None, address=None, port=None, target_name=None): self.config = Configurator() self.is_connected = False self.is_slave = slave self.parameters = None self.datastream_queue = None self.datastream_poller = None self.datastream_collector = None self.signal_structure = None # Sets basic configurations if protocol: self.config.setAttr("protocol", protocol) if address: self.config.setAttr("address", address) if port: self.config.setAttr("port", port) if target_name: self.config.setAttr("target_name", target_name) # Initializes connection self.connection = Connector(self.config)
def __init__(self): # initialize file table self.maxFiles = 1024 # self.files = [dict(path=None, dirty=False, data=None)] * self.maxFiles self.files = [None] * self.maxFiles for i in range(0, self.maxFiles): self.files[i] = dict(path=None, dirty=False, data=None) self.conn = Connector()
def __init__(self, url, profile, store, assessor, notifications, update_interval = 180, name = "Unnamed Observer"): super(Observer, self).__init__() self._interval = update_interval self._connector = Connector(url, profile) self._store = store self._assessor = assessor self._notifications = notifications self._name = name self._quit = False self._time_mark = datetime.datetime.now() - datetime.timedelta(days = 1) self._state = Observer.RUNNING self.name = name
def clone_repo(src, dest): """ Clone a repository. Arguments: src -- URL of to the repository to clone from. dest -- URL of the target directory of the clone. Returns: A clone of the supplied repository. """ src_connector = Connector.from_string(src) with src_connector.connected(): origin = repo.Repo.load_from_disk(src_connector) dest = os.path.join(dest, origin.name) # make clone at "<dest>/<name>" dest_connector = Connector.from_string(dest) with dest_connector.connected(): clone = repo.Repo.clone(origin, dest_connector) init_repo_logging(clone) log.info("Cloned repository from %s to %s" % (src, dest)) return clone
def fill_gen_add_attendees(): connector = Connector() conn = connector.connect(secretpassword) cursor = conn.cursor() cursor.execute("select company.clientid, spotsreserved from company " "inner join clients on clients.clientid = company.clientid " "inner join reservations on reservations.clientid = clients.clientid") row = cursor.fetchone() c = Connector() cn = c.connect(secretpassword) while row: clientid = row[0] spots_reserved = row[1] for reservation in range(spots_reserved): name, surname = getNameSurname() result = (clientid, name, surname) print("Add Attendee " + str(result)) c.apply_proc('AddAttendee', result) row = cursor.fetchone() conn.close() cn.close()
def fill_gen_add_payment(): connector = Connector() conn = connector.connect(secretpassword) cursor = conn.cursor() cursor.execute("select ReservationID, ToPay, ReservationDate from Reservations") row = cursor.fetchone() ratio = [i / 10 for i in range(1, 11)] c = Connector() cn = c.connect(secretpassword) while row: reservationid = row[0] topay = row[1] date = row[2] money_deposited = math.floor(int(topay) * random.choice(ratio)) (y, m, d) = date.split("-") begin = dt.date(int(y), int(m), int(d)).toordinal() book_ord = dt.datetime.fromordinal(begin + random.randint(1, 7)) date_of_payment = "/".join((str(book_ord.year), str(book_ord.month), str(book_ord.day))) result = (reservationid, money_deposited, date_of_payment) print("Add Payment " + str(result)) c.apply_proc('GeneratorAddPayment', result) row = cursor.fetchone() conn.close() cn.close()
def fill_gen_book_places_for_workshop(): connector = Connector() conn = connector.connect(secretpassword) cursor = conn.cursor() cursor.execute("select Reservations.ReservationID, WorkshopID, MaxSpots " "from DaysOfConf " "inner join Workshops on Workshops.DayID = DaysOfConf.DayID " "inner join Reservations on Reservations.DayID = DaysOfConf.DayID") row = cursor.fetchone() c = Connector() cn = c.connect(secretpassword) while row: reservationid = row[0] workshopid = row[1] maxspots = math.floor(row[2] / 3) result = (reservationid, workshopid, maxspots) print("Add Workshop Reservation " + str(result)) c.apply_proc('BookPlacesForWorkshop', result) row = cursor.fetchone() conn.close() cn.close()
def generate_connections(self): connect = Connector() bond_types, angle_types, torsion_types, improper_types = self.molecule.connection_types() self.bonds = self.molecule.assign_bonds(self.lattice_dimensions) self.bond_labels = connect.bond_labels(self.atom_labels, self.bonds, bond_types) self.angles = connect.angles(self.bonds) self.angle_labels = connect.angle_labels(self.atom_labels, self.angles, angle_types) self.torsions = connect.torsions(self.bonds) self.torsion_labels = connect.torsion_labels(self.atom_labels, self.torsions, torsion_types) self.impropers = connect.impropers(self.bonds) self.improper_labels = connect.improper_labels(self.atom_labels, self.impropers, improper_types)
def test_loginFromRequest(self): params = { 'username': '******', 'password': self.root_password, 'server':self.server_id, 'ssl':'on' } request = fakeRequest(method="post", path="/webadmin/login", params=params) server_id = request.REQUEST.get('server') username = request.REQUEST.get('username') password = request.REQUEST.get('password') is_secure = toBoolean(request.REQUEST.get('ssl')) connector = Connector(server_id, is_secure) conn = connector.create_connection('TEST.webadmin', username, password) if conn is None: self.fail('Cannot connect') conn.seppuku() if conn.isConnected() and conn.keepAlive(): self.fail('Connection was not closed')
def fill_gen_assign_attendee(): connector = Connector() conn = connector.connect(secretpassword) cursor = conn.cursor() individual_participation = [] cursor.execute("select distinct Attendees.AttendeeID, Reservations.ReservationID " "from Attendees " "inner join Clients on Attendees.ClientID = Clients.ClientID " "inner join Reservations on Reservations.ClientID = Clients.ClientID " "inner join Individual on Individual.ClientID = Clients.ClientID") row = cursor.fetchone() while row: individual_participation.append((row[0], row[1])) row = cursor.fetchone() company_participation = [] cursor.execute("select distinct Attendees.AttendeeID, Reservations.ReservationID " "from Attendees " "inner join Clients on Attendees.ClientID = Clients.ClientID " "inner join Reservations on Reservations.ClientID = Clients.ClientID " "inner join Company on Company.ClientID = Clients.ClientID") row = cursor.fetchone() while row: company_participation.append((row[0], row[1])) row = cursor.fetchone() # Two list of (AttendeeID, ReservationID) to apply # The following lines may cause declination of IDE control xD # print(individual_participation) # print(len(individual_participation)) # print(company_participation) # print(len(company_participation)) # Those insertions causes error -> try block filler = Connector() individual_size = len(individual_participation) filler.apply_proc_multi('AssignAttendee', individual_participation, individual_size) company_size = len(company_participation) filler.apply_proc_multi('AssignAttendee', company_participation, company_size) conn.close()
def run(s): s.log.info('Started host node {0} on {1}'.format(s.nodename, s.address)) # Make some count of creator for i in range(0, s.creators): # Create instance creator = Creator(s.nodename) # Run thread creator.start() # Logging s.log.info('Started creator thread: {0}'.format(creator.name)) # Make connector connector = Connector(s.nodename) # Run connector thread connector.start() # Logging s.log.info('Started connector thread: {0}'.format(connector.name))
def test_loginFailure(self): params = { 'username': '******', 'password': '******', 'server':self.server_id } request = fakeRequest(method="post", params=params) server_id = request.REQUEST.get('server') form = LoginForm(data=request.REQUEST.copy()) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password'] server_id = form.cleaned_data['server'] is_secure = toBoolean(form.cleaned_data['ssl']) connector = Connector(server_id, is_secure) conn = connector.create_connection('OMERO.web', username, password) if conn is not None: self.fail('This user does not exist. Login failure error!') else: errors = form.errors.as_text() self.fail(errors)
def createConnector(self): self.view.statusBar().showMessage('connecting...') self.c = Connector(self.view.serverLineEdit.text(), self.view.userLineEdit.text(), self.view.passwdLineEdit.text(), '') print (self.c.getWikiVersion()) self.allPages = self.c.getAllPages() if (self.allPages != None): self.view.statusBar().showMessage('connected.') parentItem = self.pageModel.invisibleRootItem() for i in self.allPages: parentItem.appendRow(QStandardItem(i['id'])) self.connected = True else: self.view.statusBar().showMessage("Couldn't get pages.") print ("Couldn't get pages.")
def load_repo(url): """ Load an existing repository from disk and return it. Arguments: url -- URL of the repository on disk. Returns: The loaded repository. """ connector = Connector.from_string(url) with connector.connected(): rep = repo.Repo.load_from_disk(connector) init_repo_logging(rep) log.info("Loaded PictureClerk repository from disk") return rep
def init_repo(url): """ Initialize a new repository and return it. Arguments: url -- URL of the repository to be initialized (e.g. '/home/user/repo'). Returns: The initialized repository. """ config = repo.new_repo_config() connector = Connector.from_string(url) with connector.connected(): rep = repo.Repo.create_on_disk(connector, config) init_repo_logging(rep) log.info("Initialized empty PictureClerk repository") return rep
def __init__(self): QMainWindow.__init__(self) self.setupUi(self) # set up User Interface (widgets, layout...) self.registerAllParameters() # we register all command line arguments self.job = Connector(self) # connector object for submitting the command self.dirs = AdvancedChecks(self) # Object for performing all operations on dirs self.lastdir = self.dirs.homedir # set the starting open directory to HOME ## TODO: just for GUI testin self.afsaccount.setChecked(1) QObject.connect(self.setinputdirectory, SIGNAL("clicked()"),self.getInputDirectory) # data input directory QObject.connect(self.inputdirectory, SIGNAL("returnPressed()"),self.dirs.initInputDirectory) # data input through keyboard QObject.connect(self.sinogramdirectory, SIGNAL("returnPressed()"),self.dirs.initSinDirectory) # sinogram dir input through keyboard QObject.connect(self.setsinogramdirectory, SIGNAL("clicked()"),self.getSinogramDirectory) # sinogram output QObject.connect(self.setcprdirectory, SIGNAL("clicked()"),self.getCprDirectory) # cpr output QObject.connect(self.setfltpdirectory, SIGNAL("clicked()"),self.getFltpDirectory) # fltp output QObject.connect(self.setrecodirectory, SIGNAL("clicked()"),self.getRecoDirectory) # reconstructions output QObject.connect(self.sinon, SIGNAL("clicked()"),self.setUnsetSinoCheckBox) # sinogram checkbox ("toggled" not working) QObject.connect(self.paganinon, SIGNAL("clicked()"),self.setUnsetPaganinCheckBox) # Paganin checkbox ("toggled" not working) QObject.connect(self.openinfiji, SIGNAL("clicked()"),self.setUnsetFijiOn) # Fiji previw image checkbox ("toggled" not working) QObject.connect(self.submit, SIGNAL("released()"),self.submitToCluster) # BUTTON submit button QObject.connect(self.clearfields, SIGNAL("released()"),self.clearAllFields) # BUTTON clear all fields method QObject.connect(self.testbutton, SIGNAL("released()"),self.test_button) # BUTTON test button QObject.connect(self.singleslice, SIGNAL("released()"),self.calcSingleSlice) # BUTTON Single Slice calculation QObject.connect(self.menuloadsettings, SIGNAL("triggered()"),self.loadConfigFile) # MENU load settings QObject.connect(self.menusavesettings, SIGNAL("triggered()"),self.saveConfigFile) # MENU save settings
def transfer_gtfs_ckan(full_gtfs=False): # Pass full_gtfs as True if you want to import # all the GTFS data to CKAN. try: print 'Retrieving GTFS data from OST...', connector = Connector() if full_gtfs: connector.fetch_full_gtfs() print 'Done.' print 'Pushing GTFS files to CKAN\'s DataStore...', connector.push_to_ckan(gtfs_csv=True) else: connector.fetch_gtfs_stops() print 'Done.' print 'Importing Transit Stops to CKAN\'s DataStore...', connector.push_to_ckan() print 'Done.' except CKANError as error: message = Fore.RED + str(error) + Fore.RESET + ': ' + \ error.message print('\n> ' + message) except (APIKeyError, CrawlerError, OSTError) as error: message = get_error_message(error) print(Fore.RED + str(error) + Fore.RESET + ':' + message)
def backup_repo(rep, *urls): """ Backup a repository to multiple locations. Arguments: rep -- Repository to be backed up urls -- Backup repository to these locations (1 or more URL args). Returns: Backup repositories (clones of the supplied respositories). """ backups = list() for url in urls: url = os.path.join(url, rep.name) connector = Connector.from_string(url) with rep.connector.connected(), connector.connected(): backup = repo.Repo.clone(rep, connector) init_repo_logging(backup) backups.append(backup) log.info("Backed up repository to %s" % url) return backups