コード例 #1
0
def conn(db, host=None):
    if not os.uname()[1].startswith('tools-webgrid'):
        # Não tentar acessar o bd fora do Labs
        return False
    wikis = {
        u'Wikipédia': 'ptwiki',
        u'Wikilivros': 'ptwikibooks',
        u'Wikiversidade': 'ptwikiversity',
        u'Wikcionário': 'ptwiktionary',
        u'Wikinotícias': 'ptwikinews',
        u'Wikiquote': 'ptwikiquote',
        u'Wikisource': 'ptwikisource',
        u'Wikivoyage': 'ptwikivoyage'
    }
    try:
        if host:
            connection = oursql.connect(
                db=db,
                host=host,
                read_default_file=os.path.expanduser('~/replica.my.cnf'))
        else:
            db = db in wikis and wikis[db] or db
            connection = oursql.connect(
                db=db + '_p',
                host=db + '.labsdb',
                read_default_file=os.path.expanduser('~/replica.my.cnf'))
        return connection.cursor()
    except:
        return False
コード例 #2
0
ファイル: wppb.py プロジェクト: tool-labs/pb
    def __init__(self,
                 user_name=None,
                 password=None,
                 host=None,
                 database='p_wppb',
                 wp_database='dewiki_p'):
        """
        Constructor.

        *wp_database* may be `None`. Otherwise it should be the wiki’s database
        name, e. g. 'dewiki_p'.
        """
        # try to read the replica.pb-db.cnf
        import ConfigParser
        import os.path
        import pb_db_config

        p = pb_db_config.db_conf_file
        if os.path.exists(p):
            parser = ConfigParser.ConfigParser()
            parser.readfp(open(p))
            if parser.has_section('client'):
                if parser.has_option('client', 'user') and user_name is None:
                    user_name = string.strip(parser.get('client', 'user'),
                                             '"\'')
                if (parser.has_option('client', 'password')
                        and password is None):
                    password = string.strip(parser.get('client', 'password'),
                                            '"\'')
                if parser.has_option('client', 'host') and host is None:
                    host = string.strip(parser.get('client', 'host'), '"\'')

        if user_name is None or password is None or host is None:
            raise WPPBException(
                u'You did not specify enough information on' +
                u' the database connection. The ~/replica.pb-db.cnf ' +
                u'file did not contain the required ' + u'information.')

        try:
            # Workaround for the outage of c2.labsdb:  the project database is
            # moved to tools-db.  ireas/2016-02-16
            self.conn = oursql.connect(host='tools-db',
                                       user=user_name,
                                       passwd=password,
                                       db=database)
            self.pb_database_name = database

            self.wp_conn = None
            if wp_database != None:
                self.wp_conn = oursql.connect(host=host,
                                              user=user_name,
                                              passwd=password,
                                              db=wp_database,
                                              charset='utf8',
                                              use_unicode=True)
        except oursql.DatabaseError, e:
            raise WPPBException(u'You specified wrong database connection ' +
                                u'data. Error message: ' + unicode(e))
コード例 #3
0
ファイル: bottools.py プロジェクト: ptwikis/ptwikisBot
def conn(db, host=None):
  """
  Conecta ao banco de dados  
  """
  if host:
    connection = oursql.connect(db=db, host=host, read_default_file=os.path.expanduser('~/replica.my.cnf'), read_timeout=10, charset='utf8', use_unicode=True, autoreconnect=True, autoping=True)
  else:
    connection = oursql.connect(db=db + '_p', host=db + '.labsdb', read_default_file=os.path.expanduser('~/replica.my.cnf'), read_timeout=10, charset='utf8', use_unicode=True, autoreconnect=True, autoping=True)
  return connection.cursor()
コード例 #4
0
ファイル: mysql.py プロジェクト: h4ck3rm1k3/pywikibot-core
def mysql_query(query, params=(), dbname=None, encoding='utf-8', verbose=None):
    """
    Yield rows from a MySQL query.

    An example query that yields all ns0 pages might look like::

        SELECT
         page_namespace,
         page_title,
        FROM page
        WHERE page_namespace = 0;

    @param query: MySQL query to execute
    @type query: str
    @param params: input parametes for the query, if needed
    @type params: tuple
    @param dbname: db name
    @type dbname: str
    @param encoding: encoding used by the database
    @type encoding: str
    @param verbose: if True, print query to be executed;
        if None, config.verbose_output will be used.
    @type verbose: None or bool
    @return: generator which yield tuples
    """
    if verbose is None:
        verbose = config.verbose_output

    if config.db_connect_file is None:
        conn = mysqldb.connect(config.db_hostname,
                               db=config.db_name_format.format(dbname),
                               user=config.db_username,
                               passwd=config.db_password,
                               port=config.db_port)
    else:
        conn = mysqldb.connect(config.db_hostname,
                               db=config.db_name_format.format(dbname),
                               read_default_file=config.db_connect_file,
                               port=config.db_port)

    cursor = conn.cursor()
    if verbose:
        pywikibot.output('Executing query:\n%s' % query)
    query = query.encode(encoding)
    params = tuple(p.encode(encoding) for p in params)

    if params:
        cursor.execute(query, params)
    else:
        cursor.execute(query)

    for row in cursor:
        yield row

    cursor.close()
    conn.close()
