コード例 #1
0
    def __init__(self, initial_vars=None) -> None:
        self.total_self_progress = 0  # if > 0 output progress during run (as apposed to batch file progress)

        self.the_command = None
        self.fixed_command = None

        DBManager.__init__(self)
        IndexYamlReaderBase.__init__(self, config_vars)

        self.path_searcher = utils.SearchPaths(config_vars, "__SEARCH_PATHS__")
        self.url_translator = connectionBase.translate_url
        self.init_default_vars(initial_vars)
        # noinspection PyUnresolvedReferences
        self.read_defaults_file(super().__thisclass__.__name__)
        # initialize the search paths helper with the current directory and dir where instl is now
        self.path_searcher.add_search_path(Path.cwd())
        self.path_searcher.add_search_path(
            Path(config_vars["__ARGV__"][0]).resolve())
        self.path_searcher.add_search_path(
            config_vars["__INSTL_DATA_FOLDER__"].Path())

        self.batch_accum = PythonBatchCommandAccum()
        self.dl_tool = CUrlHelper()

        self.out_file_realpath = None
        self.internal_progress = 0  # progress of preparing installer NOT of the installation
        self.num_digits_repo_rev_hierarchy = None
        self.num_digits_per_folder_repo_rev_hierarchy = None
        self.update_mode = False
        self.python_batch_names = PythonBatchCommandBase.get_derived_class_names(
        )
コード例 #2
0
    def init_from_cmd_line_options(self, cmd_line_options_obj):
        """ turn command line options into variables """

        if "__MAIN_COMMAND__" in config_vars:
            self.the_command = str(config_vars["__MAIN_COMMAND__"])
            self.fixed_command = self.the_command.replace('-', '_')
        # to do: in python3.8 with the new sqlite.backup function, memory database
        # can be writen to disk if needed
        if getattr(sys, 'frozen', False
                   ) or self.the_command in self.commands_that_need_memory_db:
            config_vars['__MAIN_DB_FILE__'] = ':memory:'
        DBManager.set_refresh_db_file(
            self.the_command in self.commands_that_need_to_refresh_db_file)

        if hasattr(cmd_line_options_obj,
                   "subject") and cmd_line_options_obj.subject is not None:
            config_vars["__HELP_SUBJECT__"] = cmd_line_options_obj.subject
        else:
            config_vars["__HELP_SUBJECT__"] = ""

        if cmd_line_options_obj.which_revision:
            config_vars[
                "__WHICH_REVISION__"] = cmd_line_options_obj.which_revision[0]

        if cmd_line_options_obj.define:
            individual_definitions = cmd_line_options_obj.define[0].split(",")
            for definition in individual_definitions:
                name, value = definition.split("=")
                config_vars[name] = value

        self.get_default_out_file()
コード例 #3
0
    def init_from_cmd_line_options(self, cmd_line_options_obj):
        """ turn command line options into variables """

        if "__MAIN_COMMAND__" in config_vars:
            self.the_command = str(config_vars["__MAIN_COMMAND__"])
            self.fixed_command = self.the_command.replace('-', '_')
        DBManager.set_refresh_db_file(
            self.the_command in self.commands_that_need_to_refresh_db_file)

        if hasattr(cmd_line_options_obj,
                   "subject") and cmd_line_options_obj.subject is not None:
            config_vars["__HELP_SUBJECT__"] = cmd_line_options_obj.subject
        else:
            config_vars["__HELP_SUBJECT__"] = ""

        if cmd_line_options_obj.which_revision:
            config_vars[
                "__WHICH_REVISION__"] = cmd_line_options_obj.which_revision[0]

        if cmd_line_options_obj.define:
            individual_definitions = cmd_line_options_obj.define[0].split(",")
            for definition in individual_definitions:
                name, value = definition.split("=")
                config_vars[name] = value

        self.get_default_out_file()
コード例 #4
0
ファイル: whois.py プロジェクト: zeitkunst/MAICgregator
class WhoisStore(object):
    """Class for storing metadata about schools that we can check before we go directly to the XML (and other types) data store."""

    def __init__(self, dbManager = None):
        # Call methods for creating environments and DB object

        # Setup our DBManager object
        if (dbManager is None):
            self.dbManager = DBManager()
        else:
            self.dbManager = dbManager

        # Try and get our current whois store
        self.whois = self.dbManager.get("whois")

        if (self.whois is None):
            self.dbManager.put("whois", {})
            self.whois = {}

    def _getEduWHOIS(self, domain, whoisServer = "whois.educause.net", port = 43):
        # Make sure we're only looking up the root domain, not the entire domain name
        print "domain: " + domain
        domainSplit = domain.split(".")
        host = domainSplit[-2] + "." + domainSplit[-1]
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((whoisServer, port))
        s.send(host + "\r\n")
    
        response = ""
        while True:
            data = s.recv(4096)
            response += data
    
            if data == '':
                break
        s.close()
    
        responseSplit = response.split("\n")
        try:
            registrantIndex = responseSplit.index("Registrant:")
            result = responseSplit[registrantIndex + 1].strip()
        except ValueError:
            return None

        # HEINOUS, but the WHOIS entry doesn't help us here
        if (domain == "umich.edu"):
            result = "University of Michigan"
        return result


    def getSchoolName(self, hostname):
        print "hostname: " + hostname
        try:
            return self.whois[hostname]
        except KeyError:
            schoolName = self._getEduWHOIS(hostname)
            self.whois[hostname] = schoolName
            self.dbManager.put("whois", self.whois)
            return schoolName
