modified stocks with new library

Author: andrea-mucci

tutorials/stock-wallet/front/README.md

@@ -16,8 +16,8 @@ minos-broker-kafka = "^0.5.0"
 minos-discovery-minos = "^0.5.0"
 typer = "^0.3.2"
 SQLAlchemy = "^1.4.0"
-alpha-vantage = "^2.3.1"
-arrow = "^1.2.2"
+pendulum = "^2.1.2"
+polygon-api-client = "^0.2.11"
 
 [tool.poetry.dev-dependencies]
 black = "^19.10b"

tutorials/stock-wallet/front/Stock Wallet.json

@@ -1,10 +1,6 @@
 import logging
 
-import arrow
-from alpha_vantage.async_support.timeseries import (
-    TimeSeries,
-)
-
+import pendulum
 from minos.aggregate import (
     Event,
 )
@@ -19,6 +15,7 @@
 from ..aggregates import (
     StocksAggregate,
 )
+from polygon import RESTClient
 
 logger = logging.getLogger(__name__)
 
@@ -32,40 +29,30 @@ async def set_stock_ticker(self, request: Request):
         for ticker in event["tickers"]:
             await StocksAggregate.add_ticker_to_stock(ticker["ticker"])
 
-    async def call_remote(self, ticker):
-        timeserie = TimeSeries(key="LPY6CZEYR6OIMRYA")
-        data, metadata = await timeserie.get_intraday(ticker)
-        return data, metadata
-
-    async def add_quote(self, ticker: str, when: str, quote: dict):
-        await StocksAggregate.add_quotes(
-            ticker,
-            {"close": quote["4. close"], "volume": quote["5. volume"], "when": when},
-        )
+    def call_remote(self, ticker, from_: str, to_: str):
+        with RESTClient("") as client:
+            resp = client.stocks_equities_aggregates(ticker, 1, "hour", from_, to_, adjusted=True, sort="asc",
+                                                     limit=50000)
+        return resp.results
 
     @enroute.periodic.event("* * * * *")
     async def get_stock_values(self, request: Request):
         tickers = await StocksAggregate.get_all_tickers()
+        now = pendulum.now()
+        now_minus_one_month = now.subtract(months=1)
         if len(tickers) > 0:
             for ticker in tickers:
-                updated = ticker["updated"]
-                data, metadata = await self.call_remote(ticker["ticker"])
-                last_data_refresh = metadata["3. Last Refreshed"]
-                if updated == "Never":
-                    data, metadata = await self.call_remote(ticker["ticker"])
-                    await StocksAggregate.update_time_ticker(ticker["uuid"], last_data_refresh)
-                    for when, stock_quote in data.items():
-                        await self.add_quote(ticker["uuid"], when, stock_quote)
-                else:
-                    time_now_object = arrow.get(updated, "YYYY-MM-DD HH:mm:ss")
-                    time_last_update = arrow.get(last_data_refresh, "YYYY-MM-DD HH:mm:ss")
-                    diff = time_last_update - time_now_object
-                    diff_in_seconds = diff.total_seconds()
-                    if diff_in_seconds > 60:
-                        await StocksAggregate.update_time_ticker(ticker["uuid"], last_data_refresh)
-                        for when, stock_quote in data.items():
-                            time_stock_loop = arrow.get(when, "YYYY-MM-DD HH:mm:ss")
-                            diff_loop = last_data_refresh - time_stock_loop
-                            diff_loop_seconds = diff_loop.total_seconds()
-                            if diff_loop_seconds > 60:
-                                await self.add_quote(ticker["uuid"], when, stock_quote)
+                ticker_updated = pendulum.parse(ticker["updated"])
+                results = await self.call_remote(ticker["ticker"],
+                                                 now_minus_one_month.to_date_string(),
+                                                 now.to_date_string())
+                for result in results:
+                    result_date = pendulum.parse(result["t"])
+                    difference_ticker_result = ticker_updated.diff(result_date).in_hours()
+                    if difference_ticker_result < 0:
+                        await StocksAggregate.update_time_ticker(ticker["uuid"], result_date.to_datetime_string())
+                        when = result_date.to_datetime_string()
+                        await StocksAggregate.add_quotes(ticker["uuid"], {"close": result['c'],
+                                                                          "volume": result['v'],
+                                                                          "when": when})
+