コード例 #5
0
	def dbConnect(self):
		"""Basic sql connect which creates a cursor to execute queries """
		#try first host
		try:
			conn = oursql.connect(host = self.dbHost1, user=self.dbUsername, passwd=self.dbPassword,db=self.database, use_unicode=False, charset=None, port=3306)
		#if no first host, try second host
		except:
			conn = oursql.connect(host = self.dbHost2, user=self.dbUsername, passwd=self.dbPassword,db=self.database, use_unicode=False, charset=None, port=3306)		
		curs = conn.cursor(oursql.DictCursor)
		curs = conn.cursor(try_plain_query=False)

		return curs
コード例 #6
0
ファイル: svm_and_arg.py プロジェクト: miya1987/python
def select_data(user_id, campaign_id):
    import oursql

    #get db name
    farm = int((user_id % 100) / 20) + 1
    db_name='hoge_aprop' + str(farm)

    #get table name
    tbl_name = 'campaign_raid_jyanken_' + str(campaign_id)

    #make query
    sql = 'SELECT hand FROM ' +  tbl_name + ' where user_id = ' + str(user_id)

    conn = oursql.connect(host='localhost', user='******', passwd='hoge', db=db_name)
    cur = conn.cursor()
    cur.execute(sql)
    ret = cur.fetchall()

    tmp = []
    for v in ret:
        tmp.append(v[0])

    result = tmp[len(tmp)-13:len(tmp)]

    return result
コード例 #7
0
 def run(self, **kwargs):
     """Entry point for a task event."""
     if not self.db_access_lock.acquire(False):  # Non-blocking
         self.logger.info("A job is already ongoing; aborting")
         return
     action = kwargs.get("action", "all")
     try:
         start = time()
         conn = oursql.connect(**self.conn_data)
         site = self.bot.wiki.get_site()
         if action in ["all", "update_volunteers"]:
             self.update_volunteers(conn, site)
         if action in ["all", "clerk"]:
             log = u"Starting update to [[{0}]]".format(self.title)
             self.logger.info(log)
             cases = self.read_database(conn)
             page = site.get_page(self.title)
             text = page.get()
             self.read_page(conn, cases, text)
             notices = self.clerk(conn, cases)
             if self.shutoff_enabled():
                 return
             if not self.save(page, cases, kwargs, start):
                 return
             self.send_notices(site, notices)
         if action in ["all", "update_chart"]:
             if self.shutoff_enabled():
                 return
             self.update_chart(conn, site)
         if action in ["all", "purge"]:
             self.purge_old_data(conn)
     finally:
         self.db_access_lock.release()
コード例 #8
0
    def run(self, **kwargs):
        """Entry point for a task event.

        Depending on the kwargs passed, we will either synchronize our local
        statistics database with the site (self.sync()) or save it to the wiki
        (self.save()). We will additionally create an SQL connection with our
        local database.
        """
        action = kwargs.get("action")
        if not self.db_access_lock.acquire(False):  # Non-blocking
            if action == "sync":
                self.logger.info("A sync is already ongoing; aborting")
                return
            self.logger.info("Waiting for database access lock")
            self.db_access_lock.acquire()

        try:
            self.site = self.bot.wiki.get_site()
            self.conn = oursql.connect(**self.conn_data)
            try:
                if action == "save":
                    self.save(kwargs)
                elif action == "sync":
                    self.sync(kwargs)
                elif action == "update":
                    self.update(kwargs)
            finally:
                self.conn.close()
        finally:
            self.db_access_lock.release()
コード例 #9
0
def get_connection_beforerjan2011():
    conn = oursql.connect(host="10.0.0.124", # your host, usually localhost
                         user="******", # your username
                          passwd="voxpop", # your password
                          db="voxpop",
                          use_unicode=False)
    return conn
コード例 #10
0
def get_connection_old():
    conn = oursql.connect(host="10.0.0.125", # your host, usually localhost
                         user="******", # your username
                          passwd="voxpop", # your password
                          db="voxpop",
                          use_unicode=False)
    return conn
コード例 #11
0
def main():
    conf = ConfigParser.ConfigParser()
    options, arg = interface()
    conf.read(options.conf)
    conn = oursql.connect(
            user=conf.get('Database','USER'), 
            passwd=conf.get('Database','PASSWORD'), 
            db=conf.get('Database','DATABASE')
            )
    cur = conn.cursor()
    createAccessionTable(cur)
    conn.commit()
    #counter = 0
    for line in open(options.input, 'rU').readlines():
        if '\t' in line:
            line = line.split('\t')
            chromo, start, stop = line[0:3]
            acc = line[3].split('.')[0]
            overlaps = getGeneOverlap(cur, chromo, start, stop)
            if overlaps:
                for gene in overlaps:
                    #pdb.set_trace()
                    cur.execute('''INSERT INTO annotation (gene_id, long_accession, accession) VALUES (?,?, ?)''', (gene[0], line[3], acc))
            else:
                pdb.set_trace()
