def test_getToken(self):
     reader = ConfigReader()
     resultTest = reader.getToken()
     data = open('config.json')
     jdata = json.load(data)
     resultCorrect = jdata["token"]
     self.assertEqual(resultTest, resultCorrect)
 def test_camAvaible(self):
     reader = ConfigReader()
     resultTest = reader.camAvaible()
     data = open('config.json')
     jdata = json.load(data)
     resultCorrect = jdata["avaible"]
     self.assertEqual(resultTest, resultCorrect)
Example #3
0
def allocate():
    try:
        allocatingStatus = ConfigReader.getValue('allocation',
                                                 'allocatingStatus')
        assignlimit = ConfigReader.getIntValue('db', 'assignCount')

        agents = getAgents()

        if (len(agents) == 0):
            print 'No valid Agents found: ' + filterAgentsQuery
            return

        for agent in agents:
            print ''
            print 'agent - ' + str(agent)
            agentId = agent[0]
            rem = (getRemCountForAgent(agentId, assignlimit, allocatingStatus))
            if (rem > 0):
                print 'rem - ' + str(rem)
                # In case no rows affected, we can check if there are any welcome calls remaining, else stop.
                setRemWelCalToAgent(agentId, rem, allocatingStatus)
            else:
                print 'No more assignment required for agent:' + str(agent)

    except Exception as e:
        print 'Exception while allocating'
        raise e
    finally:
        pass
    return


# allocate()
 def test_getMotionPin2(self):
     reader = ConfigReader()
     resultTest = reader.getMotionPin2()
     data = open('config.json')
     jdata = json.load(data)
     resultCorrect = jdata["motion2"]
     self.assertEqual(resultTest, resultCorrect)
 def test_getHashPass(self):
     reader = ConfigReader()
     resultTest = reader.getHashPass()
     data = open('config.json')
     jdata = json.load(data)
     resultCorrect = jdata["passhash"]
     self.assertEqual(resultTest, resultCorrect)
 def test_getNumberOfLED(self):
     reader = ConfigReader()
     resultTest = reader.getNumberOfLED()
     data = open('config.json')
     jdata = json.load(data)
     resultCorrect = jdata["number"]
     self.assertEqual(resultTest, resultCorrect)
Example #7
0
    def test_api_with_salt_value(self):
        host_web_app = ConfigReader.read_web_application_host()
        port_web_app = int(ConfigReader.read_web_application_port())
        if host_web_app == "local":
            start_url = f"{ConfigReader.read_web_application_protocol()}{get_local_ip.get_ip()}:{port_web_app}"
        else:
            start_url = f"{ConfigReader.read_web_application_protocol()}{host_web_app}:{port_web_app}"

        response_salt_value_json = get(start_url +
                                       '/api/addRandomSalt/qwe').json()

        self.assertEqual('salt' in response_salt_value_json, True)
        self.assertEqual('salt_value' in response_salt_value_json, True)

        response_with_salt_json = get(start_url + '/api/addSalt',
                                      json={
                                          'value': 'qwe',
                                          'salt':
                                          response_salt_value_json["salt"]
                                      }).json()

        self.assertEqual('salt' in response_with_salt_json, True)
        self.assertEqual('salt_value' in response_with_salt_json, True)

        self.assertEqual(
            response_with_salt_json['salt'] ==
            response_salt_value_json['salt'], True)
        self.assertEqual(
            response_with_salt_json['salt_value'] ==
            response_salt_value_json['salt_value'], True)
Example #8
0
def process():
    config = ConfigReader()
    config.read_config()  #read the configuration file
    ap = AudioProcessor(config.fullfilename)
    file_list = get_files()
    # print config.audio_dir
    # print file_list
    # f = open('output.txt','a')
    th_list = [10, 15, 20, 25, 30]
    th_list = [15]
    for th in th_list:
        for file in file_list:
            filename = config.audio_dir + file
            print 'start processing: ' + str(file)
            ap.set_filename(filename)
            fs = ap.get_samplerate()

            segment_length, segmentsetidx, pichset, genderset, segment_sample_set = ap.pitchbased_preprocessing(
                config)
            sc = SpeakerCounter(fs, segment_length, segmentsetidx, pichset,
                                genderset, segment_sample_set)
            sc.set_threshold(th)
            count = sc.get_people_count()
            # out ="# people in ("+str(file)+") :: "+str(count)+'\n'

            ac = 4
            erc = abs(ac - count)
            print[str(file), str(count), str(ac), str(erc), str(th)]
 def motionLight(self, direction):
     # Alle LEDs werden eingeschaltet und nach
     # bestimmten Zeitraum 'period' wieder ausgeschaltet
     reader = ConfigReader()
     period = reader.getValue("timeperiod")
     self.fadeAllIn(direction)
     time.sleep(float(period))
     self.fadeAllOut(direction)
