예제 #1
0
파일: recipe.py 프로젝트: buweixiaomi/im
    def getRecipes():
        """ Static method to get the list of recipes """
        if not DataBase.db_available:
            return []
        else:
            try:
                db = DataBase(Config.RECIPES_DB_FILE)
                db.connect()

                res = []
                result = db.select('select * from recipes')
                for d in result:
                    name = d[0]
                    version = d[1]
                    modules = d[2].split(",")
                    recipe = d[3]
                    isapp = d[4]
                    galaxy_module = d[5]
                    desc = d[6]
                    requirements = d[7]
                    res.append(Recipe(name, version, modules, recipe,
                                      desc, requirements, galaxy_module, isapp))

                return res
            except Exception:
                return []
예제 #2
0
파일: auth.py 프로젝트: carlewis/clues
	def get_user_list(self):
		success = False
		user_list = []
		try:
			db = DataBase(self.__db_name)
			db.connect()
			user_list = db.select("select user, attributes from user;")
			success = True
			logging.debug("user list successfully obtained")
		except Exception, e:
			logging.error("error trying to list users (%s)" % (str(e)))
예제 #3
0
파일: auth.py 프로젝트: carlewis/clues
	def get_user_data_from_db(self, username):
		t_user = None
		t_attributes = []
		try:
			db = DataBase(self.__db_name)
			db.connect()
			datos = db.select("select user, attributes from user where user=\"%s\";" % username)
			if (len(datos) != 0):
				t_user, t_attributes = datos[0]
				t_attributes = t_attributes.split(";")
		except Exception, e:
			logging.error("an error happened trying to obtain data from user '%s' (%s)" % (username, str(e)))
예제 #4
0
파일: app.py 프로젝트: vblazhnov/stats
def get_event(name, **args):
    """
    Получение подробной информации об евенте
    """

    user = DataBase.get_user_info(args["authUserName"])

    if user is None:
        abort(403)

    result = DataBase.get_users_event(user[0], name)
    return jsonify({"event": name, "events": result})
예제 #5
0
파일: app.py 프로젝트: vblazhnov/stats
def get_events(**args):
    """
    Получение своих евентов
    """

    user = DataBase.get_user_info(args["authUserName"])

    if user is None:
        abort(403)

    result = DataBase.get_users_events(user[0])

    return jsonify({"events": result})
예제 #6
0
파일: recipe.py 프로젝트: lxhiguera/im
	def insertRecipe(name, version, module, recipe, desc, requirements, galaxy_module = None, isapp = 0):
		""" Static method to insert a recipe in the DB """
		if not DataBase.db_available:
			return False
		else:
			try:
				db = DataBase(Config.RECIPES_DB_FILE)
				db.connect()
				
				res = db.execute('''insert into recipes values ("%s", "%s", "%s", "%s", %d, %d, "%s", "%s")''' % (name, version, module, recipe, isapp, galaxy_module, desc, requirements))
				return res
			except Exception:
				return False
예제 #7
0
파일: auth.py 프로젝트: carlewis/clues
	def delete_user(self, username):
		if username is None:
			return False

		success = False
		try:
			db = DataBase(self.__db_name)
			db.connect()
			db.execute("delete from user where user=\"%s\";" % username)
			success = True
			logging.debug("user '%s' successfully deleted" % username)
		except Exception, e:
			logging.error("error trying to delete user '%s' (%s)" % (username, str(e)))
예제 #8
0
파일: auth.py 프로젝트: carlewis/clues
	def create_user(self, username, password, attributes = []):
		if username is None:
			return False

		success = False
		try:
			db = DataBase(self.__db_name)
			db.connect()
			attributes_string = ";".join(attributes)
			db.execute("insert into user (user, password, attributes) values (\"%s\", \"%s\", \"%s\");" % (username, password, attributes_string))
			success = True
			logging.debug("user '%s' successfully created" % username)
		except Exception, e:
			logging.error("error trying to create user '%s' (%s)" % (username, str(e)))
예제 #9
0
    def __init__(self):
        """
        Constructor. Initializes the list of machines.

        @rtype: None
        @returns: nothing
        """
        self.__db = DataBase()
예제 #10
0
 def __init__(self, sql_queue, db_info, timestamp):
     threading.Thread.__init__(self)
     self.sql_queue = sql_queue
     self.db = DataBase(**db_info)
     self.timestamp = timestamp
     self.logger = logger.create_file_logger("Sql Thread", logging.INFO,
                                             timestamp,
                                             'collect_sql_thread.log')
예제 #11
0
def create_db(args):
    db = DataBase(
        login=args.db_login,
        pwd=args.db_pwd,
        host=args.db_host,
        db=args.db_name,
    )
    return db
예제 #12
0
def create_db_backup() -> Path:
    DB_BACKUP_ROOT.mkdir(parents=True, exist_ok=True)
    delete_files(DB_BACKUP_ROOT)
    db = DataBase()
    create_students_table(db, 100)
    for path in DB_ROOT.iterdir():
        path.rename(DB_BACKUP_ROOT / path.name)
    return DB_BACKUP_ROOT
