appkit-imagecreator 0.7.1__tar.gz

appkit_imagecreator-0.7.1/.gitignore

@@ -0,0 +1,114 @@
+__pycache__/
+__pypackages__/
+.cache
+.coverage
+.coverage.*
+.dmypy.json
+.DS_Store
+.eggs/
+.env
+.env.backup
+.env.docker
+.hypothesis/
+.idea/
+.installed.cfg
+.ipynb_checkpoints
+.mypy_cache/
+.nox/
+.pdm.toml
+.pybuilder/
+.pyre/
+.pytest_cache/
+.Python
+.python_packages
+.pytype/
+.ropeproject
+.scrapy
+.spyderproject
+.spyproject
+.states
+.tox/
+.venv
+.venv.mac
+.web
+.webassets-cache
+*.bak
+*.cover
+*.db
+*.egg
+*.egg-info/
+*.kv-env.*
+*.log
+*.manifest
+*.mo
+*.pot
+*.py,cover
+*.py[cod]
+*.sage.py
+*.so
+*.spec
+*.terraform.lock.hcl
+*.tfplan
+*.tfstate
+*.tfstate.*.backup
+*.tfstate.backup
+*.tfvars
+**/.terraform/*
+*$py.class
+/site
+/vectorstore/
+aila-storage/
+assets/external/
+build/
+celerybeat-schedule
+celerybeat.pid
+configuration/config.abaz009.yaml
+configuration/config.bubb001.yaml
+configuration/config.stie104.yaml
+configuration/config.voro047.yaml
+connector examples/sharepoint.json
+cover/
+coverage.xml
+cython_debug/
+db.sqlite3
+db.sqlite3-journal
+develop-eggs/
+dist/
+dmypy.json
+docs/_build/
+Documents/
+downloads/
+eggs/
+env.bak/
+env/
+ENV/
+htmlcov/
+instance/
+ipython_config.py
+knowledge/migrate.py
+lib/
+lib64/
+local_settings.py
+local.settings.json
+MANIFEST
+nosetests.xml
+out
+parts/
+pip-delete-this-directory.txt
+pip-log.txt
+Pipfile
+profile_default/
+sdist/
+share/python-wheels/
+sketchpad/
+sketchpad/
+stores/
+target/
+tests/mcp_test.py
+tmp.txt
+uploaded_files/
+uploads/
+var/
+venv.bak/
+venv/
+wheels/

appkit_imagecreator-0.7.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: appkit-imagecreator
+Version: 0.7.1
+Summary: Add your description here
+Author: Jens Rehpöhler
+Requires-Python: >=3.13
+Requires-Dist: appkit-commons
+Requires-Dist: google-genai>=1.26.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: openai>=2.3.0

appkit_imagecreator-0.7.1/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "appkit-imagecreator"
+version = "0.7.1"
+description = "Add your description here"
+readme = "README.md"
+authors = [{ name = "Jens Rehpöhler" }]
+requires-python = ">=3.13"
+dependencies = [
+    "google-genai>=1.26.0",
+    "httpx>=0.28.1",
+    "appkit-commons",
+    "openai>=2.3.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.uv.sources]
+appkit-commons = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/appkit_imagecreator"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

appkit_imagecreator-0.7.1/src/appkit_imagecreator/backend/generator_registry.py

@@ -0,0 +1,108 @@
+import logging
+from typing import Final
+
+from appkit_commons.configuration.configuration import ReflexConfig
+from appkit_commons.registry import service_registry
+from appkit_imagecreator.backend.generators import (
+    GoogleImageGenerator,
+)
+from appkit_imagecreator.backend.generators.openai import OpenAIImageGenerator
+from appkit_imagecreator.backend.models import ImageGenerator
+from appkit_imagecreator.configuration import ImageGeneratorConfig
+from rxconfig import config
+
+logger = logging.getLogger(__name__)
+
+
+class ImageGeneratorRegistry:
+    """Registry of image generators.
+
+    Maintains a collection of configured image generators that can be retrieved by ID.
+    """
+
+    def __init__(self):
+        self.config = service_registry().get(ImageGeneratorConfig)
+        self.reflex_config = service_registry().get(ReflexConfig)
+        self._generators: dict[str, ImageGenerator] = {}
+        self._initialize_default_generators()
+
+        logger.debug("reflex config: %s", self.reflex_config)
+        logger.debug("image generator config: %s", self.config)
+
+    def _initialize_default_generators(self) -> None:
+        """Initialize the registry with default generators."""
+
+        if self.reflex_config.single_port:
+            backend_server = f"{self.reflex_config.deploy_url}"
+        else:
+            backend_server = f"{self.reflex_config.deploy_url}:{config.backend_port}"
+
+        self.register(
+            OpenAIImageGenerator(
+                api_key=self.config.openai_api_key.get_secret_value(),
+                base_url=self.config.openai_base_url,
+                backend_server=backend_server,
+            )
+        )
+        self.register(
+            OpenAIImageGenerator(
+                api_key=self.config.openai_api_key.get_secret_value(),
+                base_url=self.config.openai_base_url,
+                backend_server=backend_server,
+                model="FLUX-1.1-pro",
+                label="Blackforest Labs FLUX 1.1-pro",
+                id="FLUX-1.1-pro",
+            )
+        )
+        self.register(
+            GoogleImageGenerator(
+                api_key=self.config.google_api_key.get_secret_value(),
+                backend_server=backend_server,
+            )
+        )
+        self.register(
+            GoogleImageGenerator(
+                api_key=self.config.google_api_key.get_secret_value(),
+                backend_server=backend_server,
+                model="imagen-3.0-generate-002",
+                label="Google Imagen 3",
+                id="imagen-3",
+            )
+        )
+
+    def register(self, generator: ImageGenerator) -> None:
+        """Register a new generator in the registry."""
+        self._generators[generator.id] = generator
+
+    def get(
+        self,
+        generator_id: str,
+    ) -> ImageGenerator:
+        """Get a generator by ID.
+
+        If api_key or backend_server are provided, they will override the
+        default values.
+        """
+        if generator_id not in self._generators:
+            raise ValueError(f"Unknown generator ID: {generator_id}")
+
+        return self._generators[generator_id]
+
+    def list_generators(self) -> list[dict[str, str]]:
+        """List all available generators with their IDs and labels."""
+        return [{"id": gen.id, "label": gen.label} for gen in self._generators.values()]
+
+    def get_generator_ids(self) -> list[str]:
+        """Get the IDs of all registered generators."""
+        return list(self._generators.keys())
+
+    def get_default_generator(self) -> ImageGenerator:
+        """Get the default generator."""
+        if not self._generators:
+            raise ValueError("No generators registered.")
+
+        return next(iter(self._generators.values()))
+
+
+# Create a global instance of the registry
+generator_registry: Final = ImageGeneratorRegistry()

appkit_imagecreator-0.7.1/src/appkit_imagecreator/backend/generators/__init__.py

@@ -0,0 +1,11 @@
+from appkit_imagecreator.backend.generators.black_forest_labs import (
+    BlackForestLabsImageGenerator,
+)
+from appkit_imagecreator.backend.generators.openai import OpenAIImageGenerator
+from appkit_imagecreator.backend.generators.google import GoogleImageGenerator
+
+__ALL__ = [
+    "BlackForestLabsImageGenerator",
+    "OpenAIImageGenerator",
+    "GoogleImageGenerator",
+]

appkit_imagecreator-0.7.1/src/appkit_imagecreator/backend/generators/black_forest_labs.py

@@ -0,0 +1,117 @@
+import asyncio
+import logging
+
+import httpx
+
+from appkit_imagecreator.backend.models import (
+    GenerationInput,
+    ImageGenerator,
+    ImageGeneratorResponse,
+    ImageResponseState,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class BlackForestLabsImageGenerator(ImageGenerator):
+    """Generator for the Together AI API (Flux Schnell model)."""
+
+    def __init__(
+        self,
+        api_key: str,
+        label: str = "Flux.1 Kontext [Pro]",
+        id: str = "flux-kontext-pro",  # noqa: A002
+        model: str = "flux-kontext-pro",
+        backend_server: str | None = None,
+    ) -> None:
+        super().__init__(
+            id=id,
+            label=label,
+            model=model,
+            api_key=api_key,
+            backend_server=backend_server,
+        )
+
+    async def _perform_generation(
+        self, input_data: GenerationInput
+    ) -> ImageGeneratorResponse:
+        prompt = self._format_prompt(input_data.prompt, input_data.negative_prompt)
+
+        api_url = f"https://api.bfl.ai/v1/{self.model}"
+        headers = {
+            "accept": "application/json",
+            "x-key": self.api_key,
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "prompt": prompt,
+            "aspect_ratio": self._aspect_ratio(input_data.width, input_data.height),
+            "seed": input_data.seed,
+            "prompt_upsampling": input_data.enhance_prompt,
+            "safety_tolerance": 6,
+        }
+
+        error_msg = None
+        image_url = None
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(api_url, headers=headers, json=payload)
+                response.raise_for_status()  # Raise an exception for bad status codes
+                request_data = response.json()
+
+                polling_url = request_data.get("polling_url")
+                polling_headers = {
+                    "accept": "application/json",
+                    "x-key": self.api_key,
+                }
+
+                while True:
+                    await asyncio.sleep(1.5)  # Use asyncio.sleep for async context
+                    poll_response = await client.get(
+                        polling_url, headers=polling_headers
+                    )
+                    poll_response.raise_for_status()
+                    result = poll_response.json()
+                    status = result.get("status")
+
+                    if status == "Ready":
+                        image_url = result.get("result", {}).get("sample")
+                        if not image_url:
+                            error_msg = (
+                                "Bild-URL wurde im 'Ready'-Status nicht gefunden."
+                            )
+                        break
+                    if status not in ["Pending", "Processing", "Queued"]:
+                        error_msg = f"Ein Fehler oder ein unerwarteter Status ist aufgetreten: {result}"  # noqa: E501
+                        break
+        except httpx.HTTPStatusError as e:
+            error_msg = (
+                f"HTTP-Fehler aufgetreten: {e.response.status_code} - {e.response.text}"
+            )
+            logger.error(error_msg)
+        except httpx.RequestError as e:
+            error_msg = f"Anfragefehler aufgetreten: {e!s}"
+            logger.error(error_msg)
+        except Exception as e:
+            error_msg = f"Ein unerwarteter Fehler ist aufgetreten: {e!s}"
+            logger.exception("Unerwarteter Fehler während der Bildgenerierung")
+
+        if error_msg or not image_url:
+            final_error_message = (
+                error_msg or "Zu dem generierten Bild wurde keine URL erstellt."
+            )
+            logger.error(
+                "Image generation failed: %s",
+                final_error_message,
+            )
+            return ImageGeneratorResponse(
+                state=ImageResponseState.FAILED,
+                images=[],
+                error=final_error_message,
+            )
+
+        return ImageGeneratorResponse(
+            state=ImageResponseState.SUCCEEDED,
+            images=[image_url],
+        )

appkit_imagecreator-0.7.1/src/appkit_imagecreator/backend/generators/google.py

@@ -0,0 +1,84 @@
+import logging
+from typing import Final
+
+from google import genai
+
+from appkit_imagecreator.backend.models import (
+    GenerationInput,
+    ImageGenerator,
+    ImageGeneratorResponse,
+    ImageResponseState,
+)
+
+logger = logging.getLogger(__name__)
+
+TMP_IMG_FILE: Final[str] = "imagen-image"
+
+
+class GoogleImageGenerator(ImageGenerator):
+    """Generator for the Google Imagen API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        label: str = "Google Imagen 4",
+        id: str = "imagen-4",  # noqa: A002
+        model: str = "imagen-4.0-generate-preview-06-06",
+        backend_server: str | None = None,
+    ) -> None:
+        super().__init__(
+            id=id,
+            label=label,
+            model=model,
+            api_key=api_key,
+            backend_server=backend_server,
+        )
+        self.client = genai.Client(api_key=self.api_key)
+
+    def _enhance_prompt(self, prompt: str) -> str:
+        response = self.client.models.generate_content(
+            model="gemini-2.0-flash-001",
+            contents=(
+                "You are an image generation assistant specialized in "
+                "optimizing user prompts. Ensure content "
+                "compliance rules are followed. Do not ask followup "
+                "questions, just generate the plain, raw, optimized prompt "
+                "withoud any additional text, headlines or questions."
+                f"Enhance this prompt for image generation: {prompt}"
+            ),
+        )
+
+        prompt = response.text.strip()
+        logger.debug("Enhanced prompt for image generation: %s", prompt)
+        return prompt
+
+    async def _perform_generation(
+        self, input_data: GenerationInput
+    ) -> ImageGeneratorResponse:
+        prompt = self._format_prompt(input_data.prompt, input_data.negative_prompt)
+
+        if input_data.enhance_prompt:
+            prompt = self._enhance_prompt(prompt)
+
+        response = self.client.models.generate_images(
+            model=self.model,
+            prompt=prompt,
+            config=genai.types.GenerateImagesConfig(
+                number_of_images=input_data.n,
+                aspect_ratio=self._aspect_ratio(input_data.width, input_data.height),
+            ),
+        )
+
+        self.clean_tmp_path(TMP_IMG_FILE)
+        output_format = "jpeg"
+        images = []
+
+        for img in response.generated_images:
+            image_url = await self._save_image_to_tmp_and_get_url(
+                image_bytes=img.image.image_bytes,
+                tmp_file_prefix=TMP_IMG_FILE,
+                output_format=output_format,
+            )
+            images.append(image_url)
+
+        return ImageGeneratorResponse(state=ImageResponseState.SUCCEEDED, images=images)

appkit_imagecreator-0.7.1/src/appkit_imagecreator/backend/generators/openai.py

@@ -0,0 +1,119 @@
+import base64
+import logging
+from typing import Final
+
+from openai import AsyncAzureOpenAI
+
+from appkit_imagecreator.backend.models import (
+    GenerationInput,
+    ImageGenerator,
+    ImageGeneratorResponse,
+    ImageResponseState,
+)
+
+logger = logging.getLogger(__name__)
+
+TMP_IMG_FILE: Final[str] = "gpt-image"
+
+
+class OpenAIImageGenerator(ImageGenerator):
+    """Generator for the OpenAI DALL-E API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        id: str = "gpt-image-1",  # noqa: A002
+        label: str = "OpenAI GPT-Image-1",
+        model: str = "gpt-image-1",
+        backend_server: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        super().__init__(
+            id=id,
+            label=label,
+            model=model,
+            api_key=api_key,
+            backend_server=backend_server,
+        )
+        # self.client = AsyncOpenAI(api_key=self.api_key)
+
+        self.client = AsyncAzureOpenAI(
+            api_version="2025-04-01-preview",
+            azure_endpoint=base_url,
+            api_key=api_key,
+        )
+
+    async def _enhance_prompt(self, prompt: str) -> str:
+        response = await self.client.chat.completions.create(
+            model="gpt-4.1-mini",
+            stream=False,
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are an image generation assistant specialized in "
+                        "optimizing user prompts. Ensure content "
+                        "compliance rules are followed. Do not ask followup "
+                        "questions, just generate the optimized prompt."
+                    ),
+                },
+                {
+                    "role": "user",
+                    "content": f"Enhance this prompt for image generation: {prompt}",
+                },
+            ],
+        )
+
+        result = response.choices[0].message.content.strip()
+        if not result:
+            result = prompt
+
+        logger.debug("Enhanced prompt for image generation: %s", result)
+        return result
+
+    async def _perform_generation(
+        self, input_data: GenerationInput
+    ) -> ImageGeneratorResponse:
+        output_format = "jpeg"
+        prompt = self._format_prompt(input_data.prompt, input_data.negative_prompt)
+
+        if input_data.enhance_prompt:
+            prompt = await self._enhance_prompt(prompt)
+
+        response = await self.client.images.generate(
+            model=self.model,
+            prompt=prompt,
+            n=input_data.n,
+            moderation="low",
+            output_format=output_format,
+            output_compression=95,
+        )
+
+        self.clean_tmp_path(TMP_IMG_FILE)
+
+        images = []
+        for img in response.data:
+            if img.url:
+                images.append(img.url)
+            elif img.b64_json:
+                image_bytes = base64.b64decode(img.b64_json)
+                image_url = await self._save_image_to_tmp_and_get_url(
+                    image_bytes=image_bytes,
+                    tmp_file_prefix=TMP_IMG_FILE,
+                    output_format=output_format,
+                )
+                images.append(image_url)
+            else:
+                logger.warning("Image data from OpenAI is neither b64_json nor a URL.")
+
+        if not images:
+            logger.error(
+                "No images were successfully processed or retrieved from OpenAI."
+            )
+            return ImageGeneratorResponse(
+                state=ImageResponseState.FAILED,
+                images=[],
+                error="Es wurden keine Bilder generiert oder von der API abgerufen.",
+            )
+
+        return ImageGeneratorResponse(state=ImageResponseState.SUCCEEDED, images=images)