Example #10
0
 def navigate_to_admin(self,username, password):
     if Conf.read_ini_config('Paths','HomeURL') in self.driver.current_url:
         self.driver.find_element(*AdminBase.admin_button).click()
     elif Conf.read_ini_config('Paths','AdminURL') not in self.driver.current_url:
         if self.driver.find_element(*LoginLogoutPage.login_link).text == 'Log in':
             LoginLogoutPage.login_with_valid_credentials(self,username,password)
             self.driver.get(Conf.read_ini_config('Paths','HomeURL'))
             self.driver.find_element(*AdminBase.admin_button).click()
 def __init__(self):
     reader = ConfigReader()
     tokenlist = reader.getValue("token")
     global token
     token = []
     # Alle Tokens werden aus der Liste geladen
     for i in tokenlist:
         token.append(i['t'])
 def mountFTP(self):
     reader = ConfigReader()
     host = reader.getValue("ftp_host")
     user = reader.getValue("ftp_user")
     password = reader.getValue("ftp_pw")
     path = reader.getValue("ftp_directory")
     script = 'sh ./script/mountFTP.sh '
     arguments = script + " " + path + " " + host + " " + user + " " + password + " " + currentuser
     subprocess.Popen([arguments], shell=True)
Example #13
0
 def test_api_random_salt_non_value(self):
     host_web_app = ConfigReader.read_web_application_host()
     port_web_app = int(ConfigReader.read_web_application_port())
     if host_web_app == "local":
         start_url = f"{ConfigReader.read_web_application_protocol()}{get_local_ip.get_ip()}:{port_web_app}"
     else:
         start_url = f"{ConfigReader.read_web_application_protocol()}{host_web_app}:{port_web_app}"
     response_json = get(start_url + '/api/addRandomSalt/')
     self.assertEqual(response_json.status_code == 404, True)
Example #14
0
def start_server(host, port):
    app.register_blueprint(db_api.blueprint)
    api.add_resource(user_resources.UserListResource, ConfigReader.read_users_api_url())
    api.add_resource(user_resources.UserResource, ConfigReader.read_user_api_url())
    api.add_resource(bin_user_resources.BinUserResource, ConfigReader.read_get_bin_user_api_url())
    DataBase.global_init("bd/name.bd")
    # UserController.UserController().create_test_user()
    # app.run(port=8080, host='127.0.0.1')
    # func_start()
    app.run(port=port, host=host)
 def initStripe(self):
     # Neopixel Objekt erzeugen
     # LED_COUNT aus config holen
     reader = ConfigReader()
     LED_COUNT = int(reader.getValue("ledcount"))
     LED_PIN = int(reader.getValue("ledport"))
     global strip
     strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT)
     strip.begin()
     self.clear()
Example #16
0
 def login_with_valid_credentials(self, username, password):
     if Conf.read_ini_config('Paths','AdminURL') in self.driver.current_url:
         self.driver.get(Conf.read_ini_config('Paths','HomeURL'))
     if self.driver.find_element(*LoginLogoutPage.login_link).text == 'Log in':
         self.driver.find_element(*LoginLogoutPage.login_link).click()
         self.driver.find_element(*LoginLogoutPage.username).clear()
         self.driver.find_element(*LoginLogoutPage.username).send_keys(username)
         self.driver.find_element(*LoginLogoutPage.password).clear()
         self.driver.find_element(*LoginLogoutPage.password).send_keys(password)
         self.driver.find_element(*LoginLogoutPage.login_button).click()
         return self.driver.find_element(*LoginLogoutPage.login_link).text
 def startRecording(self):
     path = '/home/'+currentuser+'/ftp'
     dirAvaible = os.path.exists(path)
     if dirAvaible:
         reader = ConfigReader()
         script = 'sh ./script/recordIpCam.sh '
         user = reader.getValue("cam_user")
         pw = reader.getValue("cam_pw")
         ip = reader.getValue("cam_host")
         arguments = script + " " + path + " " + ip + " " + user + " " + pw
         subprocess.Popen([arguments], shell=True)
 def safeImage(self):
     reader = ConfigReader()
     user = reader.getValue("cam_user")
     pw = reader.getValue("cam_pw")
     ip = reader.getValue("cam_host")
     camdir = reader.getValue("cam_dir")
     url = "http://" + user + ":" + pw + "@" + ip + camdir
     r = requests.get(url)
     i = Image.open(StringIO(r.content))
     path = '/home/'+currentuser+'/ftp/safe/'
     dirAvaible = os.path.exists(path)
     if dirAvaible:
         i.save(path + str(time.time()) + ".jpg")