예제 #13
0
파일: bot.py 프로젝트: ScheglovIvan/GiftBot
def Burdock(message):
    db = DataBase()
    burdocks = db.getOrder()

    try:
        for burdock in burdocks:
            order_n = burdock[0]
            user_name = burdock[2]
            shop_name = burdock[3]
            price = burdock[4]
            mess = "🏆 Заказ № %d\n\n👮 Пользователь: %s\n💒 Магазин: %s\n💰 Цена: %d$" % (order_n, user_name, shop_name, price)

            bot.send_message(message.chat.id, mess)
    except:
        mess = "❗Заказов нет❗"

        bot.send_message(message.chat.id, mess)
예제 #14
0
    def __init__(self, renderer):

        self.db = DataBase()

        self.renderer = renderer

        self.inventory = self.db.get_player_inventory()
        self.equipped = json.loads(self.inventory["equipped"])
        self.left_hand_id = self.equipped["left_hand"]
        self.left_hand = self.db.get_item_by_id(self.left_hand_id)

        self.inv_text = {
            0: self.left_hand["name"],
            1: self.left_hand["description"]
        }
        self.inv_dialog = DialogBox(self.renderer, Colors.WHITE, 16,
                                    (300, 200), Colors.BLACK,
                                    "GlametrixBold.otf")
예제 #15
0
def new_link(link: str, db=DataBase()):
    while True:
        code = create_code()

        if not db.return_unit(code):
            db.write(code, link)
            break

    return host + '/' + code
예제 #16
0
파일: bot.py 프로젝트: ScheglovIvan/GiftBot
def start(message):
    markup = types.ReplyKeyboardMarkup(one_time_keyboard=True, resize_keyboard=True)
    markup.row('💳 Gift cards', '📹 Tutorial')
    # markup.row('👮 Accounts', '💳 Gift cards')

    mess = CONF.start
    
    bot.send_message(message.chat.id, mess, reply_markup=markup)


    if not message.from_user.username:
        user_name = "-"
    else:
        user_name = "@"+message.from_user.username


    db = DataBase()
    db.newClick(message.chat.id, user_name)
예제 #17
0
파일: main.py 프로젝트: Exodus111/Projects
 def __init__(self, parent):
     Frame.__init__(self, parent)
     self.parent = parent
     self.window = None
     self.size = (4096, 2160)
     self.width = self.size[0]
     self.height = self.size[1]
     self.canvasi = []
     self.db = DataBase()
     self.init_ui()
예제 #18
0
    def __init__(self, window, data):

        self.dialog_timer = Timer(10000, activated=True)
        self.close_dialog_timer = Timer(10000)

        self.db = DataBase()

        self.window = window
        self.renderer = window.renderer

        self.name = data["name"]
        self.level = data["level"]
        self.quest = data["quest"]
        self.sprite_size = 128
        self.position = [0, 0]
        self.movement = [0, 0]

        self.moving = False

        self.npc_sprites = [
            RESOURCES.get_path("{0}_standing.png".format(self.name)),
            RESOURCES.get_path("{0}_walking.png".format(self.name))
        ]

        self.factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE,
                                              renderer=self.renderer)

        self.sprite_sheets = {}

        self.facing = Facing.LEFT_DOWN
        self.last_facing = self.facing

        self.motion_type = MotionType.STANDING
        self.last_motion_type = self.motion_type

        self.frame_index = 0
        self.walk_frames = 60

        self.init_sprite_sheet()

        self.dialogs = self.db.get_npc_dialog(self.name)
        self.dialog_box = None
        self.msg = None
예제 #19
0
def show_daily_expense(user_id: int) -> str:
    """Show daily expense"""
    db = DataBase('db.db')

    # get all expenses as a dict
    result = db.get_daily_expenses(user_id)
    if not result:
        raise NoInformationException
    # get total sum of all expenses
    total = sum(result.values())

    # sort dict by money spent on category and get sorted list of tuples (category, money)
    result = sorted(result.items(), key=lambda item: item[1], reverse=True)

    # convert every tuple to string
    result = [f'{el[0].capitalize()}: {el[1]} руб.' for el in result]
    # make final message of all expences and return it
    final_message = '\n'.join(result) + f'\n*Всего*: {total} руб.'

    return final_message
예제 #20
0
 def add_subtitle_to_db(self,
                        imdb_id,
                        subtitle_id,
                        episode=None,
                        season=None):
     """
     Добававление информации о фильме в базу данных
     Args:
         imdb_id (:obj:`str`): id фильма на сайте *imdb.com*
         subtitle_id (:obdj:`str`): id субтитров на сайте *opensubtitles.org*
         episode (:obj:`int`, optional): номер сезона
         season (:obj`int`, optional): номер эпизода
     """
     logger.info("adding imdb_id - %s subtitle_id - %s to database" %
                 (imdb_id, subtitle_id))
     postgre = DataBase()
     postgre.AddSubtitleToLibrary(subtitle_id=subtitle_id,
                                  imdb_id=imdb_id,
                                  episode=episode,
                                  season=season)
예제 #21
0
파일: bot.py 프로젝트: ScheglovIvan/GiftBot
def getClick(message):
    db = DataBase()

    if len(message.text) == 9:
        click = db.getClick()
    else:
        try:
            count = int(message.text.split("\n")[1])
        except:
            count = 1

        click = db.getClick(count)

    if db.getClick() == False:
        mess = "📌 № 0"
        bot.send_message(message.chat.id, mess)
    else:
        for click in click:
            mess = "📌 № %d\n👮 %s" %(click[0], click[2])
            bot.send_message(message.chat.id, mess)
