pylint and py format ready

app.py

@@ -1,5 +1,4 @@
 import os
-from dotenv import load_dotenv
 from llama_index import SimpleDirectoryReader
 from llama_index.node_parser import SimpleNodeParser
 from llama_index.data_structs.node import Node, DocumentRelationship
@@ -14,14 +13,13 @@ import logging
 import sys
 
 
-load_dotenv()
 logging.basicConfig(
     stream=sys.stdout, level=logging.DEBUG
 )  # logging.DEBUG for more verbose output
 logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))
 
 
-def main():
+def main() -> None:
     documents = SimpleDirectoryReader("./data").load_data()
 
     # index = VectorStoreIndex.from_documents(documents)
@@ -31,12 +29,13 @@ def main():
     # index = VectorStoreIndex(nodes)
 
     # define embedding
-    embedding = LangchainEmbedding(OpenAIEmbeddings(chunk_size=1))
+    embedding = LangchainEmbedding(OpenAIEmbeddings(client=None, chunk_size=1))
     # define LLM
     llm_predictor = LLMPredictor(
         llm=AzureOpenAI(
-            engine="text-davinci-003",
-            model_name="text-davinci-003",
+            client=None,
+            deployment_name="text-davinci-003",
+            model="text-davinci-003",
         )
     )
 

core/lifecycle.py

@@ -1,6 +1,6 @@
 import enum
 from abc import ABC, abstractmethod
-from typing import TypeVar
+from typing import TypeVar, Optional
 
 from core import logger_factory
 
@@ -30,19 +30,24 @@ class Disposable(ABC):
 
 
 class LifecycleAware(ABC):
-    def __init__(self, state):
+    def __init__(self, state: "LifecycleState") -> None:
+        """
+        Args:
+            state(LifecycleState): lifecycle state
+        """
         self.state = state
 
-    def get_lifecycle_state(self):
+    @property
+    def get_lifecycle_state(self) -> "LifecycleState":
         return self.state
 
 
 class Lifecycle(Initializable, Startable, Stoppable, Disposable, LifecycleAware, ABC):
-    def __init__(self):
+    def __init__(self) -> None:
         self.logger = logger_factory.get_logger(self.__class__.__name__)
         self.lifecycle_state = LifecycleState(lifecycle=self)
 
-    def initialize(self):
+    def initialize(self) -> None:
         if not self.lifecycle_state.can_initialize(self.lifecycle_state.get_phase()):
             self.logger.warning("[{}]cannot initialize".format(self.__class__.__name__))
             return