Example #19
0
def get_user(email: str, user_id=None):
    try:
        if user_id:
            return get(_ip_db + ConfigReader.read_user_api_url(),
                       json={
                           'id': user_id
                       }).json()
        else:
            return get(_ip_db + ConfigReader.read_user_api_url(),
                       json={
                           'email': email,
                       }).json()
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
    def run(self):
        # Use BCM GPIO references
        # instead of physical pin numbers
        GPIO.setmode(GPIO.BCM)
        reader = ConfigReader()

        # Festlegen der beiden Detection-Pins
        MOTION_PIN1 = int(reader.getValue("motionport1"))
        MOTION_PIN2 = int(reader.getValue("motionport2"))

        # Diese als Input definieren
        GPIO.setup(MOTION_PIN1,GPIO.IN)
        GPIO.setup(MOTION_PIN2,GPIO.IN)

        # Status definieren um verschiedene Änderungen zu erkennen
        Current_State_1  = 0
        Previous_State_1 = 0
        Current_State_2  = 0
        Previous_State_2 = 0

        center.writeLog('Motion Detection Status: OK')
        # Loop zur Erkennung einer Bewegung
        # Sensort erkennt Bewegung -> Signal = High
        # Wartet 3 Sekunden und setzt Signal = Low
        # Die LEDs werden nach bestimmter Zeit wieder
        # ausgeschaltet. Dies passiert in der Led-Klasse
        while cond :
            # Aktuellen Status der Sensoren einlesen
            Current_State_1 = GPIO.input(MOTION_PIN1)
            Current_State_2 = GPIO.input(MOTION_PIN2)

            if (Current_State_1 == 1 and Previous_State_1 == 0 and Current_State_2 == 0):
                # Sensor 1 hat ausgelöst
                Previous_State_1 = 1
                center.motionDetected(0)

            if (Current_State_2 == 1 and Previous_State_2 == 0 and Current_State_1 == 0):
                # Sensor 2 hat ausgelöst
                Previous_State_2 = 1
                center.motionDetected(1)

            if (Current_State_1 == 0 and Previous_State_1 == 1):
                # Sensor 1 war an und ist wieder aus
                Previous_State_1 = 0

            if (Current_State_2 == 0 and Previous_State_2 == 1):
                # Sensor 2 war an und ist wieder aus
                Previous_State_2 = 0

            time.sleep(0.01)
 def Register_with_valid_input(self,email, nickname, password, firstname, surname, company, capacity, dateofbirth, phone, mobile,address, zipcode, town, country, how_do_you_know_our_website):
     self.driver.get(Conf.read_ini_config('Paths','RegisterURL'))
     self.driver.find_element(*RegistrationPage.Email).send_keys(email)
     self.driver.find_element(*RegistrationPage.Nickname).send_keys(nickname)
     self.driver.find_element(*RegistrationPage.Password).send_keys(password)
     self.driver.find_element(*RegistrationPage.FirstName).send_keys(firstname)
     self.driver.find_element(*RegistrationPage.Surname).send_keys(surname)
     self.driver.find_element(*RegistrationPage.Company).send_keys(company)
     self.driver.find_element(*RegistrationPage.Phone).send_keys(phone)
     self.driver.find_element(*RegistrationPage.Mobile).send_keys(mobile)
     self.driver.find_element(*RegistrationPage.Address).send_keys(address)
     self.driver.find_element(*RegistrationPage.Zipcode).send_keys(zipcode)
     self.driver.find_element(*RegistrationPage.Phone).send_keys(phone)
     self.driver.find_element(*RegistrationPage.Town).send_keys(town)
     self.driver.find_element(*RegistrationPage.Title).click()
     self.driver.find_element(*RegistrationPage.Capacity).send_keys(capacity)
     self.driver.find_element(*RegistrationPage.DateOfBirth).send_keys(dateofbirth)
     self.driver.find_element(*RegistrationPage.Country).send_keys(country)
     self.driver.find_element(*RegistrationPage.How_do_you_know_our_website).send_keys(how_do_you_know_our_website)
     self.driver.find_element(*RegistrationPage.Code).send_keys('12340')
     self.driver.find_element(*RegistrationPage.FirstSelection).click()
     self.driver.find_element(*RegistrationPage.SecondSelection).click()
     self.driver.find_element(*RegistrationPage.OpenAccount).click()
     alert =self.driver.find_element(*RegistrationPage.Thanks_Msg).text
     LoginLogoutPage.logout(self)
     return alert