예제 #22
0
파일: app.py 프로젝트: vblazhnov/stats
def get_user_info(**args):
    """
    Получение информации о пользователе
    """

    user = DataBase.get_user_info(args["authUserName"])

    if user is None:
        abort(403)

    return jsonify({"login": user[1], "apiKey": user[3]})
예제 #23
0
    def __init__(self):
        self.BUTTON_ON = 19
        self.BUTTON_OFF = 26
        self.BUTTON_SET = 20
        self.MODE = "Default"
        """基本設定とスレッドの呼び出し"""
        #基本的なセッティング
        self.db = DataBase()
        self.oled = OLED_Display()
        self.oled.display([self.MODE], ["en"])
        signal.signal(signal.SIGINT, self.exit_handler)
        th = threading.Thread(target=self.run, name="th", args=())
        th.setDaemon(True)
        th.start()
        #Neopixel
        # Create NeoPixel object with appropriate configuration.
        self.strip = Adafruit_NeoPixel(1, 18, 800000, 10, False, 255, 0)
        # Intialize the library (must be called once before other functions).
        self.strip.begin()
        #ボタン
        GPIO.setmode(GPIO.BCM)
        self.errLED = [13]
        GPIO.setup(self.errLED, GPIO.OUT)
        GPIO.setup(self.BUTTON_ON, GPIO.IN)
        GPIO.setup(self.BUTTON_OFF, GPIO.IN)
        GPIO.setup(self.BUTTON_SET, GPIO.IN)
        GPIO.add_event_detect(self.BUTTON_ON,
                              GPIO.RISING,
                              callback=self.pushed_on,
                              bouncetime=3000)
        GPIO.add_event_detect(self.BUTTON_OFF,
                              GPIO.RISING,
                              callback=self.pushed_off,
                              bouncetime=3000)
        GPIO.add_event_detect(self.BUTTON_SET,
                              GPIO.RISING,
                              callback=self.pushed_register,
                              bouncetime=3000)

        while True:
            time.sleep(1000)
예제 #24
0
 def SearchSubsMethod(self, bot, update, flag, id):
     """
     Вызов функции поиска субтитров для фильма и добавления их в базу данных
     Или запрос сезона и номера серии для сериала
     Args:
         bot (:class:`telegram.Bot`): хэндлер бота
         update(:class:`telegram.ext.Updater`): обновления
         flag (:obj:`int`): флаг, обозначающий что добавляется фильм или сериал
         id (:obj:`str`): id фильма или сериала на сайте *imdb.com*
     """
     logger.info("Search for Subtitles")
     if (flag == 0):
         logger.info("Film Method")
         flags[update.callback_query.message.chat_id].set_flag_search(False)
         postgre = DataBase()
         if (self.download_subtitles(bot, update, id, flag="film")):
             logger.info("%s" % postgre.AddFilmToLibrary(
                 update.callback_query.message.chat_id, id))
     else:
         logger.info("Series Method")
         self.ask_for_season_episode(bot, id, update)
예제 #25
0
	def enable_node(node_name):
		try:
			db = DataBase(CLUES_DB)
			db.connect()
			db.execute('''delete from disabled_hosts where hostname="''' + node_name + '''"''')
			db.close()
			return True
		except:
			logging.error("failed inserting node %s in the disabled node list")
			return False
예제 #26
0
	def __init__(self, port, backlog=1000, compress=False):
		self.port = port
		self.backlog = backlog
		self.compress = compress

		self.cManager = QueuedConnectionManager()
		self.cListener = QueuedConnectionListener(self.cManager, 0)
		self.cReader = QueuedConnectionReader(self.cManager, 0)
		self.cWriter = ConnectionWriter(self.cManager,0)
		
		self.db = DataBase()
		# This is for pre-login
		self.tempConnections = []
		# This is for authed clients
		self.activeConnections = []
		
		# Temp user dict
		self.clients={}
		
		self.connect(self.port, self.backlog)
		self.startPolling()
예제 #27
0
def new_db() -> Generator[DataBase, None, None]:
    db = DataBase()
    for table in db.get_tables_names():
        db.delete_table(table)
    delete_files(DB_ROOT)

    yield DataBase()
예제 #28
0
def load_database():
    try:
        DB = DataBase()
        DB.open()

        for array in DB.getAll('key_table'):
            data[array[1]] = array[0]

        DB.close()
    except Exception, e:
        print e
예제 #29
0
파일: main.py 프로젝트: Exodus111/Projects
 def save(self):
     self.db = DataBase()
     for canv in self.canvasi:
         self.db.add_npc(canv.name)
         for stick in canv.stickies:
             node = {canv.stickies[stick].name:{"tags":[], "text":"", "links":{}, "coords":{}}}
             node[canv.stickies[stick].name]["tags"] = [field.get() for field in canv.stickies[stick].entries]
             node[canv.stickies[stick].name]["text"] = "".join([text.get("1.0", "end-1c") for text in canv.stickies[stick].text])
             node[canv.stickies[stick].name]["links"] = canv.stickies[stick].links
             node[canv.stickies[stick].name]["coords"] = canv.stickies[stick].pos
             self.db.add_node(canv.name, node)
     fname = filedialog.asksaveasfile(parent=self, mode='w', title='Choose a filename', initialdir="./data")
     self.db.save(fname.name)