コード例 #12
0
ファイル: fy_mog.py プロジェクト: ElegantCloud/feiying_worker
 def _setup_db(self):
     self.db = oursql.connect(
         host = self.options.host,
         port = self.options.port,
         user = self.options.user,
         passwd = self.options.pwd,
         db = self.options.db)
コード例 #13
0
ファイル: base.py プロジェクト: dcramer/django-oursql
 def _cursor(self):
     if not self._valid_connection():
         kwargs = {
             'charset': 'utf8',
             'use_unicode': True,
         }
         settings_dict = self.settings_dict
         if settings_dict['USER']:
             kwargs['user'] = settings_dict['USER']
         if settings_dict['NAME']:
             kwargs['db'] = settings_dict['NAME']
         if settings_dict['PASSWORD']:
             kwargs['passwd'] = settings_dict['PASSWORD']
         if settings_dict['HOST'].startswith('/'):
             kwargs['unix_socket'] = settings_dict['HOST']
         elif settings_dict['HOST']:
             kwargs['host'] = settings_dict['HOST']
         if settings_dict['PORT']:
             kwargs['port'] = int(settings_dict['PORT'])
         opts = settings_dict['OPTIONS']
         if 'autoreconnect' in opts:
             kwargs['autoreconnect'] = opts['autoreconnect']
         # We need the number of potentially affected rows after an
         # "UPDATE", not the number of changed rows.
         kwargs['found_rows'] = True
         # TODO: support for 'init_command'
         kwargs.update(settings_dict['OPTIONS'])
         self.connection = Database.connect(**kwargs)
         # XXX: oursql does not have encoders like mysqldb -- unknown if this is still needed
         # self.connection.encoders[SafeUnicode] = self.connection.encoders[unicode]
         # self.connection.encoders[SafeString] = self.connection.encoders[str]
         connection_created.send(sender=self.__class__)
     cursor = CursorWrapper(self.connection.cursor())
     return cursor
コード例 #14
0
ファイル: base.py プロジェクト: jaredmiwilliams/django-oursql
 def _cursor(self):
     if not self._valid_connection():
         kwargs = {
             'charset': 'utf8',
             'use_unicode': True,
         }
         settings_dict = self.settings_dict
         if settings_dict['USER']:
             kwargs['user'] = settings_dict['USER']
         if settings_dict['NAME']:
             kwargs['db'] = settings_dict['NAME']
         if settings_dict['PASSWORD']:
             kwargs['passwd'] = settings_dict['PASSWORD']
         if settings_dict['HOST'].startswith('/'):
             kwargs['unix_socket'] = settings_dict['HOST']
         elif settings_dict['HOST']:
             kwargs['host'] = settings_dict['HOST']
         if settings_dict['PORT']:
             kwargs['port'] = int(settings_dict['PORT'])
         opts = settings_dict['OPTIONS']
         if 'autoreconnect' in opts:
             kwargs['autoreconnect'] = opts['autoreconnect']
         # We need the number of potentially affected rows after an
         # "UPDATE", not the number of changed rows.
         kwargs['found_rows'] = True
         # TODO: support for 'init_command'
         kwargs.update(settings_dict['OPTIONS'])
         self.connection = Database.connect(**kwargs)
         # XXX: oursql does not have encoders like mysqldb -- unknown if this is still needed
         # self.connection.encoders[SafeUnicode] = self.connection.encoders[unicode]
         # self.connection.encoders[SafeString] = self.connection.encoders[str]
         connection_created.send(sender=self.__class__)
     cursor = CursorWrapper(self.connection.cursor())
     return cursor
コード例 #15
0
ファイル: years.py プロジェクト: HazardSJ/wikidata
def main():
    db = oursql.connect(raise_on_warnings=False,
                        read_default_file=os.path.expanduser("~/.my.cnf"),
                        )
    cursor = db.cursor()
    for year in gen():
        do_month(cursor, year)
コード例 #16
0
def main():
    print "Please insert SPARTAN DB credentials:"
    username = raw_input("Username: "******"spartan-db.oslo.osa", username, password, db="spartan")
    cursor = conn.cursor()
    run(cursor, "http://t/core/standards/scripts/opjsunit/", True)