tutorials/stock-wallet/microservices/stocks/poetry.lock

@@ -1,6 +1,8 @@
 import sys
 import unittest
 
+import pendulum
+
 from src import (
     Stocks,
     StocksCommandService,
@@ -29,23 +31,13 @@ def test_constructor(self):
         service = StocksCommandService()
         self.assertIsInstance(service, StocksCommandService)
 
-    async def test_create_stocks(self):
+    async def test_get_remote_quotes(self):
         service = StocksCommandService()
+        now = pendulum.now()
+        now_minus_one_month = now.subtract(months=1)
+        response = service.call_remote("AAPL", now_minus_one_month.to_date_string(), now.to_date_string())
+        self.assertIsInstance(response, list)
 
-        request = InMemoryRequest({})
-        response = await service.create_stocks(request)
-
-        self.assertIsInstance(response, Response)
-
-        observed = await response.content()
-        expected = Stocks(
-            created_at=observed.created_at,
-            updated_at=observed.updated_at,
-            uuid=observed.uuid,
-            version=observed.version,
-        )
-
-        self.assertEqual(expected, observed)
 
 
 if __name__ == "__main__":

tutorials/stock-wallet/microservices/stocks/pyproject.toml

@@ -13,7 +13,7 @@
 
 class Ticker(Entity):
     ticker: str
-    is_crypto: bool
+    flag: str
 
 
 class Wallet(RootEntity):
@@ -36,10 +36,10 @@ async def create_wallet(ticker_name: str) -> UUID:
         return root.uuid
 
     @staticmethod
-    async def add_ticker(wallet_uudi: str, ticker_value: str, is_crypto: bool) -> UUID:
+    async def add_ticker(wallet_uudi: str, ticker_value: str, flag: str) -> UUID:
         """Create a new instance."""
         wallet = await Wallet.get(wallet_uudi)
-        ticker = Ticker(ticker=ticker_value, is_crypto=is_crypto)
+        ticker = Ticker(ticker=ticker_value, flag=flag)
         logger.warning("Added following information ticker {}, {}, {}".format(wallet_uudi, ticker_value, is_crypto))
         wallet.tickers.add(ticker)
         await wallet.save()

tutorials/stock-wallet/microservices/stocks/src/commands/services.py

@@ -41,8 +41,8 @@ async def add_ticker(self, request: Request) -> Response:
             content = await request.content()
             wallet_uuid = content["wallet"]
             ticker = content["ticker"]
-            is_crypto = content["is_crypto"]
-            uuid = await WalletAggregate.add_ticker(wallet_uuid, ticker, is_crypto)
-            return Response({"uuid": uuid, "ticker": ticker, "is_crypto": is_crypto})
+            flag = content["flag"]
+            uuid = await WalletAggregate.add_ticker(wallet_uuid, ticker, flag)
+            return Response({"uuid": uuid, "ticker": ticker, "flag": flag})
         except Exception as exc:
             raise ResponseException(f"An error occurred during Wallet creation: {exc}")

tutorials/stock-wallet/microservices/stocks/tests/test_aggregates.py

@@ -31,7 +31,7 @@ class Ticker(Base):
     wallet_id = Column(Integer, ForeignKey("wallet.id"))
     wallet = relationship("Wallet", backref=backref("tickers"))
     ticker = Column(String(10), unique=True)
-    is_crypto = Column(Boolean, default=False, unique=False)
+    flag = Column(String(30))
     latest_value = Column(Float)