コード例 #5
0
 def __init__(self, cities):
     super(MeetupStatisticsFetcher, self).__init__()
     DBManager.init(1)
     self.cursor = DBManager.get_cursor()
     self.cities = cities
     self.logger = utilities.logger_with_name("StatisticsFetcher")
     self.query, self.title = "", ""
     self.results = dict()
コード例 #6
0
 def start(self):
     db = DBManager(self.filename)
     self.combo['values'] = ()
     for row in db.get_tables_names():
         self.combo['values'] += row
     self.combo.current(0)
     cols = db.get_columns_names(self.combo.get())
     curs = db.get_rows(self.combo.get())
     self.tree_update(curs, cols)
コード例 #7
0
def save_table_to_db(table):
    db_mgr = DBManager()
    array = []
    for row in table:
        fr = int(row['fr'])
        to = int(row['to'])
        re = row['result']
        if isinstance(re, unicode):
            # re.replace(u"\u2018", "'").replace(u"\u2019", "'")
            re = str(re.encode(encoding='utf-8', errors='replace'))

        print('type of re in db saving is: ' + str(type(re)))
        re = re.lower()
        ide = row['identifier']

        if isinstance(ide, unicode):
            ide = str(ide.encode(encoding='utf-8', errors='replace'))
        leads_to = None
        try:
            leads_to = row['leads_to']
        except KeyError:
            pass
        array.append({
            'identifier': ide,
            'fr': fr,
            'to': to,
            're': re,
            'table': row['table_name'],
            'leads_to_table': leads_to
        })

    db_mgr.fuzion_tables.add_many((array))
コード例 #8
0
 def save(self, actor_name, actor_role):
     db_mgr = DBManager()
     db_mgr.table_primary_stats.save_character(character_name=actor_name, role=actor_role,
                                               intelligence=self.intelligence, reflexes=self.reflexes,
                                               technique=self.technique, dexterity=self.dexterity,
                                               presense=self.presense, willpower=self.willpower,
                                               constitution=self.constitution, strength=self.strength,
                                               body=self.body, move=self.move)
コード例 #9
0
ファイル: protobuf_server.py プロジェクト: tslilyai/cs262chat
 def __init__(self):
     '''
     Initializes the protobuf server by setting up a database
     manager object for the server to communicate with.
     
     :return: ProtobufServer object
     '''
     self.db = DBManager()
コード例 #10
0
ファイル: async_core.py プロジェクト: mom1/messager
 def run(self):
     self.database = DBManager('client')
     self.notify('init_db')
     try:
         asyncio.run(self.async_start())
     except Exception as e:
         logger.error(e, exc_info=True)
         # import ipdb; ipdb.set_trace()
         self.notify('fail', msg=str(e))
コード例 #11
0
 def run_sql(self):
     query = self.entry.get()
     db = DBManager(self.filename)
     try:
         curs = db.query(query)
         cols = list(map(lambda x: x[0], curs.description))
         self.tree_update(curs, cols)
     except Exception as e:
         self.error_window = Toplevel(self.master)
         self.error_window.grab_set()
         self.error_window.title('Что-то пошло не так :(')
         self.error_window.minsize(320, 48)
         self.error_window.resizable(0, 0)
         label = ttk.Label(self.error_window, text=e)
         label.pack(side="top", fill="both", padx=5, pady=5)
         ok = ttk.Button(self.error_window,
                         text='Ок',
                         command=self.error_window.destroy)
         ok.pack(side="right", padx=5, pady=5)
コード例 #12
0
ファイル: models.py プロジェクト: hosackm/daboiz
 def __init__(self, **kwargs):
     if self.STANDINGS is None:
         raise Exception('You must set the standings dictionary first')
     self.name = kwargs.get('name')
     #self.teams = kwargs.get('teams')
     self.wins = 0
     self.losses = 0
     self.ties = 0
     self.db = DBManager()
     self.teams = self.sort_by_rec(kwargs.get('teams'))
     self.fill_in_record()
コード例 #13
0
ファイル: models.py プロジェクト: Krypticdator/FSTTRPGTables
 def load(self, name):
     db_mgr = DBManager()
     table = None
     if db_mgr.fuzion_tables.count_options(name) > 0:
         table = db_mgr.fuzion_tables.get_table(name)
     else:
         table = utilities.get_aws_table(name)
         utilities.save_table_to_db(table)
         table = db_mgr.fuzion_tables.get_table(name)
     if table is not None:
         for row in table:
             self.add_option(row.fr, row.to, row.re, leads_to=row.leads_to_table, identifier=row.identifier)
コード例 #14
0
def download_video(update, context):
    db = DBManager()
    url = update.message.text
    chat_id = update.message.chat_id
    quality = db.get_chat_quality(chat_id)
    username = str(update.message.from_user.username)
    if is_url(url) is False:
        update.message.reply_text('Enter Url please')
        return

    file_id = db.get_url_file_id(url, quality)
    if file_id:
        update.message.reply_audio(file_id)
        db.insert_user_request(url, username)
        context.bot.send_message(chat_id=owner_chat_id,
                                 text=TELEGRAM_LOG.format(username, url))
        return
    try:
        meta = downloader.download_video(url, quality)
    except youtube_dl.utils.DownloadError as e:
        update.message.reply_text(str(e))
        return
    audio_file = open(meta.file_name, 'rb')
    cover = open(meta.cover, 'rb')
    response = update.message.reply_audio(
        audio_file,
        title=meta.meta.get('title', None),
        performer=meta.meta.get('uploader', None),
        duration=meta.meta.get('duration', None),
        caption=meta.meta.get('title', None),
        thumb=cover)
    context.bot.send_message(chat_id=owner_chat_id,
                             text=TELEGRAM_LOG.format(username, url))

    db.insert_file_id(url, response['audio']['file_id'], quality)
    db.insert_user_request(url, username)

    os.remove(meta.file_name)
    os.remove(meta.cover)