コード例 #17
0
ファイル: grabber_daemon.py プロジェクト: diggit/wthr_station
def db_access(values,date_limit_str):
	try:
		conn = oursql.connect(user='******', passwd='trollface',db='weather', port=3306)#connect to mysql database
		printDBG("DB: connected!")
	except:
		print("DB: ERR- unable to connect to mysql db, check for running daemon, database existence and table existence")
		exit(1)

	curs = conn.cursor()#create cursor
	if not dry:
		curs.execute('INSERT INTO `data` (stamp,P0,T0,H0,L0) VALUES (?, ?, ?, ?, ?)',(start_t.strftime("%Y-%m-%d %H:%M:00"),values["P0"], values["T0"], values["H0"], values["L0"]))#save values into database
		printDBG("DB: data inserted into table")
	else:
		printDBG("DB: dry run! no db write done")

	if GENchart:
		# query="SELECT stamp,T0,P0,H0,L0 FROM data ORDER BY stamp DESC WHERE stamp > \'"+date_limit_str+"\' LIMIT "+str(PLOT_STEPS)+" ;"
		query="SELECT stamp,T0,P0,H0,L0 FROM data WHERE stamp > \'"+date_limit_str+"\' ORDER BY stamp DESC LIMIT "+str(PLOT_STEPS)+" ;"

		printDBG("DB: requesting data\nquery:",query)

		curs.execute(query)#request last 300 lines of T0 (temperature)
		db_data=curs.fetchall() #receive this

		printDBG("DB: data read")
	else:
		printDBG("DB: no data read")
		db_data=[]

	curs.close()#destruct cursor
	conn.close()#disconnect from db
	printDBG("DB: connection closed")
	return db_data
コード例 #18
0
ファイル: __init__.py プロジェクト: tool-labs/ToolsWeb
def connect_to_database(database, host):
    default_file = os.path.expanduser('~/replica.my.cnf')
    if not os.path.isfile(default_file):
        raise Exception('Database access not configured for this account!')
    
    return oursql.connect(host=host, db=database,
                          read_default_file=default_file)
コード例 #19
0
ファイル: dal.py プロジェクト: jdlrobson/ifttt
def ht_db_connect(read_default_file=DB_CONFIG_PATH):
    connection = oursql.connect(db=HT_DB_NAME,
                                host=HT_DB_HOST,
                                read_default_file=read_default_file,
                                charset=None,
                                use_unicode=False)
    return connection
コード例 #20
0
def main():
    conf = ConfigParser.ConfigParser()
    options, arg = interface()
    conf.read(options.conf)
    conn = oursql.connect(
        user=conf.get('Database','USER'), 
        passwd=conf.get('Database','PASSWORD'), 
        db=conf.get('Database','DATABASE')
    )
    cur = conn.cursor()
    cur.execute('''SELECT distance_id, distance_close_target, left_p, right_p 
        from primers where primer = 0''')
    data = cur.fetchall()
    #pdb.set_trace()
    outp = open(options.output, 'w')
    outp.write('''track name=consPrimers description="Primers" itemRgb=1 useScore=0\n''')
    for d in data:
        iden, ct, lp, rp = d
        # get the positions of each locus and find the smallest start pos
        # we need to do this relative to zebra finch and then transform it to
        # chicken
        cur.execute('''SELECT id, target_chromo, target_cons_start, target_cons_end 
            FROM cons WHERE id in (?, ?) ORDER BY target_cons_end''', (iden, ct))
        #pdb.set_trace()
        positions = cur.fetchall()
        start   = sorted([positions[0][2],  positions[1][2]])[0]
        end     = sorted([positions[0][3],  positions[1][3]])[1]
        #pdb.set_trace()
        d_pos = sorted([d[0], d[1]])
        upper_name = '{0}-{1}_upper'.format(d_pos[0], d_pos[1])
        lower_name = '{0}-{1}_lower'.format(d_pos[0], d_pos[1])
        #upper_name = '{0}_upper'.format(positions[0][0])
        #lower_name = '{0}_lower'.format(positions[0][0])
        # determine the actual position of the primer
        #pdb.set_trace()
        rp_start_temp = (start + int(rp.split(',')[0])) - end
        rp_end_temp = rp_start_temp - int(rp.split(',')[1])
        if not options.chicken:
            chromo      = positions[0][1]
            lp_start    = start + int(lp.split(',')[0])
            lp_end      = lp_start + int(lp.split(',')[1])
            rp_end      = end + (rp_start_temp)
            rp_start    = end + (rp_end_temp)
        if options.chicken:
            cur.execute('''SELECT id, query_chromo, query_cons_start, query_cons_end 
                FROM cons WHERE id in (?, ?) ORDER BY query_cons_end''', (iden, ct))
            positions   = cur.fetchall()
            chromo      = positions[0][1]
            start       = sorted([positions[0][2],  positions[1][2]])[0]
            end         = sorted([positions[0][3],  positions[1][3]])[1]
            lp_start    = start + int(lp.split(',')[0]) - 1
            lp_end      = lp_start + int(lp.split(',')[1])
            rp_end      = end + (rp_start_temp)
            rp_start    = end + (rp_end_temp)
        outp.write('{0} {1} {2} {3} 1000 + {1} {2} 255,0,0\n'.format(chromo, 
            lp_start, lp_end, upper_name))
        outp.write('{0} {1} {2} {3} 1000 - {1} {2} 0,0,255\n'.format(chromo, 
            rp_start, rp_end, lower_name))
    outp.close()
    conn.close()