Example #22
0
 def __init__(self, target='127.0.0.1', message='JOIN'):
     self._loop = asyncio.get_event_loop()
     self._config_reader = ConfigReader.ConfigReader()
     self._port = self._config_reader.get_config_section("Service")['port']
     self._target = target
     self._message = message
     self._co_routine = None
Example #23
0
 def __init__(self, globalq):
     config = ConfigReader.ConfigReader('./main.cfg')
     locallisten = config.getbykey('ip', 'main'), int(
         config.getbykey('port', 'main'))
     self.__server = ThreadedTCPStreamServer(locallisten,
                                             ThreadedTCPStreamHandler,
                                             queue=globalq)
 def FollowOrder(self):
     self.driver.get(Conf.read_ini_config('Paths','HomeURL'))
     self.driver.find_element(*FollowUpOrdersPage.FollowUp_Orders_Lnk).click()
     self.driver.implicitly_wait(10)
     status =self.driver.find_element(*FollowUpOrdersPage.PaymentStatus_Lnk).text
     self.driver.find_element(*FollowUpOrdersPage.PaymentStatus_Lnk).click()
     return status
Example #25
0
def getMultipleStatusQryStr():
    mulStatus = ConfigReader.getValue('allocation',
                                      'welCalStatusToPick').split(',')
    qry = ''
    for status in mulStatus:
        qry = qry + ' status=' + status + ' or'
    qry = qry[:-3]
    return qry
Example #26
0
def delete_user(user_id):
    try:
        return delete(_ip_db + ConfigReader.read_users_api_url(),
                      json={
                          'id': user_id
                      }).json()
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
Example #27
0
def check_email(email: str):
    try:
        return get(_ip_db + ConfigReader.read_check_email_api_url(),
                   json={
                       'email': email
                   }).json()
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
Example #28
0
 def __init__(self,dbname=None):
     self.__cfg=cr.readValues('conf.ini','mongo')
     client = MongoClient(self.__cfg["host"], int(self.__cfg["port"]))
     if dbname==None:
         self.db = client[self.__cfg["dbname"]]
     else:
         self.db=client[dbname]
     self.db.authenticate(self.__cfg["user"], self.__cfg["password"])
Example #29
0
def check_id(user_id: int):
    try:
        return get(_ip_db + ConfigReader.read_check_id_api_url(),
                   json={
                       'id': user_id
                   }).json()
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
Example #30
0
def getAgents():
    role = ConfigReader.getValue('db', 'role')

    # bima_customer, bima_user_role_permission.
    filterAgentsQuery = 'SELECT user_id, role_id FROM bima_user_role_permission WHERE user_id > 0 and role_id = ' + role
    # print filterAgentsQuery

    validAgents = DBUtils.executeSelectQuery(filterAgentsQuery)
    return validAgents
Example #31
0
def add_salt_value(value: str, salt: str):
    try:
        return get(_ip_app + ConfigReader.read_add_salt_value_api_url(),
                   json={
                       'value': value,
                       "salt": salt
                   }).json()
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
Example #32
0
 def __init__(self, newClientCallback=None, dataReceivedCallback=None):
     self._config_reader = ConfigReader.ConfigReader()
     self._address = "localhost"
     self._port = self._config_reader.get_config_section("Service")['port']
     self._clients = dict()
     self._newClientCallback = newClientCallback
     self._dataReceivedCallback = dataReceivedCallback
     self._loop = asyncio.get_event_loop()
     self._server = None