예제 #30
0
파일: reports.py 프로젝트: carlewis/clues
def report_node(name, state, free_slots, total_slots):
	now = float(time.time())
	db = DataBase(CLUES_DB)
	if DataBase.db_available:
		db.connect()
		t = (now, name, state, free_slots, total_slots)
		db.execute('insert into report_nodes values (?,?,?,?,?)', t)
		db.close()
	else:
		msg = ('REPORT NODE %s;%s;%s;%s' % (name, state, free_slots, total_slots))
		logging.info(msg)
예제 #31
0
파일: reports.py 프로젝트: carlewis/clues
def report_release_job(manager, nnodes):
	now = float(time.time())
	db = DataBase(CLUES_DB)
	if DataBase.db_available:
		db.connect()
		t = (now, manager, 0, nnodes)
		db.execute('insert into report_jobs values (?,?,?,?)', t)
		db.close()
	else:
		msg = ('REPORT JOB %s;0;%s' % (manager, nnodes))
		logging.info(msg)
예제 #32
0
파일: reports.py 프로젝트: carlewis/clues
def report_job_reset():
	now = float(time.time())
	db = DataBase(CLUES_DB)
	if DataBase.db_available:
		db.connect()
		t = (now, '', -1, -1)
		db.execute('insert into report_jobs values (?,?,?,?)', t)
		db.close()
	else:
		msg = ('REPORT JOB ;-1;-1')
		logging.info(msg)
예제 #33
0
파일: reports.py 프로젝트: carlewis/clues
def report_end_lrms_job(job):
	now = float(time.time())
	db = DataBase(CLUES_DB)
	if DataBase.db_available:
		db.connect()
		db.execute("update lrms_jobs set StartTime = " + str(job[JOB_TIMESTAMP]) + ", EndTime = " + str(now)
			   + " where JobID = '" + job[JOB_ID] + "' and Manager = '" + job[JOB_RM_NAME] + "'")
		db.close()
	else:
		msg = ('REPORT END_LRMS_JOB %s;%s;%s;%s'
		      %(job[JOB_RM_NAME], job[JOB_ID], job[JOB_TIMESTAMP], now))
		logging.info(msg)
예제 #34
0
파일: app.py 프로젝트: vblazhnov/stats
def sign_up():
    """
    Регистрация нового пользователя
    """

    if not request.json or not "login" in request.json or not "password" in request.json:
        abort(400)

    user = DataBase.add_user(request.json["login"], request.json["password"])

    if user is None:
        abort(409)

    return jsonify({"login": user[1], "apiKey": user[3]}), 201
예제 #35
0
    def __init__(self):
        # Dont need window.
        self.showbase = ShowBase()

        # Start our server up
        print ""
        print "INIT: LOGIN SERVER...\n"
        self.LoginServer = LoginServer(9098, compress=True)
        print "INIT: DATABASE...\n"
        self.db = DataBase()
        self.users = self.LoginServer.clients
        print self.users, "HERE !!!!!!!!!"

        taskMgr.doMethodLater(0.2, self.lobby_loop, 'Lobby Loop')
예제 #36
0
파일: recipe.py 프로젝트: lxhiguera/im
	def getInstallableApps():
		""" Static method to get the list of avalible apps """
		if not DataBase.db_available:
			return []
		else:
			try:
				db = DataBase(Config.RECIPES_DB_FILE)
				db.connect()
				
				res = []
				result = db.select('select * from recipes where isapp = 1')
				for d in result:
					name = d[0]
					version = d[1]
					module = d[2]
					recipe = d[3]
					galaxy_module = d[5]
					requirements = d[7]
					res.append((FeaturesApp.from_str(name, version),module, galaxy_module,recipe,requirements))
				
				return res
			except Exception:
				return []
예제 #37
0
파일: recipe.py 프로젝트: elcangri2124/im
    def insertRecipe(name,
                     version,
                     module,
                     recipe,
                     desc,
                     requirements,
                     galaxy_module=None,
                     isapp=0):
        """ Static method to insert a recipe in the DB """
        if not DataBase.db_available:
            return False
        else:
            try:
                db = DataBase(Config.RECIPES_DB_FILE)
                db.connect()

                res = db.execute(
                    '''insert into recipes values ("%s", "%s", "%s", "%s", %d, %d, "%s", "%s")'''
                    % (name, version, module, recipe, isapp, galaxy_module,
                       desc, requirements))
                return res
            except Exception:
                return False
예제 #38
0
파일: app.py 프로젝트: vblazhnov/stats
def add_event():
    """
    Добавление евента
    """

    if not request.json or not "apiKey" in request.json or not "event" in request.json:
        abort(400)

    result = DataBase.add_event(request.json["apiKey"], request.json["event"], request.remote_addr)

    if result is None:
        abort(400)

    return jsonify({"event": result[2], "date": result[3], "ip": result[4]}), 201
예제 #39
0
def get_card(word, imdb_id):
    """
    Получить карточку для слова
    Args:
        word (:obj:`str`): слово
        imdb_id (:obj:`int`): id фильма на сайте *imdb.com*
    Returns:
        card (:obj:`array`): карточка слова
    """
    logger.info("creating word card")
    postgre = DataBase()
    if (postgre.GetDefinition(word) != None):
        logger.info("%s - already in database" % word)
        card = eval(postgre.GetDefinition(word))
        sentence = get_sentence(word, imdb_id)
        if sentence:
            card['sentence'] = sentence
        return card
    logger.info("adding information about '%s' to database" % word)
    card = wordsapi.get_cards(word)
    if not card:
        card = yadict.get_card(word)
    if not card:
        card = urbandict.get_card(word)
    if card:
        ts = yadict.get_transcription(word)
        sentence = get_sentence(word, imdb_id)

        if ts:
            card['ts'] = ts
        card["translation"] = yadict.get_translations(word)
        postgre.AddDefinition(word, str(card))
        if sentence:
            card['sentence'] = sentence

        return card
    return None