コード例 #21
0
def get_cursor(uri):

    if uri['host'] in get_cursor.conns.keys():
        return get_cursor.conns[uri['host']].cursor(oursql.DictCursor)

    get_cursor.conns[uri['host']] = oursql.connect(**uri)
    return get_cursor.conns[uri['host']].cursor(oursql.DictCursor)
コード例 #22
0
ファイル: pinnacle.py プロジェクト: mrichman/nhs-emailvision
    def get_abandoned_carts(self, minutes):
        """ Get List of Abandoned Carts """
        logging.info("Getting abandoned carts %d minutes old." % minutes)
        conn = oursql.connect(host=self.host, user=self.username,
                              passwd=self.password, db=self.db)
        curs = conn.cursor(oursql.DictCursor)
        sql = (
            "SELECT users.email, users.fname "
            "FROM orders "
            "inner join users on (users.uid = orders.uid) "
            "where orders.status = 'Abandon' "
            "and users.email <> '' "
            "and create_date < (NOW() - INTERVAL " + str(minutes) + " MINUTE) "
            "order by create_date desc")
        logging.debug(sql)
        curs.execute(sql)

        carts = []

        rows = curs.fetchall()
        for row in rows:
            cart = (row['email'], row['fname'])
            logging.debug(cart)
            carts.append(cart)

        logging.info("Found %d abandoned carts." % len(carts))
        return carts
コード例 #23
0
def suspected_diffs(q):
    import oursql
    import dbsettings
    con = oursql.connect(host=dbsettings.reporter_db_host,
                         db='{}__copyright_p'.format(dbsettings.db_username),
                         read_default_file=dbsettings.connect_file,
                         use_unicode=True,
                         charset='utf8')
    cursor = con.cursor()
    columns = [
        'project', 'lang', 'diff', 'diff_timestamp', 'page_title', 'page_ns',
        'ithenticate_id'
    ]

    where_cols = []
    value_cols = []
    for col in columns:
        if col in q:
            where_cols.append(col)
            value_cols.append(q[col][0].decode('utf8'))
    where = ''
    if 'report' in q:
        columns.append('report')
    if len(where_cols):
        where = ' where ' + ' AND '.join([x + '= ?' for x in where_cols])
    cursor.execute(
        'select ' + ', '.join(columns) + ' from copyright_diffs' + where +
        ' order by diff_timestamp desc limit 50', value_cols)
    for data in cursor:
        yield dict((col, str(data[i])) for i, col in enumerate(columns)
                   if col not in where_cols)
コード例 #24
0
def insert():
    print 'Populating the protected_titles table...'
    conn = oursql.connect(host=settings.db_host, user=settings.db_user, passwd=settings.db_pass,
                          db=settings.db_name)
    cur = conn.cursor()
    cur.executemany('INSERT INTO `protected_titles` VALUES (?,?,?,?,?,?,?);', parse(gen()))
    conn.close()
コード例 #25
0
ファイル: dal.py プロジェクト: hatnote/hashtags
def db_connect(db, host, read_default_file=DB_CONFIG_PATH):
    connection = oursql.connect(db=db,
                                host=host,
                                read_default_file=read_default_file,
                                charset=None,
                                use_unicode=False)
    return connection
コード例 #26
0
def extractVectors(config, inputPickle, outputPickle):

    with open(inputPickle, "r") as f:
        song_to_track = pickle.load(f)

    songs = []
    vectors = []

    with oursql.connect(
        host=config.get("mysql", "host"),
        user=config.get("mysql", "username"),
        passwd=config.get("mysql", "password"),
        port=config.getint("mysql", "port"),
        db=config.get("mysql", "database"),
    ) as conn:
        with conn as cursor:

            for (song, track) in song_to_track.iteritems():
                cursor.execute("""SELECT data FROM Track WHERE echonest_id = ? LIMIT 1""", (track,))
                for (data,) in cursor:
                    songs.append(song)
                    vectors.append(pickle.loads(data))

    with open(outputPickle, "w") as f:
        pickle.dump({"songs": songs, "vectors": vectors}, f)

    pass
コード例 #27
0
ファイル: app.py プロジェクト: danmichaelo/catmonitor
def show_api():

    configs = ['config.no.json', 'config.nn.json']
    projects = []

    for configfile in configs:
        config = json.load(open(HOME + configfile, 'r'))
        sql = oursql.connect(host=config['local_db']['host'],
                             db=config['local_db']['db'],
                             charset='utf8',
                             use_unicode=True,
                             read_default_file=os.path.expanduser('~/replica.my.cnf'))
        cur = sql.cursor()
        cur2 = sql.cursor()
        cur.execute(u'SELECT category, COUNT(article) FROM articles GROUP BY category')
        cats = []
        for cat in cur.fetchall():
            cur2.execute(u'SELECT membercount, ts FROM stats WHERE category=? ORDER BY ts DESC LIMIT 20', [cat[0]])
            stats = []
            for s in cur2.fetchall():
                stats.append({'value': s[0], 'timestamp': s[1]})
            cats.append({'name': cat[0], 'membercount': stats})
        p = {
            'host': config['host'],
            'template': config['template'],
            'categories': cats
        }
        projects.append(p)
        cur.close()
        cur2.close()

    return flask.jsonify(projects=projects)