コード例 #15
0
    def tree_update(self, cursor, columns):
        db = DBManager(self.filename)
        for i in self.tree.get_children():
            self.tree.delete(i)
        self.tree['show'] = 'headings'
        self.tree['columns'] = ()
        self.tree['columns'] = tuple(columns)
        for col in columns:
            self.tree.column(col, stretch=False, width=100)
            self.tree.heading(col, text=col)

        for row in cursor:
            self.tree.insert('', 'end', values=row)
コード例 #16
0
 def load(self, actor_name, actor_role):
     db_mgr = DBManager()
     stats = db_mgr.table_primary_stats.get_character(actor_role, actor_name)
     self.intelligence = stats.intelligence
     self.reflexes = stats.reflexes
     self.technique = stats.technique
     self.dexterity = stats.dexterity
     self.presense = stats.presense
     self.willpower = stats.willpower
     self.constitution = stats.constitution
     self.strength = stats.strength
     self.body = stats.body
     self.move = stats.move
コード例 #17
0
class Engine:
    def __init__(self):
        self.hashnet = Hashnet()
        self.hashnet.load()
        self.db = DBManager(**db_params)

    def match(self, target, candidates, threshold=10):
        hash_matrix = get_hash_matrix(candidates)
        hashcode, features = target

        hamming_dists = hamming_dist(hashcode, hash_matrix)
        indices = np.argpartition(hamming_dists, threshold)[:threshold]
        shortlist = [candidates[i] for i in indices]

        feature_matrix = get_feature_matrix(shortlist)
        dists = cosine_dist(features, feature_matrix)
        winner = shortlist[dists.argmin()]
        distance = dists.min()
        return winner, distance

    def search(self, target_image, page_size):
        tick = datetime.now()
        target_features = self.hashnet.extract_features(target_image)
        session = self.db.Session()
        current_page = 0
        queryset = session.query(Image).filter(Image.hash != None)
        optimal_dist = None
        winner = None
        while True:
            query = queryset.limit(page_size).offset(current_page * page_size)
            candidates = query.all()
            if not len(candidates):
                break
            current_page += 1
            matched, distance = self.match(target_features, candidates)
            if optimal_dist is None or distance < optimal_dist:
                optimal_dist = distance
                winner = matched
        session.close()
        tock = datetime.now()
        print("\nSearching completed in {}".format(tock - tick), flush=True)
        if winner is None:
            print(
                "There is nothing found during the search, most likely because there's not images in the database",
                flush=True)
            return None, None
        print("Most similar image is {}\nwith cosine distance={}".format(
            winner, optimal_dist),
              flush=True)
        return winner, 1 - optimal_dist
コード例 #18
0
  def run(self):
    DBManager.get_connection().jconn.setAutoCommit(False)

    while self.should_run:
      try:
        jobs = self.job_queue.get(True, 5)
      except:
        self.logger.debug("No item in the queue. Waiting for something to do...")
        continue

      self.logger.info("Executing jobs on the database (approx. " + str(self.job_queue.qsize()) + " remaining)")
      for job in jobs:
        match = re.search('UPSERT (.*) VALUES .*', job.query_string)
        self.logger.info("  Job table: " + match.group(1) if match else "finishing group...")
        self.logger.info("  Job size: " + str(get_size(job.values_list) / 1024.0) + " KB")
        utilities.try_execution(
            lambda: DBManager.get_cursor().executemany(job.query_string, job.values_list),
            "Executing query: " + job.query_string + ", Last tuple: " + str(job.values_list[-1]),
            self.logger)

      DBManager.get_connection().commit()
      self.logger.info("Finished executing jobs on the database")
    self.logger.info("PersisterThread stopped")
コード例 #19
0
    def __init__(self):
        self._api = VKApi(VK_USER, VK_PASSWORD, version=API_VERSION)
        self._user = self.get_user()
        self._user_id = self._user['id']

        self._db = DBManager()

        self._commands = {
            'cancel': self.cancel,
            'publish': self.publish,
            'delayed_publish': self.delayed_publish
        }

        print "[INFO] Logged in as %s %s (UID: %s)" % (
            self._user['first_name'], self._user['last_name'], self._user_id)
コード例 #20
0
ファイル: whois.py プロジェクト: zeitkunst/MAICgregator
    def __init__(self, dbManager = None):
        # Call methods for creating environments and DB object

        # Setup our DBManager object
        if (dbManager is None):
            self.dbManager = DBManager()
        else:
            self.dbManager = dbManager

        # Try and get our current whois store
        self.whois = self.dbManager.get("whois")

        if (self.whois is None):
            self.dbManager.put("whois", {})
            self.whois = {}
コード例 #21
0
 def save_changes(self):
     db = DBManager(self.filename)
     table = self.combo.get()
     db.query("DELETE FROM {}".format(table))
     cols = str(self.tree['columns'])[1:-1]
     columns = "(" + cols + ")"
     values = ''
     for i in self.tree.get_children():
         vals = str(self.tree.item(i)['values'])[1:-1]
         values += "(" + vals + "), "
     query = "INSERT INTO {} {} VALUES {}".format(table, columns,
                                                  values[:-2])
     db.query(query)