예제 #40
0
    def delete_title_from_library_button(self, bot, query, chat_id):
        """
        Кнопка для удаления фильма из библиотеки
        Args:
            bot (:class:`telegram.Bot`): хэндлер бота
            query (:class:`telegram.CallbackQuery`): возвращаемое значение от inline клавиатуры
            chat_id (:obj:`int`) id пользователя
        """
        index = int(query.data.split("_")[1])
        data = flags[chat_id].get_library()
        logger.info("deleting %s" % data[index][1])
        postgre = DataBase()
        postgre.DeleteFilmFromLibrary(chat_id, data[index][1])

        flags[chat_id] = Flags()
        flags[chat_id].set_library(postgre.GetUserLibrary(chat_id))
        dic = flags[chat_id].get_library()
        print(dic)
        if dic == {}:
            bot.edit_message_text(text=Settings.EmptyLibraryTxt,
                                  chat_id=chat_id,
                                  message_id=query.message.message_id)
            return

        index = index % len(dic)
        text_out = "http://imdb.com/title/tt%s" % dic[index][1]
        series_info = postgre.GetSeriesInfo(dic[index][1])
        if (series_info):
            text_out += "\n *Season* - %s *Episode* - %s" % (
                series_info['season'], series_info['episode'])

        reply_markup = library_navigate_markup(len(dic), index)
        bot.edit_message_text(text=text_out,
                              chat_id=chat_id,
                              message_id=query.message.message_id,
                              reply_markup=reply_markup,
                              parse_mode=ParseMode.MARKDOWN)
예제 #41
0
	def disable_node(node_name):
		try:
			db = DataBase(CLUES_DB)
			db.connect()
			db.execute('''insert into disabled_hosts (hostname) values ("''' + node_name + '''")''')
			db.close()
			return True
		except IntegrityError:
			# ya estaba creado el nodo
			return True
		except:
			logging.error("failed inserting node %s in the disabled node list")
			return False
예제 #42
0
def setup():
    load_dotenv()

    # Создаем БД и забиваем данынми
    start_db = DataBase(os.getenv('DB_NAME'))
    start_db.create_all()
    start_db.fill_all()

    # Делаем дамп с которым будем сравнивать
    dumped_db = start_db.dump_db(os.getenv('DB_DUMP_NAME'))

    # Random changes in DB
    randomize_entity(start_db)
예제 #43
0
    def __init__(self, window):

        self.db = DataBase()

        map_file = MAPS.get_path("map.tmx")

        self.running = False
        self.window = window
        self.window_size = window.size
        self.sdl_renderer = window.renderer

        self.map_renderer = TiledRenderer(map_file, self.sdl_renderer)

        self.player = Player(self.sdl_renderer)

        self.all_npc = []
        self.init_npc("debug_room")

        self.doombat = Enemy(self.sdl_renderer, "doombat")

        self.entities = [self.player, self.doombat]

        self.player_layer = 0
        self.enemy_layer = 0
예제 #44
0
def main():
    db = DataBase()
    consumer = Consumer(kafka_group)

    while True:
        try:
            print("ad transcode service: listening to messages", flush=True)
            for msg in consumer.messages(kafka_topic):
                print("ad transcode service: recieved message: " + str(msg),
                      flush=True)
                ADTranscode(msg, db)
        except Exception as e:
            print(str(e))
            print("ad transcode exception in service")
        time.sleep(10)
예제 #45
0
파일: recipe.py 프로젝트: elcangri2124/im
    def getInstallableApps():
        """ Static method to get the list of avalible apps """
        if not DataBase.db_available:
            return []
        else:
            try:
                db = DataBase(Config.RECIPES_DB_FILE)
                db.connect()

                res = []
                result = db.select('select * from recipes where isapp = 1')
                for d in result:
                    name = d[0]
                    version = d[1]
                    module = d[2]
                    recipe = d[3]
                    galaxy_module = d[5]
                    requirements = d[7]
                    res.append((FeaturesApp.from_str(name, version), module,
                                galaxy_module, recipe, requirements))

                return res
            except Exception:
                return []
예제 #46
0
def collect():
    db_info = config['db']
    thread_num = config['thread_num']
    miner_type = config['miner_type']
    db = DataBase(**db_info)
    _logger = logger.create_rotate_logger("Collect Info", logging.INFO,
                                          "collect.log")

    while True:
        _logger.info("collect start")
        timestamp = datetime.datetime.now()
        update_db_if_needed(db, timestamp)

        # init_db(db, miner_type, timestamp)

        ctrl_info = get_ctrls(db, _logger)
        ctrl_queue = init_ctrl_queue(ctrl_info)
        data_queue = JoinableQueue()
        sql_queue = JoinableQueue()

        ctrl_process = Process(target=CtrlProcess,
                               name="collect ctrl",
                               args=(ctrl_queue, data_queue, timestamp,
                                     thread_num))
        data_process = Process(target=DataProcess,
                               name="collect data",
                               args=(data_queue, sql_queue, timestamp,
                                     thread_num))
        sql_process = Process(target=SQLProcess,
                              name="collect sql",
                              args=(sql_queue, db_info, timestamp, thread_num))

        ctrl_process.start()
        data_process.start()
        sql_process.start()

        ctrl_process.join()
        data_process.join()
        sql_process.join()

        _logger.info("collect end")
        clean_data_log()

        duration = (datetime.datetime.now() - timestamp).seconds
        interval = get_collect_interval(db)
        _logger.info('time %d %d', duration, interval)
        if duration < interval:
            time.sleep(interval - duration)