コード例 #28
0
ファイル: dal.py プロジェクト: amitkumarj441/ifttt
def ht_db_connect(read_default_file=DB_CONFIG_PATH):
    connection = oursql.connect(db=HT_DB_NAME,
                                host=HT_DB_HOST,
                                read_default_file=read_default_file,
                                charset=None,
                                use_unicode=False)
    return connection
コード例 #29
0
ファイル: opentask.py プロジェクト: sema0703/suggestbot
	def connectDatabase(self, hostName=None, dbName=None):
		'''
		Connect to the database associated with our Wikipedia,
		or a given server and database if host/database names
		are supplied.

		@param hostName: hostname of the server we're connecting to
		@type hostName: str

		@param dbName: name of the database we will be using
		@type dbName: str
		'''
		if not hostName:
			hostName = u"{lang}wiki.labsdb".format(lang=self.lang)
			dbName = u"{lang}wiki_p".format(lang=self.lang)

		if self.dbConn:
			self.disconnectDatabase()

		try:
			self.dbConn = oursql.connect(db=dbName,
						     host=hostName,
						     read_default_file=os.path.expanduser(self.mysqlConf),
						     use_unicode=False,
						     charset=None)
			self.dbCursor = self.dbConn.cursor()
		except oursql.Error, e:
			logging.error("unable to connect to database {0} on server {1}".format(dbName, hostname))
			logging.error("oursqul error {0}: {1}".format(e.args[0], e.args[1]))
			return False
コード例 #30
0
ファイル: dal.py プロジェクト: intracer/hashtags
def db_connect(db, host, read_default_file=DB_CONFIG_PATH):
    connection = oursql.connect(db=db,
                                host=host,
                                read_default_file=read_default_file,
                                charset=None,
                                use_unicode=False)
    return connection
コード例 #31
0
ファイル: mysql.py プロジェクト: LukeCarrier/hn
    def __init__(self, host=None, username=None, password=None, port=3306):
        for attr in ("host", "username", "password", "port"):
            setattr(self, attr, locals()[attr])

        credentials = {"host": self.host, "user": self.username, "passwd": self.password, "port": self.port}

        self.__conn = oursql.connect(**credentials)
コード例 #32
0
def get_connection():
    conn = oursql.connect(  host="10.0.0.125", 
                            user="******", 
                            passwd="voxpop",
                            db="voxpop",
                            use_unicode = False)
    return conn
コード例 #33
0
ファイル: fun.py プロジェクト: MartinMartimeo/merodii
def get_cursor(uri):

    if uri['host'] in get_cursor.conns.keys():
        return get_cursor.conns[uri['host']].cursor(oursql.DictCursor)

    get_cursor.conns[uri['host']] = oursql.connect(**uri)
    return get_cursor.conns[uri['host']].cursor(oursql.DictCursor)
コード例 #34
0
ファイル: wordpress.py プロジェクト: mrichman/nhs-emailvision
    def get_blog_subscribers(self):
        """ Gets WordPress Blog Subscribers """
        logging.info("Getting blog subscribers.")
        conn = oursql.connect(host=self.host, user=self.username,
                              passwd=self.password, db=self.db)
        curs = conn.cursor(oursql.DictCursor)

        sql = (
            "SELECT users.user_email, users.display_name "
            "FROM admin_wpdb.wp_usermeta meta "
            "INNER JOIN admin_wpdb.wp_users users ON "
            "   (users.ID = meta.user_id) "
            "WHERE meta.meta_key = 'wp_capabilities' "
            "AND meta.meta_value LIKE '%subscriber%' "
            "ORDER BY users.ID")

        logging.debug(sql)

        try:
            curs.execute(sql)
        except Error as error:
            logging.error(error.message)
            raise Exception(error.message)

        users = []

        rows = curs.fetchall()
        for row in rows:
            user = (row['user_email'], row['display_name'])
            logging.debug(user)
            users.append(user)

        logging.info("Found %d total blog subscribers." % len(users))

        return users
コード例 #35
0
    def _sql_connect(self, **kwargs):
        """Attempt to establish a connection with this site's SQL database.

        oursql.connect() will be called with self._sql_data as its kwargs.
        Any kwargs given to this function will be passed to connect() and will
        have precedence over the config file.

        Will raise SQLError() if the module "oursql" is not available. oursql
        may raise its own exceptions (e.g. oursql.InterfaceError) if it cannot
        establish a connection.
        """
        if not oursql:
            e = "Module 'oursql' is required for SQL queries."
            raise exceptions.SQLError(e)

        args = self._sql_data
        for key, value in kwargs.iteritems():
            args[key] = value

        if "read_default_file" not in args and "user" not in args and "passwd" not in args:
            args["read_default_file"] = expanduser("~/.my.cnf")

        if "autoping" not in args:
            args["autoping"] = True

        if "autoreconnect" not in args:
            args["autoreconnect"] = True

        self._sql_conn = oursql.connect(**args)