コード例 #22
0
ファイル: main.py プロジェクト: jalspons/xxl_campaign_sniffer
def update():
    # Start logging
    init_logging()
    # Create dbmanager and httpclient
    db_client = DBManager(db_file, db_logger_name)
    http_client = HttpClient(host, url_paths, http_logger_name)
    
    # Create db if not existing
    if db_client.is_empty():
        db_client.create_db()

    #print(db_client.fetch_products_from_db())
    
    for product_group, url_path in url_paths.items():
        html_file = http_client.fetch_html_file(host, url_path)
        json_file = http_client.parse_html_file(html_file)
        
        db_client.add_products(product_group, json_file)
コード例 #23
0
    def load(self, tablename):
        self.name = tablename
        print(tablename)
        db_mgr = DBManager()

        if db_mgr.fuzion_tables.count_options(tablename) > 0:
            pass
        else:
            t = utilities.get_aws_table(tablename)
            utilities.save_table_to_db(t)
        t = db_mgr.fuzion_tables.get_table(tablename)
        for row in t:
            option = TraitsTableOption()
            option.fr = int(row.fr)
            option.to = int(row.to)

            option.re = str(row.re)

            option.identifier = str(row.identifier)
            leads_to = ""
            if row.leads_to_table is not None:
                leads_to = row.leads_to_table
            option.leads_to = leads_to
            self.options.append(option)
コード例 #24
0
ファイル: spill.py プロジェクト: aniket-bhange/spillwater
 def getAll(self):
     db = DBManager()
     db.connect()
     units = db.find_all()
     return units
コード例 #25
0
ファイル: init.py プロジェクト: t-8ch/alot
    try:
        if not alotconfig:
            alotconfig = configfiles[0]
            settings.write_default_config(alotconfig)

        settings.read_config(alotconfig)
        settings.read_notmuch_config(notmuchconfig)
    except (ConfigError, OSError, IOError), e:
        sys.exit(e)

    # store options given by config swiches to the settingsManager:
    if args['colour-mode']:
        settings.set('colourmode', args['colour-mode'])

    # get ourselves a database manager
    dbman = DBManager(path=args['mailindex-path'], ro=args['read-only'])

    # determine what to do
    try:
        if args.subCommand == 'search':
            query = ' '.join(args.subOptions.args)
            cmdstring = 'search %s %s' % (args.subOptions.as_argparse_opts(),
                                          query)
            cmd = commands.commandfactory(cmdstring, 'global')
        elif args.subCommand == 'compose':
            cmdstring = 'compose %s' % args.subOptions.as_argparse_opts()
            cmd = commands.commandfactory(cmdstring, 'global')
        else:
            default_commandline = settings.get('initial_command')
            cmd = commands.commandfactory(default_commandline, 'global')
    except CommandParseError, e:
コード例 #26
0
 def cmb_update(self, _event):
     db = DBManager(self.filename)
     cols = db.get_columns_names(self.combo.get())
     curs = db.get_rows(self.combo.get())
     self.tree_update(curs, cols)