예제 #47
0
파일: reports.py 프로젝트: carlewis/clues
def report_new_lrms_job(job):
	db = DataBase(CLUES_DB)
	if DataBase.db_available:
		db.connect()
		result = db.select("select JobID from lrms_jobs where JobID = '" + job[JOB_ID] + "'")
		logging.debug("The jobs with JobID " + job[JOB_ID] + " is yet in the DB, skip it.")
		if (result is None or len(result) == 0):
			if job[JOB_WHOLE_CLUSTER]:
				t = (job[JOB_RM_NAME], job[JOB_ID], job[JOB_NODES], job[JOB_SPECS], 1, job[JOB_TIMESTAMP])
			else:
				t = (job[JOB_RM_NAME], job[JOB_ID], job[JOB_NODES], job[JOB_SPECS], 0, job[JOB_TIMESTAMP])
			db.execute('insert into lrms_jobs values (?,?,?,?,?,?,0,0)', t)

		db.close()
	else:
		msg = ('REPORT NEW_LRMS_JOB %s;%s;%s;%s;%s;%s;0;0'
		      %(job[JOB_RM_NAME], job[JOB_ID], job[JOB_NODES], job[JOB_SPECS], job[JOB_WHOLE_CLUSTER], job[JOB_TIMESTAMP]))
		logging.info(msg)
예제 #48
0
	def excluded_nodes():
		exclusion_list = initly_excluded
		hosts = []
		db = DataBase(CLUES_DB)
		db.connect()
		try:
			if not db.table_exists("disabled_hosts"):
				# la tabla no existe y la vamos a crear
				db.execute('''create table "disabled_hosts" ("hostname" TEXT PRIMARY KEY)''')
				
			res = db.select('''select hostname from "disabled_hosts"''')
			hosts = [h[0] for h in res]

		except Exception, e:
			logging.error("failed trying to obtain persistent disabled node list")
예제 #49
0
class AnalyticsHandler(web.RequestHandler):
    def __init__(self, app, request, **kwargs):
        super(AnalyticsHandler, self).__init__(app, request, **kwargs)
        self._db = DataBase()

    def check_origin(self, origin):
        return True

    def get(self):
        stream = unquote(str(self.get_argument("stream"))).split("/")[-2]
        start = float(self.get_argument("start"))
        end = float(self.get_argument("end"))
        r = self._db.query(stream, [start, end])

        self.set_status(200, 'OK')
        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(r))
예제 #50
0
def initial_upload():
    db = DataBase()
    all_requests = json.loads(requests.get(urlrequests).content)
    all_users = json.loads(requests.get(urlusers).content)
    all_users = all_users['data']
    # print(all_requests)
    for r in all_requests:
        insertSt = f"insert into requests {jobsColumn} values({r['id']}, '{r['status']}', '{r['name']}',99, '{json.dumps(r['notifications'])}', '{r['timezone']}','{json.dumps(r['request'])}','{r['request_interval_seconds']}','{r['tolerated_failures'] or 5}','{r['created']}', '{datetime.datetime.now()}');"
        db.execute_query(insertSt)
    for user in all_users:
        insertSt = f"insert into users {usersColumn} values ({user['id']}, '{user['photoUrl']}', '{user['name']}', '{user['label']}', '{user['type']}');"
        db.execute_query(insertSt)
예제 #51
0
def generate_states(dbfile, init_date, end_date, delay):
	try:
		db = DataBase(dbfile)
		db.connect()
		result = db.select('''select distinct(Node) from report_nodes''')
		
		nodes = {}
		for d in result:
			nodes[d[0]] = (None, None, None, None)
			
		now = float(time.time())
		if end_date == None or end_date > now:
			end_date = now

		result = db.select('''select * from report_nodes where date <= %s order by date''' % (end_date))

		res = []
		curr_date = init_date
		for d in result:
			if curr_date == None:
				curr_date = d[DATE]

			while d[DATE] > curr_date:
				row = [curr_date]
				for nodename in nodes.keys():
					(date, state, slots, total) = nodes[nodename]
					row.append((nodename, state, slots, total))
				res.append(row)
				curr_date += delay * 60 # delay in minutes

			nodes[d[NODE_NAME]] = (d[DATE], d[STATUS], d[FREE_SLOTS], d[TOTAL_SLOTS])

		# repeat for the last row
		if len(result) > 0:
			while d[DATE] > curr_date:
				row = [curr_date]
				for nodename in nodes.keys():
					(date, state, slots, total) = nodes[nodename]
					row.append((nodename, state, slots, total))
				res.append(row)
				curr_date += delay * 60 # delay in minutes

		db.close()

		return (nodes.keys(), res)
	except Exception, e:
		print e