Example #33
0
def changing_user_properties(user_id: int, change_properties: dict):
    try:
        return post(_ip_db + ConfigReader.read_user_api_url(),
                    json={
                        'id': user_id,
                        'change_properties': change_properties
                    }).json()
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
Example #34
0
 def __init__(self, remote, func, dictdata):
     self.__config = ConfigReader.ConfigReader('./main.cfg')
     self.__remotehost = remote
     self.__connectiontimeout = int(
         self.__config.getbykey('timeout', 'heartbeat'))
     self.__retry = int(self.__config.getbykey('retry', 'heartbeat'))
     self.__port = int(self.__config.getbykey('port', 'main'))
     self.targetfunc = func
     self.__data = dictdata
Example #35
0
    def __init__(self):
        Tk.__init__(self)
        self.wm_title("Tekken Bot Prime")
        self.iconbitmap('TekkenData/tekken_bot_close.ico')

        self.color_scheme_config = ConfigReader.ConfigReader("color_scheme")
        self.color_scheme_config.add_comment("colors with names -> http://www.science.smith.edu/dftwiki/images/3/3d/TkInterColorCharts.png")
        self.changed_color_scheme("Current", False)

        self.menu = Menu(self)
        self.configure(menu=self.menu)

        self.text = Text(self, wrap="word")
        sys.stdout = TextRedirector(self.text, "stdout")

        try:
            with open("TekkenData/tekken_bot_readme.txt") as fr:
                lines = fr.readlines()
            for line in lines: print(line)
        except:
            print("Error reading readme file.")

        self.overlay = fdo.GUI_FrameDataOverlay(self)

        self.checkbox_dict = {}
        self.column_menu = Menu(self.menu)
        for i, enum in enumerate(fdo.DataColumns):
            bool = self.overlay.redirector.columns_to_print[i]
            self.add_checkbox(self.column_menu, enum, enum.name, bool, self.changed_columns)
        self.menu.add_cascade(label='Columns', menu=self.column_menu)

        self.display_menu = Menu(self.menu)
        for enum in fdo.DisplaySettings:
            default = self.overlay.tekken_config.get_property(fdo.DisplaySettings.config_name(), enum.name, False)
            self.add_checkbox(self.display_menu, enum, enum.name, default, self.changed_display)
        self.menu.add_cascade(label="Display", menu=self.display_menu)

        self.color_scheme_menu = Menu(self.menu)
        self.radio_var = StringVar()
        for section in self.color_scheme_config.parser.sections():
            if section not in ("Comments", "Current"):
                self.color_scheme_menu.add_radiobutton(label=section, variable=self.radio_var, value=section, command=lambda : self.changed_color_scheme(self.radio_var.get()))
        self.menu.add_cascade(label="Color Scheme", menu=self.color_scheme_menu)



        self.text.grid(row = 2, column = 0, columnspan=2, sticky=N+S+E+W)
        #self.grid_rowconfigure(0, weight=1)
        self.grid_rowconfigure(2, weight=1)
        self.grid_columnconfigure(0, weight=1)
        #self.grid_columnconfigure(1, weight=1)

        self.geometry(str(720) + 'x' + str(720))

        self.overlay.update_launcher()
        self.overlay.hide()
Example #36
0
    def __init__(self):
        self.cfg = ConfigReader.GetConfig()

        if self.cfg['geo']['enabled'] == True:
            location = self.GetLocation()
            self.Longitude = location[1]
            self.Latitude = location[0]
        else:
            self.Longitude = self.cfg['geo']['default_longitude']
            self.Latitude = self.cfg['geo']['default_latitude']
Example #37
0
def send_confirmation_email(redirection, recipients):
    try:
        return post(_ip_app +
                    ConfigReader.read_send_confirmation_email_api_url(),
                    json={
                        'redirection': redirection,
                        "recipients": recipients
                    })
    except requests.exceptions.ConnectionError as e:
        raise ConnectionError
Example #38
0
    def __init__(self, server_address='localhost'):
        self._config_reader = ConfigReader.ConfigReader()
        self._port = 26541 # self._config_reader.get_config_section("Service")['port']
        # Create a TCP/IP socket
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        # Connect the socket to the port where the server is listening
        self._server_address = server_address
        self._server = (server_address, self._port)
        logger.info('connecting to %s on port %s' % self._server + '\n')