コード例 #27
0
class Wrapper:

    os   = None
    db   = None

    def __init__(self):
        self.os    = OpenstackBridge()
        self.db    = DBManager()

    def __generate_user_data(self, name, email, enabled, expire):

        user = User()

        user.name = name
        user.email = email
        user.enabled = enabled

        if (is_int(expire)):
            expire = str(expire) + "d"

        user.expiration = (timestring.Range("next " + expire)).end

        project_name = (user.name).title() + "'s project"
        password     = __generate_password()

        user.project_name = project_name
        user.password = password

        return user

    def __generate_password(self):
        wordfile = xp.locate_wordfile()
        mywords  = xp.generate_wordlist(wordfile=wordfile,
                                        min_length=4,
                                        max_length=5)
        new_pass = xp.generate_xkcdpassword(mywords,
                                            delimiter=".",
                                            numwords=4)
        return new_pass

    #  __get_user_data
    #  Receives an ID, which can be a name, email or INT, and
    #  returns the data associated.
    def __get_user_data(self, obj):
        db = self.db
        data = None

        if (is_int(obj)):
            data = db.select_by('id', obj)
        elif obj.find('@') >= 0:
            data = db.select_by('email', obj)
        else:
            data = db.select_by('name', obj)

        if data is None:
            sys.exit(0)

        return data


    def __db_add_user(self, user):
        db = self.db
        db.insert(user)

    def __create_user(self, user):
        print
        warnings.filterwarnings("ignore")

        INFO(3)
        self.os.register_user(user)
        INFO(4)
        self.os.create_network(user)
        user.history.register()
        self.__db_add_user(user)

        if (user.enabled is False):
            self.os.update_user({'user_id':user.user_id,
                                 'project_id': user.project_id,
                                 'enabled':False })

        NOTIFY(5)


    def __update_user(self, id, dict):

        db = self.db
        u  = self.__get_user_data(id)

        user = User()

        user.load(u)

        dict['project_id'] = user.project_id
        dict['user_id']    = user.user_id

        if 'name' in dict:
            user.name = dict['name']

        if 'email' in dict:
            user.email = dict['email']

        if 'enabled' in dict:
            if (isinstance(dict['enabled'], unicode)):
                try:
                    v = ast.literal_eval(dict['enabled'].title())
                    setattr(user, 'enabled', v)
                    dict['enabled'] = v
                except:
                    sys.exit(0)
            else:
                user.enabled = dict['enabled']
            user.history.register()

        if 'expiration' in dict:
            if user.enabled:
                exp = timestring.Date(dict['expiration'])
                user.expiration = exp
            else:
                MSG("user "+ user.name + " is not enabled")
                return

        # self.os.update_user(dict)
        self.db.update(user)


    def __confirmation(self):

        yes  = set(['yes', 'y', 'ye'])
        no   = set(['no', 'n'])

        add = ''
        while (add not in yes) and (add not in no):
            add = GET_INPUT(2)
            if (add not in yes) and (add not in no):
                ERROR(1)
                sys.exit()
            if add in yes:
                break
            else:
                ERROR(2)
                sys.exit()

    def __line_highlight(self, line, color):
        line[0] = color(line[0])
        line[-1] = color(line[-1]) + NORMAL()

    def __line_color(self, line, color):
        for i in range(0, len(line)):
            line[i] = FRRED(line[i])

    #  ADD
    #  Generates user information given name and email.
    #  Gets confirmation if needed and adds user to the
    #  database.
    def add(self, name, email, enabled, expire, yes):

        user = self.__generate_user_data(name, email, enabled, expire)

        show_full_info(user)
        if not yes:
            self.__confirmation()
        self.__create_user(user)

    #  SHOW
    #  Displays user information retrieved from the database.
    #  Receives an id, which can be a name, an email or an INT.
    def show(self, id):

        u  = User()
        load = self.__get_user_data(id)
        u.load(load)
        p = self.os.get_project(u)
        show_project(u, p)
        show_project(u)

    #  DELETE
    #  Deletes one or multiple users from the database.
    #  Receives an id, which can be a name, an email or an INT.
    #  TODO: Delete Openstack credentials.
    def delete(self, list):

        for id in list:
            u = self.__get_user_data(id)
            # self.db.delete(u)

    #  MODIFY
    #  Modifies users information, both from database and Openstack.
    #  Receives an id, which can be a name, an email or an INT, and
    #  a dictionary with fields to modify.
    def modify(self, id, dict):
        self.__update_user(id, dict)


    #  MIGRATE
    #  Takes users who are in Openstacks database and copies them
    #  over Alice database. Ignores duplicates, services and admin.
    def migrate(self):
        db = self.db

        all_users = self.os.get_user()

        services = ['ceilometer', 'nova', 'neutron', 'glance', 'keystone', 'admin']

        for user in all_users:
            if user.name not in services:
                try:
                    found = db.select_by('email', user.email)

                    if found is None:
                        u = User()

                        u.user_id = user.id
                        u.project_id = user.default_project_id
                        u.email = user.email
                        u.enabled = user.enabled
                        u.name = user.name
                        u.expiration = (timestring.Range("next 30d")).end
                        u.history.register()

                        db.insert(u)
                except:
                    continue

    #  LIST
    #  Retrieves users given a filter from the database and displays
    #  in a table manner.
    def list(self, highlight, filter):

        db     = self.db
        fetch  = None

        # List filter select
        if filter is not None and filter != "disabled":
            fetch = db.find_enabled(True)
        elif (filter == "disabled"):
            fetch = db.find_enabled(False)
        else:
            fetch = db.select_all()

        t = PrettyTable(['ID', 'Name', 'Email', 'Status', 'Expires in'])

        t.borders = False
        t.vrules  = 2

        for row in fetch:

            u = User()
            u.load(row)

            if u.expiration is None and u.enabled is True:
                exp = u.history.last_seen() + "30d"
                self.db.add_expiration(u.id, exp)
                u.expiration = exp

            if u.enabled is True:

                elapsed = (u.history.time_left()).elapse

                # String too long
                try:
                    elapsed = elapsed[:elapsed.index("hour") + 5]
                except:
                    elapsed = elapsed[:elapsed.index("min") + 7]

                # On hold, expired or active
                state = DateParser(u.history.time_left()).state

                v = [u.id, u.name, u.email, state.title(), elapsed]

                # Enables highlight
                if highlight is True:
                    if state == 'expired': self.__line_highlight(v, BGRED)
                    if state == 'hold':    self.__line_highlight(v, BGYELLOW)
                else:
                    if state == 'expired': self.__line_color(v, FRRED)
                    if state == 'hold':    self.__line_color(v, FRYELLOW)

                if str(filter) == state or filter is None or filter == "enabled":
                   t.add_row(v)

            else:
                state = 'Disabled'
                t.add_row([FRDIM(u.id),
                          FRDIM(u.name),
                          FRDIM(u.email),
                          FRDIM(state),
                          FRDIM("---")])


        print t
コード例 #28
0
 def __init__(self):
     self.os    = OpenstackBridge()
     self.db    = DBManager()
