Ejemplo n.º 1
0
    def test_database_overwrite (self):

        #
        # Create database
        #
        database = Database (':memory:')

        #
        # Setup some coin entries
        #
        entries = []
        entries.append (Entry (timestamp=Timestamp ('2017-06-18 12:00'), value=230.0))
        entries.append (Entry (timestamp=Timestamp ('2017-06-18 15:00'), value=2200.12))
        entries.append (Entry (timestamp=Timestamp ('2017-06-18 21:00'), value=240.0))

        entries.append (Entry (timestamp=Timestamp ('2017-06-18 15:00'), value=242.0))

        database.add ('Test::ETH', entries)

        entries = database.get ('Test::ETH')
        self.assertEqual (len (entries), 3)

        for entry in entries:
            if entry.timestamp == Timestamp ('2017-06-18 15:00'):
                self.assertEqual (entry.value, 242.0)
Ejemplo n.º 2
0
    def test_gap_detection(self):

        database = Database(':memory:')

        entries = []

        entries.append(Entry(Timestamp('2017-08-12 14:00'), 10.0))
        entries.append(Entry(Timestamp('2017-08-12 15:00'), 12.0))
        entries.append(Entry(Timestamp('2017-08-12 16:00'), 14.0))
        entries.append(Entry(Timestamp('2017-08-12 17:00'), 14.0))

        database.add('Test::TST', entries)

        scr = TestScraper()
        ScraperRegistry.scrapers = {}
        ScraperRegistry.register(scr)

        acquirer = Acquirer()

        scr.refresh = (None, None)
        acquirer.run(database, Timestamp('2017-08-12 12:00'),
                     Timestamp('2017-08-12 16:00'))
        self.assertEqual(scr.refresh[0], Timestamp('2017-08-12 12:00'))
        self.assertEqual(scr.refresh[1], Timestamp('2017-08-12 13:00'))

        scr.refresh = (None, None)
        acquirer.run(database, Timestamp('2017-08-12 12:00'),
                     Timestamp('2017-08-12 17:00'))
        self.assertEqual(scr.refresh[0], Timestamp('2017-08-12 12:00'))
        self.assertEqual(scr.refresh[1], Timestamp('2017-08-12 13:00'))

        scr.refresh = (None, None)
        acquirer.run(database, Timestamp('2017-08-12 14:00'),
                     Timestamp('2017-08-12 19:00'))
        self.assertEqual(scr.refresh[0], Timestamp('2017-08-12 18:00'))
        self.assertEqual(scr.refresh[1], Timestamp('2017-08-12 19:00'))

        scr.refresh = (None, None)
        acquirer.run(database, Timestamp('2017-08-12 14:00'),
                     Timestamp('2017-08-12 17:00'))
        self.assertEqual(scr.refresh[0], None)
        self.assertEqual(scr.refresh[1], None)
Ejemplo n.º 3
0
    def test_database_read_write (self):

        #
        # Create database
        #
        database = Database (':memory:')

        #
        # Add some entries
        #
        eth_entries = []
        eth_entries.append (Entry (timestamp=Timestamp ('2017-04-21 12:00'), value=234.32))
        eth_entries.append (Entry (timestamp=Timestamp ('2017-04-21 14:00'), value=240.00))
        eth_entries.append (Entry (timestamp=Timestamp ('2017-04-21 16:00'), value=272.98))

        database.add ('Test::ETH', eth_entries)

        btc_entries = []
        btc_entries.append (Entry (timestamp=Timestamp ('2017-04-22 13:00'), value=230.00))
        btc_entries.append (Entry (timestamp=Timestamp ('2017-04-22 15:00'), value=242.00))
        btc_entries.append (Entry (timestamp=Timestamp ('2017-04-22 17:00'), value=270.98))
        btc_entries.append (Entry (timestamp=Timestamp ('2017-04-22 19:00'), value=272.78))

        database.add ('Test::BTC', btc_entries)

        entries = database.get_all_channels ()

        self.assertTrue (len (entries) >= 3)
        self.assertTrue ('Test::ETH' in [entry.id for entry in entries])
        self.assertTrue ('Test::Twitter::ETH' in [entry.id for entry in entries])

        entries = database.get ('Test::ETH')
        self.assertEqual (len (entries), 3)

        entries = database.get ('Test::BTC')
        self.assertEqual (len (entries), 4)
Ejemplo n.º 4
0
                        default=False,
                        help='Verbose output')
    parser.add_argument('-i',
                        '--id',
                        type=str,
                        required=True,
                        help='Stock or index id')
    parser.add_argument('file',
                        type=str,
                        default=None,
                        help='CSV file to import')

    args = parser.parse_args()

    database = Database(args.database)

    if args.database == ':memory:':
        database.create()

    data = pd.read_csv(args.file, header=0)

    for i in range(len(data)):
        row = data.ix[i]

        if row['Low'] != 'null' and row['High'] != 'null':
            entry = StockEntry(to_date(row['Date']), args.id.lower(),
                               (float(row['High']) + float(row['Low'])) / 2)
            database.add(entry)

    database.commit()
Ejemplo n.º 5
0
def write_out(converter: RecordsToCsv, db: Database,
              records: List[Record]) -> None:
    converter.add_to_csv(*records)
    db.add(*records)
Ejemplo n.º 6
0
                        type=str,
                        default=':memory:',
                        help='Database file')
    parser.add_argument('-v',
                        '--verbose',
                        action='store_true',
                        default=False,
                        help='Verbose output')
    parser.add_argument('file',
                        type=str,
                        default=None,
                        help='CSV file to import')

    args = parser.parse_args()

    database = Database(args.database)

    if args.database == ':memory:':
        database.create()

    data = pd.read_csv(args.file, header=0)

    for i in range(len(data)):
        row = data.ix[i]
        database.add(
            CoinEntry(
                to_date(row['start']) + time.timezone, 'xrp', 'xrpchart',
                (row['low'] + row['high']) / 2, row['counter_currency']))

    database.commit()