🚧 WIP

Author: Dmytro Parfeniuk

src/guidellm/backend/__init__.py

@@ -1,9 +1,9 @@
-from .base import Backend, BackendTypes, GenerativeResponse
+from .base import Backend, BackendEngine, GenerativeResponse
 from .openai import OpenAIBackend
 
 __all__ = [
     "Backend",
-    "BackendTypes",
+    "BackendEngine",
     "GenerativeResponse",
     "OpenAIBackend",
 ]

src/guidellm/backend/base.py

@@ -9,10 +9,10 @@
 from guidellm.core.request import TextGenerationRequest
 from guidellm.core.result import TextGenerationResult
 
-__all__ = ["Backend", "BackendTypes", "GenerativeResponse"]
+__all__ = ["Backend", "BackendEngine", "GenerativeResponse"]
 
 
-class BackendTypes(Enum):
+class BackendEngine(Enum):
     TEST = "test"
     OPENAI_SERVER = "openai_server"
 
@@ -39,7 +39,7 @@ class Backend(ABC):
     _registry = {}
 
     @staticmethod
-    def register_backend(backend_type: BackendTypes):
+    def register(backend_type: BackendEngine):
         """
         A decorator to register a backend class in the backend registry.
 
@@ -54,7 +54,7 @@ def inner_wrapper(wrapped_class: Type["Backend"]):
         return inner_wrapper
 
     @staticmethod
-    def create_backend(backend_type: Union[str, BackendTypes], **kwargs) -> "Backend":
+    def create(backend_type: Union[str, BackendEngine], **kwargs) -> "Backend":
         """
         Factory method to create a backend based on the backend type.
 

src/guidellm/backend/openai.py

@@ -4,13 +4,13 @@
 from loguru import logger
 from transformers import AutoTokenizer
 
-from guidellm.backend import Backend, BackendTypes, GenerativeResponse
-from guidellm.core.request import TextGenerationRequest
+from guidellm.backend import Backend, BackendEngine, GenerativeResponse
+from guidellm.core import TextGenerationRequest
 
 __all__ = ["OpenAIBackend"]
 
 
-@Backend.register_backend(BackendTypes.OPENAI_SERVER)
+@Backend.register(BackendEngine.OPENAI_SERVER)
 class OpenAIBackend(Backend):
     """
     An OpenAI backend implementation for the generative AI result.

src/guidellm/main.py

@@ -78,7 +78,7 @@ def main(
     num_requests,
 ):
     # Create backend
-    Backend.create_backend(
+    Backend.create(
         backend_type=backend,
         target=target,
         host=host,

tests/conftest.py

@@ -0,0 +1,64 @@
+import random
+from typing import List, Optional
+
+import pytest
+from loguru import logger
+from openai.pagination import SyncPage
+from openai.types import Completion, Model
+
+from guidellm.backend import Backend, BackendEngine, OpenAIBackend
+
+from . import dummy
+
+
+def pytest_configure() -> None:
+    logger.disable("guidellm")
+
+
+@pytest.fixture(autouse=True)
+def openai_models_list_patch(mocker) -> List[Model]:
+    """
+    Mock available models function to avoid OpenAI API call.
+    """
+
+    items = dummy.data.OpenAIModel.batch(3)
+    mocker.patch(
+        "openai.resources.models.Models.list",
+        return_value=SyncPage(object="list", data=items),
+    )
+
+    return items
+
+
+@pytest.fixture(autouse=True)
+def openai_completion_create_patch(mocker) -> List[Completion]:
+    """
+    Mock available models function to avoid OpenAI API call.
+    """
+
+    items = dummy.data.OpenAICompletion.batch(random.randint(2, 5))
+    mocker.patch("openai.resources.completions.Completions.create", return_value=items)
+
+    return items
+
+
+@pytest.fixture
+def openai_backend_factory():
+    """
+    OpenAI Backend factory method.
+    Call without provided arguments returns default Backend service.
+    """
+
+    def inner_wrapper(*_, base_url: Optional[str] = None, **kwargs) -> OpenAIBackend:
+        static = {"backend_type": BackendEngine.OPENAI_SERVER}
+        defaults = {
+            "openai_api_key": "required but not used",
+            "internal_callback_url": base_url or "http://localhost:8080",
+        }
+
+        defaults.update(kwargs)
+        defaults.update(static)
+
+        return Backend.create(**defaults)
+
+    return inner_wrapper

tests/dummy/__init__.py

@@ -0,0 +1,10 @@
+"""
+The tests.dummy package package represents dummy data factories and test services.
+test.dummy.data.OpenAIModel - openai.Model test factory
+test.dummy.data.OpenAICompletion - openai.Completion test factory
+test.dummy.data.OpenAICompletionChoice - openai.CompletionChoice test factory
+test.dummy.services.TestRequestGenerator - RequestGenerator that is used
+    for testing purposes
+"""
+
+from . import data, services

tests/dummy/data/__init__.py

@@ -0,0 +1,3 @@
+from .openai import OpenAICompletion, OpenAICompletionChoice, OpenAIModel
+
+__all__ = ["OpenAIModel", "OpenAICompletionChoice", "OpenAICompletion"]

tests/dummy/data/openai.py

@@ -0,0 +1,33 @@
+"""
+This module includes data models factories for openai 3-rd party package
+"""
+
+import functools
+import random
+
+from openai.types import Completion, CompletionChoice, Model
+from polyfactory.factories.pydantic_factory import ModelFactory
+
+
+class OpenAIModel(ModelFactory[Model]):
+    """
+    A model factory for Open AI Model representation.
+    """
+
+    pass
+
+
+class OpenAICompletionChoice(ModelFactory[CompletionChoice]):
+    """
+    A model factory for Open AI Completion Choice representation.
+    """
+
+    finish_reason = "stop"
+
+
+class OpenAICompletion(ModelFactory[Completion]):
+    """
+    A model factory for Open AI Completion representation.
+    """
+
+    choices = functools.partial(OpenAICompletionChoice.batch, random.randint(3, 5))

tests/dummy/services/__init__.py

@@ -0,0 +1,5 @@
+from .requests import TestRequestGenerator
+
+__all__ = [
+    "TestRequestGenerator",
+]

tests/dummy/services/requests.py

@@ -0,0 +1,12 @@
+from guidellm.core import TextGenerationRequest
+from guidellm.request import RequestGenerator
+
+
+class TestRequestGenerator(RequestGenerator):
+    """
+    This class represents the Testing Request Generator.
+    The purpose - to be used for testing.
+    """
+
+    def create_item(self) -> TextGenerationRequest:
+        return TextGenerationRequest(prompt="Test prompt")