Example #39
0
def advanced_settings():
    if request.method == 'GET':
        cfg = ConfigReader.GetConfig()
        strip = cfg['strip']
        geo = cfg['geo']
        return render_template("advanced.html", strip=strip, geo=geo)
    else:
        cfg = ConfigReader.GetConfig()
        strip = cfg['strip']
        geo = cfg['geo']
        strip['count'] = int(request.form.get('ledCount'))
        strip['pin'] = int(request.form.get('pinNum'))
        geo['enabled'] = bool(request.form.get('geoEnabled'))
        geo['api_key'] = str(request.form.get('apiKey'))
        geo['location'] = str(request.form.get('location'))
        geo['default_latitude'] = float(request.form.get('lat'))
        geo['default_longitude'] = float(request.form.get('lon'))
        cfg = ConfigReader.Dump(cfg)
        return redirect('index')
Example #40
0
def update_settings():
    cfg = ConfigReader.GetConfig()
    cfg['strip']['brightness'] = int(request.form['brightness'])
    cfg['strip']['less_than_time'] = request.form['onTime']
    cfg['strip']['greater_than_time'] = request.form['endTime']

    rgbaVal = request.form['activeColor']
    cleanVal = re.sub(r'^.*\(', "", rgbaVal)
    processedVal = re.sub(r'\)', "", cleanVal).split(',')
    cfg['strip']['active_color']['R'] = int(processedVal[0])
    cfg['strip']['active_color']['G'] = int(processedVal[1])
    cfg['strip']['active_color']['B'] = int(processedVal[2])

    cfg['start_animation'] = request.form['startAnimation']
    cfg['end_animation'] = request.form['endAnimation']
    cfg['onTime'] = int(request.form['onDuration'])

    cfg = ConfigReader.Dump(cfg)
    return redirect(url_for('index'))
Example #41
0
 def __init__(self, newClientCallback=None, dataReceivedCallback=None):
     self._config_reader = ConfigReader.ConfigReader()
     self._port = int(
         self._config_reader.get_config_section("Service")['port'])
     self._clients = dict()
     self._newClientCallback = newClientCallback
     self._dataReceivedCallback = dataReceivedCallback
     self._server = socketserver.ThreadingTCPServer(
         ('', self._port),
         ClusterRequestHandler(self._newClientCallback,
                               self._dataReceivedCallback))
Example #42
0
    def __init__(self):
        self.stage = 1
        config_reader = ConfigReader.ReadConfig()
        config = config_reader.read()

        if config.has_section('api_config'):
            api_config = dict(config.items('api_config', {}))
            self.request_handler = RequestHandler.RequestHandler(api_config)
            self.play_game()
        else:
            print 'API config not available. Cannot start the game ...'
Example #43
0
    def connect(self):
        """ Connect to MySQL database """
        db_config = ConfigReader.read_db_config()
        self.conn = None
        try:
            self.conn = mysql.connector.MySQLConnection(**db_config)
            if self.conn.is_connected():
                print('Connected to MySQL database')

        except Error as e:
            print(e)
Example #44
0
    def __init__(self):                                                   # Parameters for the connection
        asyncore.dispatcher.__init__(self)                                # Overload the previous definition
        self.config = ConfigReader.ReadConf('bot.conf')                   # Get the configuration
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)            # Create the sock_stream socket
        self.connect((self.config.get("realmadress", "127.0.0.1"), 3724)) # Connect to the realm_server
        self.buffer = ''                                                  # Init the data to send buffer

        self.packethandler = {                                            # Dictionnary with received opcode and function to call
            0x00 : self.SS_AUTH_LOGON_CHALLENGE,
            0x01 : self.SS_AUTH_LOGON_PROOF,
            0x10 : self.SS_REALM_LIST,
            0xFF : self.SS_UNKNOWN,
        }
Example #45
0
    def __init__(self):
        """Initializes class NetworkMapper.
            If a list of member IPs is found in the config, these are used.
            Otherwise the network will be scanned.
        """
        self._config_reader = ConfigReader.ConfigReader()
        ip_list = self._config_reader.get_config_section(
            "Cluster")['members'].replace(" ", "").split(',')

        if ip_list[0] == "":
            self._host_list = self.scan_network()
        else:
            self._host_list = self.fill_host_list(ip_list)