@@ -50,7 +55,7 @@ class Lifecycle(Initializable, Startable, Stoppable, Disposable, LifecycleAware,
         self.do_init()
         self.lifecycle_state.set_phase(LifecyclePhase.INITIALIZED)
 
-    def start(self):
+    def start(self) -> None:
         if not self.lifecycle_state.can_start(self.lifecycle_state.get_phase()):
             self.logger.warning("[{}]cannot start".format(self.__class__.__name__))
             return
@@ -58,7 +63,7 @@ class Lifecycle(Initializable, Startable, Stoppable, Disposable, LifecycleAware,
         self.do_start()
         self.lifecycle_state.set_phase(LifecyclePhase.STARTED)
 
-    def stop(self):
+    def stop(self) -> None:
         if not self.lifecycle_state.can_stop(self.lifecycle_state.get_phase()):
             self.logger.warning("[{}]cannot stop".format(self.__class__.__name__))
             return
@@ -66,7 +71,7 @@ class Lifecycle(Initializable, Startable, Stoppable, Disposable, LifecycleAware,
         self.do_stop()
         self.lifecycle_state.set_phase(LifecyclePhase.STOPPED)
 
-    def dispose(self):
+    def dispose(self) -> None:
         if not self.lifecycle_state.can_dispose(self.lifecycle_state.get_phase()):
             self.logger.warning("[{}]cannot dispose".format(self.__class__.__name__))
             return
@@ -75,19 +80,19 @@ class Lifecycle(Initializable, Startable, Stoppable, Disposable, LifecycleAware,
         self.lifecycle_state.set_phase(LifecyclePhase.DISPOSED)
 
     @abstractmethod
-    def do_init(self):
+    def do_init(self) -> None:
         pass
 
     @abstractmethod
-    def do_start(self):
+    def do_start(self) -> None:
         pass
 
     @abstractmethod
-    def do_stop(self):
+    def do_stop(self) -> None:
         pass
 
     @abstractmethod
-    def do_dispose(self):
+    def do_dispose(self) -> None:
         pass
 
 
@@ -103,18 +108,18 @@ class LifecyclePhase(enum.Enum):
 
 
 class LifecycleController(ABC):
-    def can_initialize(self, phase: [LifecyclePhase]) -> bool:
+    def can_initialize(self, phase: Optional[LifecyclePhase]) -> bool:
         return phase is None or phase == LifecyclePhase.DISPOSED
 
-    def can_start(self, phase: [LifecyclePhase]) -> bool:
+    def can_start(self, phase: Optional[LifecyclePhase]) -> bool:
         return phase is not None and (
             phase == LifecyclePhase.INITIALIZED or phase == LifecyclePhase.STOPPED
         )
 
-    def can_stop(self, phase: [LifecyclePhase]) -> bool:
+    def can_stop(self, phase: Optional[LifecyclePhase]) -> bool:
         return phase is not None and phase == LifecyclePhase.STARTED
 
-    def can_dispose(self, phase: [LifecyclePhase]) -> bool:
+    def can_dispose(self, phase: Optional[LifecyclePhase]) -> bool:
         return phase is not None and (
             phase == LifecyclePhase.INITIALIZED or phase == LifecyclePhase.STOPPED
         )
@@ -124,7 +129,9 @@ LS = TypeVar("LS", bound=Lifecycle)
 
 
 class LifecycleState(LifecycleController, ABC):
-    def __init__(self, lifecycle: [LS]):
+    phase: Optional[LifecyclePhase]
+
+    def __init__(self, lifecycle: LS) -> None:
         self.phase = None
         self.prev_phase = None
         self.lifecycle = lifecycle
@@ -154,18 +161,25 @@ class LifecycleState(LifecycleController, ABC):
     def is_disposed(self) -> bool:
         return self.phase == LifecyclePhase.DISPOSED
 
-    def get_phase(self) -> LifecyclePhase:
+    def get_phase(self) -> Optional[LifecyclePhase]:
         return self.phase
 
-    def set_phase(self, phase: [LifecyclePhase]) -> None:
-        prev = "None" if self.phase is None else self.phase.name
+    def set_phase(self, phase: Optional[LifecyclePhase]) -> None:
+        prev = "None"
+        if self.phase is not None:
+            prev = self.phase.name
+        current = "None"
+        if phase is not None:
+            current = phase.name
         self.logger.info(
             "[setPhaseName][{}]{} --> {}".format(
-                self.lifecycle.__class__.__name__, prev, phase.name
+                self.lifecycle.__class__.__name__,
+                prev,
+                current,
             )
         )
         self.phase = phase
 
-    def rollback(self, err: [Exception]) -> None:
+    def rollback(self, err: Exception) -> None:
         self.phase = self.prev_phase
         self.prev_phase = None

core/logger_factory.py

@@ -3,7 +3,7 @@ from logging import handlers
 from typing import Optional
 
 
-def get_logger(name: [str], file_name: Optional[str] = None) -> logging.Logger:
+def get_logger(name: str, file_name: Optional[str] = None) -> logging.Logger:
     logger = logging.getLogger(name)
     if file_name is None:
         file_name = "app-default.log"

core/test_lifecycle.py

@@ -7,52 +7,52 @@ logging.basicConfig()
 
 
 class SubLifecycle(Lifecycle):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self.init_counter = 0
 
-    def do_init(self):
+    def do_init(self) -> None:
         self.init_counter += 1
 
-    def do_start(self):
+    def do_start(self) -> None:
         self.init_counter += 1
 
-    def do_stop(self):
+    def do_stop(self) -> None:
         self.init_counter += 1
 
-    def do_dispose(self):
+    def do_dispose(self) -> None:
         self.init_counter += 1
 
 
 class TestLifecycle(TestCase):
-    def test_initialize(self):
+    def test_initialize(self) -> None:
         ls = SubLifecycle()
         ls.initialize()
-        ls.logger.info(ls.lifecycle_state.get_phase().name)
+        ls.logger.info(ls.lifecycle_state.get_phase())
         ls.start()
-        ls.logger.info(ls.lifecycle_state.get_phase().name)
+        ls.logger.info(ls.lifecycle_state.get_phase())
         ls.stop()
-        ls.logger.info(ls.lifecycle_state.get_phase().name)
+        ls.logger.info(ls.lifecycle_state.get_phase())
         ls.dispose()
-        ls.logger.info(ls.lifecycle_state.get_phase().name)
+        ls.logger.info(ls.lifecycle_state.get_phase())
 
-    def test_start(self):
+    def test_start(self) -> None:
         self.fail()
 
-    def test_stop(self):
+    def test_stop(self) -> None:
         self.fail()
 
-    def test_dispose(self):
+    def test_dispose(self) -> None:
         self.fail()
 
-    def test_do_init(self):
+    def test_do_init(self) -> None:
         self.fail()
 
-    def test_do_start(self):
+    def test_do_start(self) -> None:
         self.fail()
 
-    def test_do_stop(self):
+    def test_do_stop(self) -> None:
         self.fail()
 
-    def test_do_dispose(self):
+    def test_do_dispose(self) -> None:
         self.fail()

github_retriever.py

@@ -10,7 +10,7 @@ import os
 import pickle
 
 
-def main():
+def main() -> None:
     # define embedding
     embedding = LangchainEmbedding(OpenAIEmbeddings(chunk_size=1))
     # define LLM

langchain/manager.py

@@ -8,8 +8,8 @@ from langchain.base_language import BaseLanguageModel
 from core.lifecycle import Lifecycle
 
 
-class LangChainManager(Lifecycle, ABC):
-    def __init__(self):
+class BaseLangChainManager(Lifecycle, ABC):
+    def __init__(self) -> None:
         super().__init__()
 
     @abstractmethod
@@ -21,17 +21,19 @@ class LangChainManager(Lifecycle, ABC):
         pass
 
 
-class LangChainAzureManager(LangChainManager):
-    def __init__(self):
+class LangChainAzureManager(BaseLangChainManager):
+    def __init__(self) -> None:
         super().__init__()
 
     # Override
     def get_embedding(self) -> LCEmbeddings:
-        return OpenAIEmbeddings(chunk_size=1)
+        return OpenAIEmbeddings(client=None, chunk_size=1)
 
     # Override
     def get_llm(self) -> BaseLanguageModel:
         return AzureOpenAI(
-            engine="text-davinci-003",
-            model_name="text-davinci-003",
+            deployment_name="text-davinci-003",
+            # model_name="text-davinci-003",
+            model="text-davinci-003",
+            client=None,
         )

llama/context.py

@@ -1,23 +1,29 @@
 from llama_index import ServiceContext, LLMPredictor, LangchainEmbedding
-
+from type import Optional
 from core.lifecycle import Lifecycle
-from langchain.manager import LangChainManager
+from langchain.manager import BaseLangChainManager
 
 
 class ServiceContextManager(Lifecycle):
-    def __init__(self, manager: [LangChainManager]):
+    service_context: Optional[ServiceContext]
+
+    def __init__(self, manager: BaseLangChainManager) -> None:
         super().__init__()
         self.manager = manager
         self.service_context = None
 
     def get_service_context(self) -> ServiceContext:
         if self.lifecycle_state.is_started():
-            raise Exception(
-                "incorrect lifecycle state: {}".format(self.get_lifecycle_state())
+            raise KeyError(
+                "incorrect lifecycle state: {}".format(self.lifecycle_state.phase)
+            )
+        if self.service_context is None:
+            raise ValueError(
+                "service context is not ready, check for lifecycle statement"
             )
         return self.service_context
 
-    def do_init(self):
+    def do_init(self) -> None:
         # define embedding
         embedding = LangchainEmbedding(self.manager.get_embedding())
         # define LLM
@@ -27,29 +33,29 @@ class ServiceContextManager(Lifecycle):
             llm_predictor=llm_predictor, embed_model=embedding
         )
 
-    def do_start(self):
+    def do_start(self) -> None:
         pass
 
-    def do_stop(self):
+    def do_stop(self) -> None:
         pass
 
-    def do_dispose(self):
+    def do_dispose(self) -> None:
         pass
 
 
 class StorageContextManager(Lifecycle):
-    def __init__(self, dataset_path: [str] = "./dataset"):
+    def __init__(self, dataset_path: Optional[str] = "./dataset") -> None:
         super().__init__()
         self.dataset_path = dataset_path
 
-    def do_init(self):
+    def do_init(self) -> None:
         pass
 
-    def do_start(self):
+    def do_start(self) -> None:
         pass
 
-    def do_stop(self):
+    def do_stop(self) -> None:
         pass
 
-    def do_dispose(self):
+    def do_dispose(self) -> None:
         pass

llama/index.py

@@ -1,14 +1,18 @@
 from core.lifecycle import Lifecycle
 from llama.context import ServiceContextManager
+from llama_index.indices.vector_store import VectorStoreIndex
+from typing import Optional
 
 
 class IndexManager(Lifecycle):
-    def __init__(self, context_manager: [ServiceContextManager]):
+    index: Optional[VectorStoreIndex]
+
+    def __init__(self, context_manager: ServiceContextManager) -> None:
         super().__init__()
         self.index = None
         self.context_manager = context_manager
 
-    def get_index(self):
+    def get_index(self) -> Optional[VectorStoreIndex]:
         if not self.lifecycle_state.is_started():
             raise Exception("Lifecycle state is not correct")
         return self.index

llama/vector_storage.py

@@ -2,17 +2,17 @@ from core.lifecycle import Lifecycle
 
 
 class VectorStorageManager(Lifecycle):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
-    def do_init(self):
+    def do_init(self) -> None:
         pass
 
-    def do_start(self):
+    def do_start(self) -> None:
         pass
 
-    def do_stop(self):
+    def do_stop(self) -> None:
         pass
 
-    def do_dispose(self):
+    def do_dispose(self) -> None:
         pass

pyproject.toml

@@ -1,7 +1,7 @@
 [tool.mypy]
 ignore_missing_imports = "True"
 disallow_untyped_defs = "True"
-exclude = ["notebooks", "build", "examples"]
+exclude = ["notebooks", "build", "examples", "docs", "dataset", "app.py", "github_retriever.py"]
 
 [tool.ruff]
 exclude = [
@@ -14,4 +14,6 @@ exclude = [
     "notebooks",
     "docs",
     "dataset",
+    "app.py",
+    "github_retriever.py"
 ]

requirements.txt

@@ -1,3 +1,7 @@
 llama_index
 llama_hub
-langchain
+langchain
+dotenv
+ruff
+black
+mypy