コード例 #29
0
def main():
    if len(sys.argv) > 1:

        db = DBManager()

        command = sys.argv[1]

        if command == "do-everything":

            if len(sys.argv) > 2:
                path = sys.argv[2]
            else:
                path = input("Please enter the path to the directory to load: ")

            db.destroy()
            db = DBManager()

            validate = input("Do you want to validate the CSV files? This takes longer and has probably already been done. (Y/N): ")

            if validate.lower() == 'y' or validate.lower() == "yes":
                validateFolderCSV(path)

            loadFolder(db, path)
            loadGoldenSet(db)

            print("\nDatabase populated!\n")
            print("Generating search crossover report. Will be known as 'crossover-report.csv'")
            report = reports.generateReportCrossover(db)
            report = parse.reportToCSV(report)
            with open("crossover-report.csv", "w") as out:
                out.write(report)

            print("Generating search count by year report. Will be known as 'year-report.csv'")
            report = reports.generateReportByYear(db)
            report = parse.reportToCSV(report)
            with open("year-report.csv", "w") as out:
                out.write(report)

            print("Generating author count by search report. Will be known as 'author-report.csv'")
            report = reports.generateAuthorReport(db)
            report = parse.reportToCSV(report)
            with open("author-report.csv", "w") as out:
                out.write(report)
        elif command == "report-crossover":
            report = reports.generateReportCrossover(db)
            report = parse.reportToCSV(report)
            print(report)
        elif command == "report-by-year":
            report = reports.generateReportByYear(db)
            report = parse.reportToCSV(report)
            print(report)
        elif command == "report-by-authors":
            report = reports.generateAuthorReport(db)
            report = parse.reportToCSV(report)
            print(report)
        elif command == "compile-folder":
            if len(sys.argv) > 2:
                path = sys.argv[2]
            else:
                path = input("Please enter the path to the folder to compile: ")

            while not isdir(path):
                path = input("Error: The input path must be a directory.\nPlease enter another path: ")

            if len(sys.argv) > 3:
                outputFile = sys.argv[3]
            else:
                outputFile = input("Please enter the name of the output file: ")

            filePaths = []
            filePaths = getFilePaths(path)

            if len(filePaths) > 0:
                contents = parse.compileFolder(filePaths)
                outFile = open(outputFile, 'w')
                outFile.write(contents)
                outFile.close()
            else:
                print("The directory you entered was empty. So nothing happened.")
        elif command == "validateCSV":
            # For a given directory path,
            # traverses through each file and ensures
            # that they each follow valid CSV format
            path = sys.argv[2]
            validateFolderCSV(path)
        elif command == "load":
            # Loads an entire folder of CSV files and the golden set
            # into the database

            path = sys.argv[2]
            loadFolder(db, path)
            loadGoldenSet(db)
        elif command == "shell":
            # Run the shell
            shell.run(db)
        else:
            print("Unsupported command. Please see README for supported operations.")
        db.shutdown()
    else:
        print("No commands entered. Please see README for supported operations.")
コード例 #30
0
def set_max_quality(update, context):
    db = DBManager()
    db.set_chat_settings(update.message.chat_id, 'max')
    update.message.reply_text("Max quality is set")
コード例 #31
0
def start(update, context):
    db = DBManager()
    db.create_new_user(update.message.chat_id)
    """Send a message when the command /start is issued."""
    update.message.reply_text(
        'Hi! This is yputube downloader bot. Enter a link to download video.')