Example #46
0
def index():
    cfg = ConfigReader.GetConfig()
    strip = cfg['strip']
    animation_list = cfg['animations']
    start_animation = cfg['start_animation']
    end_animation = cfg['end_animation']
    onDuration = cfg['onTime']
    return render_template("index.html",
                           strip=strip,
                           animation_list=animation_list,
                           start_animation=start_animation,
                           end_animation=end_animation,
                           onDuration=onDuration)
    def process_queries(self, cfg_file_name='pc.cfg'):
        logging.info("Execution begin")

        configs = ConfigReader.read_cfg(cfg_file_name)
        logging.info("Configuration file read")

        begin = time.perf_counter()
        for xml_file_name in configs['LEIA']:
            xml_file = minidom.parse(xml_file_name)
            query_list = xml_file.getElementsByTagName('QUERY')
            for query in query_list:
                self._process_xml_query(query)
        end = time.perf_counter()
        elapsed = end - begin
        logging.info("Queries processed: " + str(len(self.expected_docs_by_query)) + " queries read from " + str(len(configs['LEIA'])) + " file(s)")
        logging.info("Query processor performance: " + str(len(self.expected_docs_by_query)/elapsed) + " queries per second.")

        self.write_queries(configs['CONSULTAS'][0], configs['ESPERADOS'][0])
        logging.info("Query processing saved")
        logging.info("Execution ended")
Example #48
0
    def do_index(self, cfg_file="index.cfg"):
        logging.info("Execution begin")

        cfg = ConfigReader.read_cfg(cfg_file)
        logging.info("Configuration file read")

        inv_list_file = cfg['LEIA'][0]
        model_file = cfg['ESCREVA'][0]

        inv_list = self.read_inv_list(inv_list_file)
        logging.info("Inverted list read: " + str(len(inv_list)) + " terms")

        self.weight_function.generate_model(inv_list)
        logging.info("Model generated")

        with open(model_file, 'wb') as pick_file:
            pickle.dump(self.weight_function, pick_file)
        logging.info("Model saved")

        logging.info("Execution ended")
Example #49
0
    def do_search(self, config_file_name="busca.cfg"):
        logging.info("Execution begin")
        cfg = ConfigReader.read_cfg(config_file_name)
        logging.info("Configuration file read")

        model_file_name = cfg["MODELO"][0]
        queries_file_name = cfg["CONSULTAS"][0]
        results_file_name = cfg["RESULTADOS"][0]

        self.model = pickle.load(open(model_file_name, 'rb'))
        logging.info("Model loaded")

        queries = dict()
        with open(queries_file_name) as queries_file:
            for l in queries_file.readlines():
                temp = l.split(';')
                query_id = temp[0]
                query = temp[1]
                queries[query_id] = query

        n_queries = len(queries)
        logging.info("Queries file loaded: " + str(n_queries) + " loaded")

        query_results = dict()
        begin_time = time.perf_counter()
        for query_id in queries:
            similarities = self.model.retrieve(queries[query_id])
            query_results[query_id] = similarities

        end_time = time.perf_counter()
        elapsed_time = end_time - begin_time

        logging.info("Retrieval done")
        logging.info("Retrieval performance: " + str(n_queries/elapsed_time) + " queries per seconds")

        with open(results_file_name, 'w') as results_file:
            for query_id in query_results:
                self._write(query_id, query_results[query_id], results_file)

        logging.info("Queries results saved")
        logging.info("Execution ended")
    def parse_corpus(self, cfg_file):
        logging.info("Execution begin")

        configs = ConfigReader.read_cfg(cfg_file)
        logging.info("Configuration file read")

        corpus = dict()
        for in_file in configs["LEIA"]:
            document = self.read_xml(in_file)
            corpus.update(document)

        logging.info("Corpus read: " + str(len(corpus)) + " documents readed from " + str(len(configs["LEIA"])) + " files")

        begin = time.perf_counter()
        inv_list = self.generate_inverted_list(corpus)
        end = time.perf_counter()
        elapsed = end - begin

        logging.info("Inverted list generated: " + str(len(inv_list)) + " terms collected")
        logging.info("Inverted list performance: " + str(len(corpus)/elapsed) + " documents per second")

        self.write_inverted_list(inv_list, configs["ESCREVE"][0])
        logging.info("Inverted list saved")
        logging.info("Execution ended")
Example #51
0
 def getPictureList(self):
     files = []
     reader = ConfigReader()
     if (reader.camAvaible() == "0"):
         return files
     ftphost = reader.getFTP()
     ftpdirectory = reader.getFTPDirectory()
     user = reader.getFTPUser()
     pw = reader.getFTPPW()
     ftp = ftplib.FTP(ftphost)
     try:
         if user == "" && pw == "":
             # Anonymous Login
             ftp.login()
         else:
             ftp.login(user,pw)
     except:
         return files
     ftp.cwd(ftpdirectory)
     files = ftp.nlst()
     ftp.quit()
     return files
