def _sync(self) -> bool:
     try:
         str_date = DateTime(self.get_last_sync_date(),
                             timezone_hours=0).to_str("%Y%m%d")
         market_data = self._get_market_data(str_date)
         if market_data is not None:
             with DBLock:
                 try:
                     # save to models
                     self.save_market_data(market_data)
                     # update sync date
                     self.set_last_sync_date(
                         DateTime(timezone_hours=0).date.timestamp)
                     self._logger.log(
                         "%s market data sync success. date: %s" %
                         (self.__class__.__name__,
                          DateTime(self.get_last_sync_date(),
                                   timezone_hours=0).to_str("%Y%m%d")))
                     commit()
                 except Exception as e:
                     rollback()
                     raise e
             return True
         else:
             return False
     except Exception as e:
         self._logger.log_err(e)
         return False
예제 #2
0
파일: game.py 프로젝트: JackieChiles/Cinch
    def dbupdate(self):
        """Write a completed gamestate to the sqlite database."""
        log.debug("Trying to add a row for the new game.")

        # Get the automatic game ID to use in the Events table in place of the
        # random engine-generated game ID. The game timestamp is that of the
        # first game event.
        autogen_game_id = db.Games.insert(
            Timestamp=self.gs.events[0]['timestamp'],
            PlayerName0=self.players[0].name,
            PlayerName1=self.players[1].name,
            PlayerName2=self.players[2].name,
            PlayerName3=self.players[3].name
        )
        log.debug("Grabbed a game_id from the database.")

        # Write everything from Events to the database.
        log.info("Writing game data for local game %s, db game %s.",
                  self.gs.game_id, autogen_game_id)

        for action in self.gs.events:
            db.Events.insert(
                game_id=autogen_game_id,
                HandNumber=action['hand_num'],
                Timestamp=action['timestamp'],
                EventString=action['output']
            )

        db.commit()
예제 #3
0
def update(filename):
    '''Change the cube list to reflect the contents of FILENAME.
    FILENAME: a list of cardnames, one per line. No quantity data - multiples
    must be listed separately for each instance. This matches CubeTutor's output
    as of August 2014.
    
    This function:
    1. Iterates through the list and builds a {name: quantity} dictionary.
    2. Iterates through the cards table, setting quantities to 0 on all cards
    not appearing in the dictionary.
    3. Iterates through the dictionary, creating or updating rows as needed.

    This function does not add, update, or change card attributes (color etc.).
    '''

    log.debug("Reading from %s", filename)
    with open(filename, 'r') as f:
        cardData = f.readlines()
    log.info("cardData indicates a %s-card cube.", len(cardData))

    # Step 1

    newCards = {} # empty dictionary to hold name:qty keypairs
    for i in range(len(cardData)):
        cardData[i] = cardData[i].strip()
        if cardData[i] in newCards:    # Duplicate cardname found...
            newCards[cardData[i]] += 1 # so increment the quantity.
        else:
            newCards[cardData[i]] = 1  # Otherwise add a key with qty=1.
    log.warning("newCards indicates a %s-card cube.", sum(newCards.values()))

    # Step 2

    cut_cards = added_cards = 0 # Count number of changed cards for logging.
    for row in db().select(db.Cards.Name, db.Cards.Quantity):
        if row.Name not in newCards and row.Quantity != 0: # Card has been cut
            db(db.Cards.Name == row.Name).update(Quantity = 0)
            cut_cards += row.Quantity
        else:
            added_cards -= row.Quantity
            # This subtracts out the existing records' quantities. The total
            # number of added cards is the sum of this (negative or 0) and the
            # update_or_insert quantity sum in step 3.

    log.warning("Cutting %s cards...", cut_cards)

    # Step 3

    for cardname in newCards:
        db.Cards.update_or_insert(db.Cards.Name == cardname, Name = cardname,
                                  Quantity = newCards[cardname])
        added_cards += newCards[cardname]

    log.warning("Adding %s cards...", added_cards)

    db.commit()

    return
예제 #4
0
 def set(cls, key, value):
     value = JsonUtil.serialize(value)
     with cls._lock:
         if cls._has_key(key):
             sql = 'UPDATE state SET `value` = \'%s\' WHERE `key` = \'%s\';' % (
                 value, key)
         else:
             sql = 'INSERT INTO state (`key`, `value`) VALUES (\'%s\', \'%s\');' % (
                 key, value)
         with DBLock:
             execute(sql)
             commit()
예제 #5
0
def write_updated_ratings(transactions):
    '''Given a cardname:(mu, sigma) dictonary, write each entry to the database as a new transaction. Each entry in a given call to this function should have an identical timestamp.

    inputs

    outputs

    '''
    timestamp = datetime.datetime.utcnow()

    for cardname in transactions:
        db.Transactions.insert(card_id = db.Cards(db.Cards.Name==cardname).id,
                               mu = transactions[cardname][0],
                               sigma = transactions[cardname][1],
                               timestamp = timestamp)

    db.commit()
예제 #6
0
 def _sync(self) -> bool:
     try:
         # str_date = DateTime(self.get_current_sync_date(), timezone_hours=0).to_str("%Y%m%d")
         dt = self.get_current_sync_date()
         date_table, _, _ = self.db_context()
         if self._exists(date_table, dt):
             self.set_last_sync_date(dt)
             self._logger.log_err('duplicate date: %s' % DateTime(dt, timezone_hours=0).to_str('%Y-%m-%d'))
             return True
         nr_data = self._req_queue.get(dt)
         # nr_data = self._get_daily_all_nr(str_date)
         if nr_data is not None:
             with DBLock:
                 try:
                     # save to models
                     self._sort_nr_data(nr_data)
                     self._save_nr_data(nr_data)
                     # update sync date
                     self.set_last_sync_date(dt)
                     self._logger.log(
                         "%s nr_data sync success. date: %s" % (
                             self.__class__.__name__,
                             DateTime(self.get_last_sync_date(), timezone_hours=0).to_str("%Y%m%d")
                         )
                     )
                     commit()
                     self._req_queue.remove(dt)
                 except Exception as e:
                     rollback()
                     raise e
             return True
         else:
             return False
     except Exception as e:
         self._logger.log_err(e)
         return False
예제 #7
0
elif sys.platform.startswith('linux'):
    sys.path.append(os.path.abspath(__file__).split('/resource/load_resource_main.py')[0])

from common.client import client
from load_resource import load_resource
from common.db import commit

if __name__ == '__main__':
    arguments = sys.argv

    client.init_client(arguments[1], arguments[2], arguments[3])
    load_resource.set_access_key(arguments[1])

    print('[*] Resource Load Start')

    load_resource.load_iam_resource()
    load_resource.load_vpc_resource()
    load_resource.load_ec2_resource()
    load_resource.load_rds_resource()
    load_resource.load_ebs_resource()
    load_resource.load_s3_resource()
    load_resource.load_cloudtrail_resource()
    load_resource.load_cloudwtach_resource()
    load_resource.load_cloudfront_resource()
    load_resource.load_kms_resource()
    load_resource.load_lambda_resource()

    commit()
    print('[*] Resource Load Complete')