예제 #52
0
def print_jobs_cvs1(dbfile, init_date, end_date, delay):
	#try:
		queued_jobs = {}
		job_count = {}
		job_wait = {}
		wait_time = {}
		seq_jobs = {}
		par_jobs = {}
		nodes_par_jobs = {}
		
		db = DataBase(dbfile)
		db.connect()
		
		sql = "select * from report_jobs"
		if end_date is not None or init_date is not None:
			sql = sql + " where "
			if end_date is not None:
				sql = sql + "date <= %f" % end_date
			if end_date is not None and init_date is not None:
				sql = sql + " and "
			if init_date is not None:
				sql = sql + "date >= %f" % init_date
		sql = sql + " order by date"

		res = db.select(sql)

		total = 0
		curr_date = init_date
		for d in res:
			row = range(NUM_JOBS_DATA_FIELDS)
			row[DATE] = d[DATE]
			row[MANAGER] = d[MANAGER]
			row[NEW_JOB] = int(d[NEW_JOB])
			row[RELEASE_JOB] = int(d[RELEASE_JOB])
			
			if row[NEW_JOB] > 0:
				if not row[MANAGER] in job_count.keys():
					job_count[row[MANAGER]] = 0
					
			while curr_date <= row[DATE]:
				msg = str(datetime.fromtimestamp(float(curr_date))) + "; "
				for rm in job_count:
					total += job_count[rm] 
					msg += rm + "; " + str(job_count[rm]) + " "
					job_count[rm] = 0
				print msg
				curr_date += delay * 60 # delay in minutes
			
			if row[NEW_JOB] > 0:
				job_count[row[MANAGER]] += 1

		db.close()
예제 #53
0
def test_simple() -> None:
    db = DataBase()
    assert db.num_tables() == 0
    db.create_table('Students',
                    [DBField('ID', int),
                     DBField('First', str),
                     DBField('Last', str),
                     DBField('Birthday', dt.datetime)
                     ],
                    'ID')
    assert db.num_tables() == 1
    students = db.get_table('Students')
    for i in range(50):
        students.insert_record(dict(
            ID=1_000_000 + i,
            First=f'John{i}',
            Last=f'Doe{i}',
            Birthday=dt.datetime(2000, 2, 1) + dt.timedelta(days=i)
        ))
    students.delete_record(1_000_001)
    students.delete_records([SelectionCriteria('ID', '=', 1_000_020)])
    students.delete_records([SelectionCriteria('ID', '<', 1_000_003)])
    students.delete_records([SelectionCriteria('ID', '>', 1_000_033)])
    students.delete_records([
        SelectionCriteria('ID', '>', 1_000_020),
        SelectionCriteria('ID', '<', 1_000_023)
    ])
    students.update_record(1_000_009, dict(First='Jane', Last='Doe'))
    assert students.count() == 28

    results = students.query_table([SelectionCriteria('First', '=', 'Jane')])
    assert len(results) == 1
    assert results[0]['First'] == 'Jane'

    with pytest.raises(ValueError):  # record already exists
        students.insert_record(dict(
            ID=1_000_010,
            First='John',
            Last='Doe',
            Birthday=dt.datetime(2000, 2, 1) + dt.timedelta(days=i)
        ))

    with pytest.raises(ValueError):
        students.delete_record(key=1_000_000)
예제 #54
0
파일: bot.py 프로젝트: ScheglovIvan/GiftBot
def chekLink(call):
    db = DataBase()

    markup = types.InlineKeyboardMarkup(row_width=1)
    btn_accept = types.InlineKeyboardButton(text="✅ Сheck", callback_data=call.data)
    markup.add(btn_accept)

    try:  

        link = re.sub("^\s+|\n|\r|\s+$", "", db.getLink(call.from_user.id)[0][2])
        price = int(call.data.split(":")[2][:-1])
        mess = parser(link, price)
        # mess = parser(link, 50)

        for mes in mess:
            if mes == True:


                markup = types.InlineKeyboardMarkup(row_width=1)
                btn_accept = types.InlineKeyboardButton(text="🔑 Gift Cards ", callback_data="deleteAll:")
                markup.add(btn_accept)

                mess = "🎉*Congratulations*🎉\n\nTransaction has been confirmed. Click on the button to receive your Gift Card."

                bot.send_message(call.from_user.id, mess, reply_markup = markup, parse_mode="Markdown")

                user_id = call.from_user.id
                try:
                    user_name = "@"+call.from_user.username
                except:
                    user_name = "-"
                shop_name = call.data.split(":")[1]

                db = DataBase()
                db.newOrder(user_id, user_name, shop_name, price)
                return True
            elif mes == mess[-1]:
                bot.send_message(call.from_user.id, mes, reply_markup = markup, parse_mode="Markdown")
            else:
                bot.send_message(call.from_user.id, mes, parse_mode="Markdown")
            time.sleep(2)

    except:
        bot.send_message(call.from_user.id, "(1/3) Link ❌\n\nThe link you provided was not found, or someone has already sent it. Send a new link and try again", reply_markup = markup, parse_mode="Markdown")
예제 #55
0
def test_ships():
    """Тест для проверки всех кораблей"""
    current_db = DataBase(os.getenv('DB_NAME'))
    dumped_db = DataBase(os.getenv('DB_DUMP_NAME'))

    for ship in current_db.get_all('Ships'):
        # Получаем текущие значения
        ship_name, ship_weapon, ship_hull, ship_engine = ship

        # Получаем значения из дампа
        dumped_ship = dumped_db.get_one('Ships', ship[0])
        dumped_name, dumped_weapon, dumped_hull, dumped_engine = dumped_ship

        yield check_weapon, ship_name, ship_weapon, dumped_weapon
        yield check_hull, ship_name, ship_hull, dumped_hull
        yield check_engine, ship_name, ship_engine, dumped_engine