コード例 #36
0
ファイル: codesearch.py プロジェクト: duganchen/codesearch
def display(sphinx_id):

    db = oursql.connect(user='******', passwd='codesearch',
                        db='codesearch')

    cursor = db.cursor(oursql.DictCursor)
    query = 'SELECT project, path, text FROM documents WHERE id = ?'
    cursor.execute(query, (sphinx_id,))
    sourcecode = cursor.fetchone()
    if sourcecode is None:
        flask.abort(404)

    title = posixpath.join(sourcecode['project'], sourcecode['path'])

    try:
        lexer = get_lexer_for_filename(sourcecode['path'])
    except ClassNotFound:
        # Syntax highlighting not supported.'
        code = u'<pre>{}</pre>'.format(sourcecode['text'])
        return flask.render_template('display.html', title=title, code=code)

    formatter = HtmlFormatter()

    # Highlighting large files can be a slow operation. This is a candidate
    # for caching.
    checksum = zlib.adler32(sourcecode['text'])
    key = json.dumps(['HIGHLIGHT', checksum])
    code = cache.get(key)
    if code is None:
        code = highlight(sourcecode['text'], lexer, formatter)
        cache.set(key, code)

    return flask.render_template('display.html', title=title,
                                 code=code)
コード例 #37
0
    def run(self, **kwargs):
        """Entry point for a task event.

        Depending on the kwargs passed, we will either synchronize our local
        statistics database with the site (self.sync()) or save it to the wiki
        (self.save()). We will additionally create an SQL connection with our
        local database.
        """
        action = kwargs.get("action")
        if not self.db_access_lock.acquire(False):  # Non-blocking
            if action == "sync":
                self.logger.info("A sync is already ongoing; aborting")
                return
            self.logger.info("Waiting for database access lock")
            self.db_access_lock.acquire()

        try:
            self.site = self.bot.wiki.get_site()
            self.conn = oursql.connect(**self.conn_data)
            try:
                if action == "save":
                    self.save(kwargs)
                elif action == "sync":
                    self.sync(kwargs)
                elif action == "update":
                    self.update(kwargs)
            finally:
                self.conn.close()
        finally:
            self.db_access_lock.release()
コード例 #38
0
def insert():
    print 'Populating the page_restrictions table...'
    conn = oursql.connect(host=settings.db_host, user=settings.db_user, passwd=settings.db_pass,
                          db=settings.db_name)
    cur = conn.cursor()
    cur.executemany('INSERT IGNORE INTO `page_restrictions` VALUES (?,?,?,?,?,?,?);', parse(full_gen()))
    conn.close()
コード例 #39
0
ファイル: database.py プロジェクト: nagecai/xmppserver
def connect(host, port, user, passwd, dbname, servercfg):
    log.debug("connecting to database %s on %s@%s" % (dbname, user, host))
    db = oursql.connect(host=host,
                        port=port,
                        user=user,
                        passwd=passwd,
                        db=dbname)
    return MessengerDb(db, servercfg)
コード例 #40
0
ファイル: years.py プロジェクト: XXN/wikidata-1
def main():
    db = oursql.connect(
        raise_on_warnings=False,
        read_default_file=os.path.expanduser("~/.my.cnf"),
    )
    cursor = db.cursor()
    for year in gen():
        do_month(cursor, year)
コード例 #41
0
def count():
    db = oursql.connect(db='u_sigma_webcite_p', host="sql-user-l.toolserver.org", read_default_file="/home/legoktm/.my.cnf")
    cur = db.cursor()
    cur.execute("SELECT table_name, table_rows     FROM INFORMATION_SCHEMA.TABLES     WHERE TABLE_SCHEMA = 'u_sigma_webcite_p' AND TABLE_NAME='new_links';")
    query = cur.fetchall()
    res = query[0][1]
    db.close()
    return res
コード例 #42
0
 def connect(self, read_default_file=DB_CONFIG_PATH):
     with tlog.critical('connect') as rec:
         self.connection = oursql.connect(db=HT_DB_NAME,
                                          host=HT_DB_HOST,
                                          read_default_file=read_default_file,
                                          charset=None,
                                          use_unicode=False,
                                          autoping=True)
コード例 #43
0
 def saveLuxData(self):
     conn = oursql.connect(host=db["host"],
                           port=db["port"],
                           db=db["name"],
                           user=db["user"],
                           passwd=db["pass"])
     self.saveLux2Database(conn)
     self.saveLux2Graph(conn)
コード例 #44
0
ファイル: misc.py プロジェクト: innocentius/copyvios
def get_db():
    if not g._db:
        args = cache.bot.config.wiki["_copyviosSQL"]
        args["read_default_file"] = expanduser("~/.my.cnf")
        args["autoping"] = True
        args["autoreconnect"] = True
        g._db = oursql.connect(**args)
    return g._db