Example #52
0
 def navigate_to_page(self,username, password):
     if Conf.read_ini_config('Paths','AdminURL') in self.driver.current_url:
         self.driver.get(Conf.read_ini_config('Paths','HomeURL'))
         if self.driver.find_element(*LoginLogoutPage.login_link).text == 'Log in':
             LoginLogoutPage.login_with_valid_credentials(self,username,password)
 def test_camURL_MUST_FAIL(self):
     reader = ConfigReader()
     resultTest = reader.camURL()
     # Muss fehlschlagen!!!
     resultCorrect = '123' #config.get("cam","adress")
     self.assertEqual(resultTest, resultCorrect)
Example #54
0
 def setUpClass(cls):
     cls.driver = webdriver.Firefox()
     cls.driver.implicitly_wait(30)
     cls.driver.maximize_window()
     # navigate to the application home page
     cls.driver.get(Conf.read_ini_config('Paths','LoginURL'))
Example #55
0
def modifyConfigs(request):
    if request.method == 'POST':
        new_url = str(request.POST['url'])
        ConfigReader.setConfig('URL', new_url)
    return HttpResponseRedirect("/")
Example #56
0
def configs(request):
    url = ConfigReader.getConfig('URL')
    default_url = ConfigReader.getConfig('DefaultURL')
    return render_to_response('configs.html', {'url': url, 'default_url': default_url})
Example #57
0
def getServerURL():
    serverURL = ConfigReader.getConfig("URL")
    return serverURL
Example #58
0
import ConfigReader

# specify eBay API dev,app,cert IDs
devID = ConfigReader.getConfig("Developer")
appID = ConfigReader.getConfig("Application")
certID = ConfigReader.getConfig("Certificate")

#get the server details from the config file

serverDirectory = ConfigReader.getConfig("Directory")


def buildHttpHeaders():
    httpHeaders = {'X-EBAY-SOA-OPERATION-NAME': 'findItemsByKeywords',\
                   'X-EBAY-SOA-SERVICE-VERSION': '1.3.0',
                   'X-EBAY-SOA-REQUEST-DATA-FORMAT': 'XML',
                   'X-EBAY-SOA-GLOBAL-ID': 'EBAY-US',
                   'X-EBAY-SOA-SECURITY-APPNAME': appID,
                   'Content-Type': 'text/xml;charset=utf-8'}
    return httpHeaders


def buildRequestXml(keyword):
    requestXml = "<?xml version='1.0' encoding='utf-8'?>" + \
              "<findItemsByKeywordsRequest " + \
              "xmlns=\"http://www.ebay.com/marketplace/search/v1/services\">" +\
              "<keywords>" + keyword + "</keywords>" + \
              "<paginationInput>" + \
              "<entriesPerPage>15</entriesPerPage>" + \
              "</paginationInput>" + \
              "</findItemsByKeywordsRequest>"
Example #59
0
# -*- coding: UTF-8 -*-
import Functions, ConfigReader
import os, sys, time, commands
from Client import Client

#1.校验tar包MD5码

client = ConfigReader.getClient(sys.argv[1])

tarFileMD5 = Functions.getFileMd5(Client.tarFilePath)

if Client.MD5==tarFileMD5:

  #2.校验成功后解压
  Functions.extract(Client.tarFilePath, Client.tempDirPath)
  #3.停止tomcat服务
  (shutresult, shutreturn) = commands.getstatusoutput(Client.tomcatPath+"/bin/shutdown.sh")
  print("shutresult-------->"+str(shutresult))
  # print("shutreturn-------->"+shutreturn)
  (status, pid) = commands.getstatusoutput("pidof java")
  if(status == 0):
    Functions.killProcess()

  #4.替换程序
  print("文件夹路径:"+Client.folderPath)
  (cpresutl, cpreturn) = commands.getstatusoutput("cp -rf "+Client.folderPath+" "+Client.tomcatPath+"/webapps")
  print("cpresutl-------->" + str(cpresutl))
  #5.删除临时文件
  (rmresult, rmreturn) = commands.getstatusoutput("rm -rf "+Client.tempDirPath)
  print("rmresult-------->" + str(rmresult))
  #6.启动tomcat服务