コード例 #32
0
        presense = self.stats.presense
        strength = self.stats.strength
        constitution = self.stats.constitution
        willpower = self.stats.willpower
        body = self.stats.body
        move = self.stats.move
        packed_stats = {'int':intelligence, 'ref':reflexes, 'tech':technique, 'dex':dexterity, 'pre':presense,
                        'str':strength, 'con':constitution, 'will':willpower, 'body':body, 'move':move}
        models.upload_to_aws(name=name, role=role, packed_stats=packed_stats)
        db_mgr = DBManager()
        db_mgr.table_primary_stats.save_character(character_name=name, role=role, intelligence=intelligence,
                                                  reflexes=reflexes, technique=technique, dexterity=dexterity,
                                                  presense=presense, strength=strength, constitution=constitution,
                                                  willpower=willpower, body=body, move=move)'''


    view = View(
        Item('character_name', style='custom', show_label=False),

        Item('stats', style='custom'),
        Item('save', show_label=False),
        Item('load', show_label=False)

        # Item('upload', show_label=False)
    )

if __name__ == '__main__':
    s = StandaloneContainer()
    db_mgr = DBManager()

    s.configure_traits()
コード例 #33
0
ファイル: models.py プロジェクト: hosackm/daboiz
class User():
    '''Used to represent one User in the app.

    There is a class wide STANDINGS attritbute which
    holds the records for each team.  This is used to
    sort teams based on their records and retain the same
    order across all instances of User
    '''
    STANDINGS = None

    def __init__(self, **kwargs):
        if self.STANDINGS is None:
            raise Exception('You must set the standings dictionary first')
        self.name = kwargs.get('name')
        #self.teams = kwargs.get('teams')
        self.wins = 0
        self.losses = 0
        self.ties = 0
        self.db = DBManager()
        self.teams = self.sort_by_rec(kwargs.get('teams'))
        self.fill_in_record()

    def __repr__(self):
        return 'User({})'.format(self.name)

    @classmethod
    def set_standings(cls, standings):
        cls.STANDINGS = standings

    def set_name(self, name):
        self.name = name

    def set_teams(self, teams):
        self.teams = teams

    def fill_in_record(self):
        for team in self.teams:
            win, loss, tie = self.STANDINGS.get(team[0])
            self.wins += win
            self.losses += loss
            self.ties += tie
        self.wins = int(self.wins)
        self.losses = int(self.losses)
        self.ties = int(self.ties)

    def get_win_percentage(self):
        try:
            return self.wins / sum((self.wins, self.losses, self.ties))
        except ZeroDivisionError:
            return 0.0

    def get_record_totals(self):
        '''Zip win, loss, and tie together and sum
        to get a quick total of all teams scores'''
        win, loss, tie = (0 for i in xrange(3))
        for team in self.teams:
            #zip win, loss, tie together and sum
            #them to get a quick total
            win, loss, tie = (sum(i) for i in zip(
                (win, loss, tie),
                self.db.get_record(team)))
        return win, loss, tie

    def sort_by_rec(self, teams):
        def _cmp(team):
            w, l, t = self.STANDINGS.get(team)
            try:
                return w / sum((w, l, t))
            except ZeroDivisionError:
                return 0.0
        teams = sorted(teams, key=_cmp, reverse=True)
        return zip(teams, [self.STANDINGS.get(t) for t in teams])
コード例 #34
0
ファイル: spill.py プロジェクト: aniket-bhange/spillwater
 def saveValue(self, data):
     db = DBManager()
     db.connect()
     data['waterunit'] = str(self.unit)
     data['totalunit'] = str(self.totalUnit)
     return db.save(data)
コード例 #35
0
ファイル: protobuf_server.py プロジェクト: tslilyai/cs262chat
class ProtobufServer(obj.BetaChatAppServicer):
    ''' 
    ProtobufServer wraps the autogenerated protobuf code for server-side functions.

    This server implements the handling of the rpc functions specified in service.proto.
    Each function is passed a request argument, which is a protobuf message object 
    (e.g. a CMessage or User) defined in service.proto.

    The server communicates with the database and returns a protobuf message object 
    or list of these objects (e.g. Response, Group, User) so that the protobuf client
    wrapper can understand the server's response.
    '''
    def __init__(self):
        '''
        Initializes the protobuf server by setting up a database
        manager object for the server to communicate with.
        
        :return: ProtobufServer object
        '''
        self.db = DBManager()

    @add_logging
    def rpc_send_message(self, request, context):
        '''
        Sends the specified message in the message object to the specified user
        in the message object by inserting this message into the user table in the
        database.

        :param request: CMessage protobuf object.
        :return: protobuf Response object 
        '''
        try:
            to_id = request.to_id
            from_id = self.db.get_user_id(request.from_name)
            msg = request.msg
            self.db.insert_message(to_id, from_id, msg)
        except Exception as e:
            return obj.Response(errno=1, msg=e)
        return obj.Response(errno=0, msg="success!\n")
    
    @add_logging
    @list_to_protobuf(obj.CMessage)
    def rpc_get_messages(self, request, context):
        '''
        Retrieves all the messages stored in the messages database table under this
        user's name.

        :param request: User protobuf object.
        :return: protobuf Message object stream on success, or empty list on error
        '''
        try:
            msgs = self.db.get_messages(request.u_id, request.checkpoint)
        except Exception as e:
            return []
        return msgs

    @add_logging
    def rpc_create_conversation(self, request, context):
        '''
        Creates a new conversation between two users by inserting
        a new "virtual group" into the database, and returns
        the group object corresponding to the new conversation.

        :param request: UserPair protobuf object.
        :return: Group protobuf object on success or error string
        '''
        try:
            u1 = self.db.get_user_id(request.username1)
            u2 = self.db.get_user_id(request.username2)
            gid = self.db.get_or_create_vgid(u1, u2)
            return obj.Group(g_id=gid)
        except Exception as e:
            return obj.Response(errno=1, msg=str(e))

    @add_logging
    def rpc_create_group(self, request, context):
        '''
        Creates a new group with 0 members by creating a new
        group into the database. The group must have a unique
        identifier, or else an error is returned

        :param request: Group protobuf object.
        :return: Group protobuf object on success, empty Group (with no name) on error
        '''
        g_name = request.g_name
        try:
            self.db.create_group(g_name)
            g_id = self.db.get_group_id(g_name)
        except Exception as e:
            return obj.Group(g_id=0, g_name="") 
        return obj.Group(g_id=g_id, g_name=g_name)

    @add_logging
    def rpc_create_account(self, request, context):
        '''
        Creates a new user account. The user must have a unique
        identifier, or else an error is returned.

        :param request: User protobuf object.
        :return: User protobuf object on success, empty User (with no name) on error
        '''
        username = request.username
        try:
            self.db.create_account(username)
            u_id = self.db.get_user_id(username)
        except Exception as e:
            return obj.User(u_id=0, username="") 
        return obj.User(u_id=u_id, username=username) 

    @add_logging
    def rpc_remove_account(self, request, context):
        '''
        Removes the account corresponding to the specified user.

        :param request: User protobuf object.
        :return: protobuf Response object indicating success or error
        '''
        try:
            self.db.remove_account(request.username)
        except Exception as e:
            return obj.Response(errno=1, msg=e)
        return obj.Response(errno=0, msg="success!\n")

    @add_logging
    def rpc_edit_group_name(self, request, context):
        '''
        Modify the group name of the specified group. 

        :param request: Group protobuf object.
        :return: protobuf Response object indicating success or error
        '''
        try:
            self.db.edit_group_name(request.g_name, request.new_name)
        except Exception as e:
            return obj.Response(errno=1, msg=e)
        return obj.Response(errno=0, msg="success!\n")

    @add_logging
    def rpc_remove_group_member(self, request, context):
        '''
        Remove a member from the specified group. 

        :param request: Group protobuf object (with "edit_member_name" field specified)
        :return: protobuf Response object indicating success or error
        '''
        try:
            self.db.remove_group_member(request.g_name, request.edit_member_name)
        except Exception as e:
            return obj.Response(errno=1, msg=e)
        return obj.Response(errno=0, msg="success!\n")

    @add_logging
    def rpc_add_group_member(self, request, context):
        '''
        Add a member from the specified group. 

        :param request: Group protobuf object (with "edit_member_name" field specified)
        :return: protobuf Response object indicating success or error
        '''
        try:
            self.db.add_group_member(request.g_name, request.edit_member_name)
        except Exception as e:
            return obj.Response(errno=1, msg=e)
        return obj.Response(errno=0, msg="success!\n")

    @add_logging
    @list_to_protobuf(obj.User)
    def rpc_list_group_members(self, request, context):
        '''
        List members in the specified group. 

        :param request: Group protobuf object (with "edit_member_name" field specified)
        :return: stream of protobuf User objects (NULL User returned if error)
        '''
        try:
            users = self.db.get_group_members(request.g_name)
        except Exception as e:
            return [{'username': '******'}]
        return users

    @add_logging
    @list_to_protobuf(obj.Group)
    def rpc_list_groups(self, request, context):
        '''
        List groups matching the specified pattern 

        :param request: Pattern protobuf object 
        :return: stream of protobuf Group objects (NULL Group returned if error)
        '''
        try:
            groups = self.db.get_groups(request.pattern)
        except Exception as e:
            return [{'g_id' : 0, 'g_name': 'NULL'}]
        return groups
        
    @add_logging
    @list_to_protobuf(obj.User)
    def rpc_list_accounts(self, request, context):
        '''
        List users matching the specified pattern 

        :param request: Pattern protobuf object 
        :return: stream of protobuf User objects (NULL User returned if error)
        '''
        try:
            users = self.db.get_accounts(request.pattern)
        except Exception as e:
            return [{'username': '******'}]
        return users
コード例 #36
0
 def __init__(self):
     self.bot = TeleBot(self.token)
     logger.setLevel(logging.INFO)  # Outputs debug messages to console.
     self.db = DBManager()
     self.handler = Handler(self.bot)
コード例 #37
0
ファイル: update_library.py プロジェクト: hchen13/hashnet
            ssh_private_key = '/home/ethan/.ssh/mac_id_rsa'
        else:
            ssh_private_key = '/Users/ethan/.ssh/id_rsa'
        server = SSHTunnelForwarder(
            ("121.41.12.158", 22),
            ssh_username='******',
            ssh_pkey=ssh_private_key,
            remote_bind_address=(
                db_params['host'],
                3306
            )
        )
        server.start()
        db_params['host'] = server.local_bind_host
        db_params['port'] = server.local_bind_port
    db = DBManager(**db_params)
    storage = Storage(**oss_params)
    hashnet = Hashnet()
    hashnet.load()

    print("Scanning database for images not being processed...")
    session = db.Session()
    results = session.query(Image).filter(
        or_(
            Image.features == None,
            Image.hash == None
        )
    ).all()
    n = len(results)
    print("Scanning complete! {} in total.\n".format(n))
コード例 #38
0
    def __init__(self, master):
        # Main window
        self.master = master
        self.master.title('Simple DB viewer')
        self.master.minsize(width=640, height=480)

        menubar = Menu(self.master)

        menu = Menu(self.master, tearoff=0)
        menu.add_command(label='Создать базу данных')
        menu.add_command(label='Открыть базу данных')
        menu.add_separator()
        menu.add_command(label='Выход')
        menubar.add_cascade(label='Файл', menu=menu)

        menu = Menu(self.master, tearoff=0)
        menu.add_command(label='Записать изменения')
        menu.add_command(label='Удалить изменения')
        menubar.add_cascade(label='База данных', menu=menu)

        self.master.config(menu=menubar)


        tree_frame = ttk.Frame(self.master)
        btns_frame = ttk.Frame(self.master)

        # Connect to DB
        self.db = DBManager('db-name')

        # Combobox with select of table
        self.combo = ttk.Combobox(btns_frame)
        self.combo['values'] = ()
        for row in self.db.get_tables_names():
            self.combo['values'] += row
        self.combo.current(0)
        self.combo.bind('<<ComboboxSelected>>', self._combo_update)

        self.tree = ttk.Treeview(tree_frame, selectmode='extended')
        tree_x_scroll = ttk.Scrollbar(tree_frame, orient='hor', command=self.tree.xview)
        tree_y_scroll = ttk.Scrollbar(tree_frame, orient='vert', command=self.tree.yview)
        self.tree.configure(yscrollcommand=tree_y_scroll.set)
        self.tree.configure(xscrollcommand=tree_x_scroll.set)

        tree_y_scroll.pack(side='right', fill='y')
        self.tree.pack(side='top', fill='both', expand=True)
        tree_x_scroll.pack(side='bottom', fill='x')

        self._combo_update()

        # Buttons
        add = ttk.Button(btns_frame, text='Добавить запись')
        rm = ttk.Button(btns_frame, text='Удалить запись')
        run_sql = ttk.Button(btns_frame, text='Выполнить SQL')

        # Packs all elements
        tree_frame.pack(side='top', fill='both', expand=True)
        btns_frame.pack(side='bottom', fill='both')
        self.combo.pack(side='left', padx=5, pady=5)
        add.pack(side='left', padx=5, pady=5)
        rm.pack(side='left', padx=5, pady=5)
        run_sql.pack(side='left', padx=5, pady=5)
コード例 #39
0
 def __init__(self):
     self.hashnet = Hashnet()
     self.hashnet.load()
     self.db = DBManager(**db_params)