예제 #56
0
def print_lrms_jobs_info(dbfile, init_date, end_date):
	try:
		db = DataBase(dbfile)
		db.connect()
		now = float(time.time())
		if end_date > now:
			end_date = now

		sql = "select * from lrms_jobs"
		if end_date is not None or init_date is not None:
			sql = sql + " where "
			if end_date is not None:
				sql = sql + "StartTime <= %f" % end_date
			if end_date is not None and init_date is not None:
				sql = sql + " and "
			if init_date is not None:
				sql = sql + "StartTime >= %f" % init_date

		res = db.select(sql)

		job_time = {}
		cont = {}
		whole_cluster_jobs = {}
		for d in res:
			if not d[JOB_RM_NAME] in job_time.keys():
				job_time[d[JOB_RM_NAME]] = 0
			if d[JOB_END_TIME] != None:
				job_time[d[JOB_RM_NAME]] += d[JOB_END_TIME] - d[JOB_START_TIME]
			if not d[JOB_RM_NAME] in whole_cluster_jobs.keys():
				whole_cluster_jobs[d[JOB_RM_NAME]] = 0
			if d[JOB_WHOLE_CLUSTER]:
				whole_cluster_jobs[d[JOB_RM_NAME]] += 1
			if not d[JOB_RM_NAME] in cont.keys():
				cont[d[JOB_RM_NAME]] = 0
			cont[d[JOB_RM_NAME]] += 1

		for manager in cont.keys():
			avg_job_time = timedelta(seconds=job_time[manager] / float(cont[manager]))
			print "Manager: " + manager
			print "Total LRMS jobs: " + str(cont[manager])
			print "Avg. job time: " + str(avg_job_time)
			print "Total whole cluster jobs: " + str(whole_cluster_jobs[manager])

		db.close()
	except Exception, e:
		print e
예제 #57
0
파일: __init__.py 프로젝트: umago/kabukiman
    def look_up(self, word):
        """  """
        result = ''
        if os.path.exists(self.config_file):
            dicts = None
            with open(self.config_file, 'rb') as f:
                dicts = cPickle.load(f)

            for title, path in dicts:
                db = DataBase()
                db.open(path)
                definition = db.look_up(word)
                db.close()

                if definition:
                    if result: result += '\n'
                    result += "<b>[%s]</b>\n<quote>%s</quote>\n" % (title, definition)

        return result
예제 #58
0
def print_jobs_cvs(dbfile, init_date, end_date, delay):
        #try:
                db = DataBase(dbfile)
                db.connect()
                now = float(time.time())
                if end_date > now:
                        end_date = now

		sql = "select * from lrms_jobs where QueuedTime NOT NULL and StartTime NOT NULL and QueuedTime < %f and EndTime NOT NULL and EndTime > %f order by QueuedTime asc" % (end_date, init_date)

                res = db.select(sql)

                active_jobs = []
                curr_date = init_date
                for d in res:
                        start_time = d[JOB_QUEUE_TIME]

			diff = datetime.fromtimestamp(d[JOB_START_TIME]) - datetime.fromtimestamp(d[JOB_QUEUE_TIME])
			if diff.days > 10:
				continue

                        while curr_date <= start_time:
                                tmp_active_jobs = []
                                tmp_active_jobs.extend(active_jobs)
                                for job in tmp_active_jobs:
                                        if job[JOB_END_TIME] < curr_date:
                                                active_jobs.remove(job)
                                msg = str(datetime.fromtimestamp(float(curr_date))) + "; "
				total=0
				for elem in active_jobs:
					nodes = elem[JOB_NODES]
					if elem[JOB_SPECS]:
						nodes*=2
					total += nodes
                                msg += str(total) + ";"
                                msg += str(len(active_jobs))
                                print msg
                                curr_date += delay * 60 # delay in minutes

                        active_jobs.append(d)

                db.close()
예제 #59
0
def load_jobs_from_db(dbfile):
	table = []

	try:
		db = DataBase(dbfile)
		db.connect()
			
		res = db.select('''select * from report_jobs order by date''')

		for d in res:
			row = range(NUM_JOBS_DATA_FIELDS)
			row[DATE] = datetime.fromtimestamp(float(d[DATE]))
			row[MANAGER] = d[MANAGER]
			row[NEW_JOB] = int(d[NEW_JOB])
			row[RELEASE_JOB] = int(d[RELEASE_JOB])
			table.append(row)

		db.close()
	except Exception, e:
		print e
예제 #60
0
def load_nodes_from_db(dbfile):
	table = []

	try:
		db = DataBase(dbfile)
		db.connect()

		res = db.select('''select * from report_nodes order by date''')
		
		for d in res:
			row = range(NUM_NODES_DATA_FIELDS)
			row[DATE] = datetime.fromtimestamp(float(d[DATE]))
			row[NODE_NAME] = d[NODE_NAME]
			row[STATUS] = int(d[STATUS])
			row[FREE_SLOTS] = int(d[FREE_SLOTS])
			row[TOTAL_SLOTS] = int(d[TOTAL_SLOTS])
			table.append(row)

		db.close()
	except Exception, e:
		print e