Feature/logger and redis and api improvements

corva/__init__.py

@@ -0,0 +1,4 @@
+from .application import Corva  # noqa: F401
+from .models.stream import StreamEvent  # noqa: F401
+from .network.api import Api  # noqa: F401
+from .state.redis_state import RedisState as Cache  # noqa: F401

corva/app/base.py

@@ -1,27 +1,23 @@
 from abc import ABC, abstractmethod
 from itertools import groupby
-from logging import Logger, LoggerAdapter
-from typing import List, Optional, Union
+from typing import List, Optional
 
-from corva import settings
 from corva.event import Event
-from corva.logger import DEFAULT_LOGGER
 from corva.models.base import BaseContext
 from corva.network.api import Api
+from corva.settings import CORVA_SETTINGS
 
 
 class BaseApp(ABC):
     def __init__(
          self,
-         app_key: str = settings.APP_KEY,
-         cache_url: str = settings.CACHE_URL,
-         api: Optional[Api] = None,
-         logger: Union[Logger, LoggerAdapter] = DEFAULT_LOGGER
+         app_key: str = CORVA_SETTINGS.APP_KEY,
+         cache_url: str = CORVA_SETTINGS.CACHE_URL,
+         api: Optional[Api] = None
     ):
         self.app_key = app_key
         self.cache_url = cache_url
-        self.api = api or Api()
-        self.logger = logger
+        self.api = api
 
     @property
     @abstractmethod
@@ -42,7 +38,6 @@ def run(self, event: str) -> None:
             event = self.event_loader.load(event=event)
             events = self._group_event(event=event)
         except Exception:
-            self.logger.error('Could not prepare events for run.')
             raise
 
         for event in events:
@@ -52,15 +47,13 @@ def _run(self, event: Event) -> None:
         try:
             context = self.get_context(event=event)
         except Exception:
-            self.logger.error('Could not get context.')
             raise
 
         try:
             self.pre_process(context=context)
             self.process(context=context)
             self.post_process(context=context)
         except Exception as exc:
-            self.logger.error('An error occurred in process pipeline.')
             self.on_fail(context=context, exception=exc)
             raise
 

corva/application.py

@@ -1,2 +1,83 @@
+from typing import Any, Callable, List, Optional
+
+from corva.models.scheduled import ScheduledContext, ScheduledEvent
+from corva.models.stream import StreamContext, StreamEvent
+from corva.network.api import Api
+from corva.runners.scheduled import scheduled_runner
+from corva.runners.stream import stream_runner
+from corva.settings import CorvaSettings, CORVA_SETTINGS
+
+
 class Corva:
-    pass
+    def __init__(
+         self,
+         api_url: Optional[str] = None,
+         data_api_url: Optional[str] = None,
+         cache_url: Optional[str] = None,
+         api_key: Optional[str] = None,
+         app_key: Optional[str] = None,
+         api_timeout: Optional[int] = None,
+         api_max_retries: Optional[int] = None,
+         cache_kwargs: Optional[dict] = None
+    ):
+        self.cache_kwargs = cache_kwargs or {}
+
+        self.settings = CorvaSettings(
+            API_ROOT_URL=api_url or CORVA_SETTINGS.API_ROOT_URL,
+            DATA_API_ROOT_URL=data_api_url or CORVA_SETTINGS.DATA_API_ROOT_URL,
+            API_KEY=api_key or CORVA_SETTINGS.API_KEY,
+            CACHE_URL=cache_url or CORVA_SETTINGS.CACHE_URL,
+            APP_KEY=app_key or CORVA_SETTINGS.APP_KEY
+        )
+
+        self.api = Api(
+            api_url=self.settings.API_ROOT_URL,
+            data_api_url=self.settings.DATA_API_ROOT_URL,
+            api_key=self.settings.API_KEY,
+            app_name=self.settings.APP_NAME,
+            timeout=api_timeout,
+            max_retries=api_max_retries
+        )
+
+    def stream(
+         self,
+         fn: Callable,
+         event: str,
+         *,
+         filter_by_timestamp: bool = False,
+         filter_by_depth: bool = False
+    ) -> List[Any]:
+        events = StreamEvent.from_raw_event(event=event, app_key=self.settings.APP_KEY)
+
+        results = []
+
+        for event in events:
+            ctx = StreamContext(
+                event=event,
+                settings=self.settings,
+                api=self.api,
+                cache_kwargs=self.cache_kwargs,
+                filter_by_timestamp=filter_by_timestamp,
+                filter_by_depth=filter_by_depth
+            )
+
+            results.append(stream_runner(fn=fn, context=ctx))
+
+        return results
+
+    def scheduled(self, fn: Callable, event: str):
+        events = ScheduledEvent.from_raw_event(event=event)
+
+        results = []
+
+        for event in events:
+            ctx = ScheduledContext(
+                event=event,
+                settings=self.settings,
+                api=self.api,
+                cache_kwargs=self.cache_kwargs
+            )
+
+            results.append(scheduled_runner(fn=fn, context=ctx))
+
+        return results