コード例 #45
0
ファイル: dal.py プロジェクト: obaid2526/weeklypedia
 def __init__(self, lang='en'):
     self.lang = lang
     self.db_title = lang + 'wiki_p'
     self.db_host = lang + 'wiki.labsdb'
     self.connection = oursql.connect(db=self.db_title,
                                      host=self.db_host,
                                      read_default_file=DB_CONFIG_PATH,
                                      charset=None)
コード例 #46
0
def ht_db_connect():
    connection = oursql.connect(db=app.config['HT_DB_NAME'],
                                host=app.config['HT_DB_HOST'],
                                user=app.config['DB_USER'],
                                passwd=app.config['DB_PASSWORD'],
                                charset=None,
                                use_unicode=False)
    return connection
コード例 #47
0
def oursql_no_port_connect():
    # 省略port
    no_port_conn = oursql.connect(MYSQL_CONF['host'],
                                  MYSQL_CONF['name'],
                                  MYSQL_CONF['pwd'],
                                  db=MYSQL_CONF['db'])
    sql = common_select_sql()
    res = common_select_conn(no_port_conn, sql)
    return res
コード例 #48
0
def oursql_keyword_connect():
    keyword_conn = oursql.connect(host=MYSQL_CONF['host'],
                                  port=MYSQL_CONF['port'],
                                  user=MYSQL_CONF['name'],
                                  passwd=MYSQL_CONF['pwd'],
                                  db=MYSQL_CONF['db'])
    sql = common_select_sql()
    res = common_select_conn(keyword_conn, sql)
    return res
コード例 #49
0
def oursql_position_connect():
    # 标准位置参数连接
    position_conn = oursql.connect(MYSQL_CONF['host'],
                                   MYSQL_CONF['name'],
                                   MYSQL_CONF['pwd'],
                                   port=MYSQL_CONF['port'],
                                   db=MYSQL_CONF['db'])
    sql = common_select_sql()
    res = common_select_conn(position_conn, sql)
    return res
コード例 #50
0
def main():
    conf = ConfigParser.ConfigParser()
    options, args = interface()
    if options.conf:
        conf.read(options.conf)
    # build our configuration
    if options.db:
        conn = oursql.connect(
        user=conf.get('Database','USER'),
        passwd=conf.get('Database','PASSWORD'),
        db=conf.get('Database','DATABASE')
        )
        cur = conn.cursor()
    #genomes = ['hg19', 'venter', 'chinese', 'korean', 'panTro2']
    #genomes = [
    #'129S1_SvImJ_Mouse_Genome',
    #'129S5_Mouse_Genome',
    #'C57BL_6N_Mouse_Genome',
    #'CAST_Ei_Mouse_Genome',
    #'NOD_Mouse_Genome',
    #'NZO_Mouse_Genome',
    #'PWK_Ph_Mouse_Genome',
    #'Spretus_Ei_Mouse_Genome',
    #'WSB_Ei_Mouse_Genome',
    #'mm9',
    #'rn4'
    #]
    if options.db:
        try:
            cur.execute('''CREATE TABLE species (
            name varchar(7) NOT NULL,
            description varchar(100) NULL,
            version text NULL,
            PRIMARY KEY (name)) ENGINE=InnoDB''')
        except:
            # need better handling here for tables that exist
            pass
    if options.readlist:
        for g in options.readlist:
            #pdb.set_trace()
            output_file = os.path.abspath(os.path.join(options.output,       
                        "all_probes_v_{0}.lastz".format(g)))
            exc_str = '''/Users/bcf/git/brant/seqcap/Alignment/run_lastz.py \
                        --target=/nfs/data1/genomes/Genomes/{3}{0}/{0}.2bit \
                        --query={1}\
                        --nprocs=6 \
                        --output={2} --huge'''.format(g, options.probefile, output_file, options.fish)
            os.system(exc_str)
            if options.db:
                rest_of_steps(cur, g, output_file)
                try:
                    cur.execute('INSERT INTO species (name) VALUES (?)', (g,))
                except oursql.IntegrityError, e:
                    if e == 1062:
                        pass
コード例 #51
0
def main():
    page = wikitools.Page(wiki, base)
    db = oursql.connect(db='wikidatawiki_p',
                        host="sql-s5",
                        read_default_file=os.path.expanduser("~/.my.cnf"),
                        charset=None,
                        use_unicode=False)
    text = 'This report spans multiple subpages. It was last run at <onlyinclude>~~~~~</onlyinclude>.'
    text += run(db, 'P17', 'P30')  #country w/o continent
    text += run(db, 'P21', 'P107')  #sex w/o entity type
    page.edit(text, summary='Bot: Updating database report', bot=1)
コード例 #52
0
def run_query(query, query_params, lang):
    db_title = lang + 'wiki_p'
    db_host = lang + 'wiki.labsdb'
    connection = oursql.connect(db=db_title,
                                host=db_host,
                                user=app.config['DB_USER'],
                                passwd=app.config['DB_PASSWORD'],
                                charset=None)
    cursor = connection.cursor(oursql.DictCursor)
    cursor.execute(query, query_params)
    ret = cursor.fetchall()
    return ret