aquiles-image 0.1.0__tar.gz

aquiles_image-0.1.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: aquiles-image
+Version: 0.1.0
+Summary: Aquiles-Image.
+Author-email: Aquiles-ai / Fredy <riveraaai200678@gmail.com>
+License: Apache License 2.0
+Project-URL: Homepage, https://github.com/Aquiles-ai/Aquiles-Image
+Project-URL: Issues, https://github.com/Aquiles-ai/Aquiles-Image/issues
+Keywords: fastapi,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: transformers
+Requires-Dist: sentencepiece
+Requires-Dist: fastapi
+Requires-Dist: click>=8.0.0
+Requires-Dist: uvicorn
+Requires-Dist: ftfy
+Requires-Dist: accelerate
+Requires-Dist: xformers
+Requires-Dist: protobuf
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+<h1 align="center">Aquiles-Image</h1>
+
+<div align="center">
+  <img src="aquilesimage/static/aquilesim.png" alt="Aquiles-Image Logo" width="225"/>
+</div>
+
+<p align="center">
+  <strong>Easy, fast and cheap Diffusion Models that work for everyone.</strong><br/>
+  🚀 FastAPI • Diffusers • Compatible with the OpenAI client
+</p>

aquiles_image-0.1.0/README.md

@@ -0,0 +1,10 @@
+<h1 align="center">Aquiles-Image</h1>
+
+<div align="center">
+  <img src="aquilesimage/static/aquilesim.png" alt="Aquiles-Image Logo" width="225"/>
+</div>
+
+<p align="center">
+  <strong>Easy, fast and cheap Diffusion Models that work for everyone.</strong><br/>
+  🚀 FastAPI • Diffusers • Compatible with the OpenAI client
+</p>

aquiles_image-0.1.0/aquiles_image.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: aquiles-image
+Version: 0.1.0
+Summary: Aquiles-Image.
+Author-email: Aquiles-ai / Fredy <riveraaai200678@gmail.com>
+License: Apache License 2.0
+Project-URL: Homepage, https://github.com/Aquiles-ai/Aquiles-Image
+Project-URL: Issues, https://github.com/Aquiles-ai/Aquiles-Image/issues
+Keywords: fastapi,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: transformers
+Requires-Dist: sentencepiece
+Requires-Dist: fastapi
+Requires-Dist: click>=8.0.0
+Requires-Dist: uvicorn
+Requires-Dist: ftfy
+Requires-Dist: accelerate
+Requires-Dist: xformers
+Requires-Dist: protobuf
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+<h1 align="center">Aquiles-Image</h1>
+
+<div align="center">
+  <img src="aquilesimage/static/aquilesim.png" alt="Aquiles-Image Logo" width="225"/>
+</div>
+
+<p align="center">
+  <strong>Easy, fast and cheap Diffusion Models that work for everyone.</strong><br/>
+  🚀 FastAPI • Diffusers • Compatible with the OpenAI client
+</p>

aquiles_image-0.1.0/aquiles_image.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+README.md
+pyproject.toml
+aquiles_image.egg-info/PKG-INFO
+aquiles_image.egg-info/SOURCES.txt
+aquiles_image.egg-info/dependency_links.txt
+aquiles_image.egg-info/entry_points.txt
+aquiles_image.egg-info/requires.txt
+aquiles_image.egg-info/top_level.txt
+aquilesimage/main.py
+aquilesimage/cli/__init__.py
+aquilesimage/cli/cli.py
+aquilesimage/configs/__init__.py
+aquilesimage/configs/configs.py
+aquilesimage/models/__init__.py
+aquilesimage/models/models.py
+aquilesimage/pipelines/__init__.py
+aquilesimage/pipelines/pipelines.py
+aquilesimage/runtime/__init__.py
+aquilesimage/runtime/requestscopedpipeline.py
+aquilesimage/runtime/scheduler.py
+aquilesimage/static/aquilesim.png
+aquilesimage/utils/__init__.py
+aquilesimage/utils/utils.py
+test/test.py

aquiles_image-0.1.0/aquiles_image.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aquiles_image-0.1.0/aquiles_image.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aquiles-image = aquilesimage.cli:cli

aquiles_image-0.1.0/aquiles_image.egg-info/requires.txt

@@ -0,0 +1,17 @@
+torch
+torchvision
+transformers
+sentencepiece
+fastapi
+click>=8.0.0
+uvicorn
+ftfy
+accelerate
+xformers
+protobuf
+
+[dev]
+pytest
+black
+isort
+mypy

aquiles_image-0.1.0/aquiles_image.egg-info/top_level.txt

@@ -0,0 +1 @@
+aquilesimage

aquiles_image-0.1.0/aquilesimage/cli/__init__.py

@@ -0,0 +1 @@
+from .cli import cli

aquiles_image-0.1.0/aquilesimage/cli/cli.py

@@ -0,0 +1,147 @@
+import click
+from typing import Optional
+import sys
+
+@click.group()
+def cli():
+    """A sample CLI application."""
+    pass
+
+@cli.command("hello")
+@click.option("--name")
+def greet(name):
+    click.echo(f"Hello, {name}!")
+
+@cli.command("serve")
+@click.option("--host", default="0.0.0.0", help="Host where Aquiles-Image will be executed")
+@click.option("--port", type=int, default=5500, help="Port where Aquiles-Image will be executed")
+@click.option("--model", type=str, help="The model to use for image generation.")
+@click.option("--api-key", type=str, help="API KEY enabled to make requests")
+@click.option("--max-concurrent-infer", type=int, help="Maximum concurrent inferences")
+@click.option("--block-request/--no-block-request", default=None, help="Block requests during maximum concurrent inferences")
+@click.option("--force", is_flag=True, help="Force overwrite existing configuration")
+def serve(host: str, port: int, model: Optional[str], api_key: Optional[str], 
+         max_concurrent_infer: Optional[int], block_request: Optional[bool], force: bool):
+    """Start the Aquiles-Image server."""
+    try:
+        import uvicorn
+        from aquilesimage.main import app
+        from aquilesimage.configs import load_config_cli, configs_image_serve
+        from aquilesimage.models import ConfigsServe
+    except ImportError as e:
+        click.echo(f"Error importing required modules: {e}", err=True)
+        sys.exit(1)
+
+    try:
+        conf = load_config_cli()
+    except Exception as e:
+        click.echo(f"Error loading configuration: {e}", err=True)
+        sys.exit(1)
+
+    model_from_config = conf.get("model")
+    final_model = model or model_from_config
+
+    if not final_model:
+        click.echo("Error: No model specified. Use --model parameter or configure one first.", err=True)
+        sys.exit(1)
+
+    config_needs_update = any([
+        model is not None,
+        api_key is not None,
+        max_concurrent_infer is not None,
+        block_request is not None
+    ])
+
+    if config_needs_update:
+        try:
+            api_keys = [api_key] if api_key else []
+            
+            gen_conf = ConfigsServe(
+                model=final_model,
+                allows_api_keys=api_keys,
+                max_concurrent_infer=max_concurrent_infer,
+                block_request=block_request
+            )
+
+            configs_image_serve(gen_conf, force)
+            click.echo("Configuration updated successfully.")
+            
+        except Exception as e:
+            click.echo(f"Error saving configuration: {e}", err=True)
+            sys.exit(1)
+
+    click.echo(f"Starting server with:")
+    click.echo(f"  Host: {host}")
+    click.echo(f"  Port: {port}")
+    click.echo(f"  Model: {final_model}")
+    
+    try:
+        uvicorn.run(app, host=host, port=port)
+    except Exception as e:
+        click.echo(f"Error starting server: {e}", err=True)
+        sys.exit(1)
+
+@cli.command("configs")
+@click.option("--show", is_flag=True, help="Show current configuration")
+@click.option("--reset", is_flag=True, help="Reset configuration to defaults")
+def configs(show: bool, reset: bool):
+    """Manage Aquiles-Image configuration."""
+    try:
+        from aquilesimage.configs import load_config_cli, clear_config_cache
+        import json
+    except ImportError as e:
+        click.echo(f"Error importing required modules: {e}", err=True)
+        sys.exit(1)
+
+    if reset:
+        if click.confirm("Are you sure you want to reset the configuration?"):
+            try:
+                clear_config_cache() 
+                click.echo("Configuration reset successfully.")
+            except Exception as e:
+                click.echo(f"Error resetting configuration: {e}", err=True)
+        return
+
+    if show:
+        try:
+            conf = load_config_cli()
+            if conf:
+                click.echo("Current configuration:")
+                click.echo(json.dumps(conf, indent=2, ensure_ascii=False))
+            else:
+                click.echo("No configuration found.")
+        except Exception as e:
+            click.echo(f"Error loading configuration: {e}", err=True)
+        return
+
+    ctx = click.get_current_context()
+    click.echo(ctx.get_help())
+
+
+@cli.command("validate")
+def validate():
+    """Validate current configuration."""
+    try:
+        from aquilesimage.configs import load_config_cli
+        from aquilesimage.models import ConfigsServe
+    except ImportError as e:
+        click.echo(f"Error importing required modules: {e}", err=True)
+        sys.exit(1)
+
+    try:
+        conf = load_config_cli()
+        
+        if not conf:
+            click.echo("❌ No configuration found.", err=True)
+            sys.exit(1)
+            
+        validated_conf = ConfigsServe(**conf)
+        click.echo("✅ Configuration is valid.")
+        
+    except Exception as e:
+        click.echo(f"❌ Configuration validation failed: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

aquiles_image-0.1.0/aquilesimage/configs/__init__.py

@@ -0,0 +1 @@
+from .configs import configs_image_serve, load_config_cli, load_config_app, clear_config_cache

aquiles_image-0.1.0/aquilesimage/configs/configs.py

@@ -0,0 +1,100 @@
+from platformdirs import user_data_dir
+import json
+import aiofiles
+import asyncio
+from pathlib import Path
+import os
+from aquilesimage.models import ConfigsServe
+from typing import Dict, Any
+import time
+import threading
+from typing import Optional
+
+_load_lock = asyncio.Lock()
+data_dir = user_data_dir("aquiles", "Aquiles-Image")
+os.makedirs(data_dir, exist_ok=True)
+AQUILES_CONFIG = os.path.join(data_dir, "aquiles_cofig.json")
+_cache_lock = threading.Lock()
+_cached_config: Optional[Dict[str, Any]] = None
+_cache_timestamp: float = 0
+_cache_mtime: float = 0
+
+
+def load_config_cli(use_cache: bool = True, cache_ttl: float = 30.0) -> Dict[str, Any]:
+    global _cached_config, _cache_timestamp, _cache_mtime
+    config_path = Path(AQUILES_CONFIG)
+    if not config_path.exists():
+        return {}
+    current_time = time.time()
+    if use_cache:
+        with _cache_lock:
+            try:
+                file_mtime = config_path.stat().st_mtime
+                
+                if (_cached_config is not None and 
+                    (current_time - _cache_timestamp) < cache_ttl and
+                    file_mtime == _cache_mtime):
+                    return _cached_config.copy()
+                    
+            except OSError:
+                pass
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            config_data = json.load(f)
+            
+        if use_cache:
+            with _cache_lock:
+                try:
+                    file_mtime = config_path.stat().st_mtime
+                    _cached_config = config_data.copy()
+                    _cache_timestamp = current_time
+                    _cache_mtime = file_mtime
+                except OSError:
+                    pass
+                    
+        return config_data
+        
+    except FileNotFoundError:
+        return {}
+    except (json.JSONDecodeError, OSError, UnicodeDecodeError):
+        return {}
+
+
+async def load_config_app() -> Dict[str, Any]:
+    async with _load_lock:  
+        try:
+            async with aiofiles.open(AQUILES_CONFIG, "r", encoding="utf-8") as f:
+                s = await f.read()
+        except FileNotFoundError:
+            return {}
+        except Exception as exc:
+            return {}
+
+        try:
+            return json.loads(s)
+        except json.JSONDecodeError:
+            return {}
+
+def clear_config_cache() -> None:
+    global _cached_config, _cache_timestamp, _cache_mtime
+    
+    with _cache_lock:
+        _cached_config = None
+        _cache_timestamp = 0
+        _cache_mtime = 0
+
+def configs_image_serve(cfg: ConfigsServe, force: bool = False) -> None:
+    conf = cfg.model_dump()
+    config_path = Path(AQUILES_CONFIG)
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if config_path.exists() and not force:
+        return
+    try:
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(conf, f, ensure_ascii=False, indent=2)
+        
+        clear_config_cache()
+          
+    except (OSError, UnicodeEncodeError) as e:
+        pass

aquiles_image-0.1.0/aquilesimage/main.py

@@ -0,0 +1,178 @@
+"""
+The goal is to create image generation, editing, and variance endpoints compatible with the OpenAI client.
+
+APIs:
+
+POST /images/variations (create_variation)
+POST /images/edits (edit)
+POST /images/generations (generate)
+"""
+
+from fastapi import FastAPI, UploadFile, File, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.concurrency import run_in_threadpool
+from aquilesimage.models import CreateImageRequest, ImagesResponse, CreateImageEditRequest, CreateImageVariationRequest
+from aquilesimage.utils import Utils, setup_colored_logger
+from aquilesimage.runtime import RequestScopedPipeline
+from aquilesimage.pipelines import ModelPipelineInit
+from aquilesimage.configs import load_config_app, load_config_cli
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+import threading
+import torch
+import random
+
+logger = setup_colored_logger("Aquiles-Image", logging.INFO)
+
+logger.info("Loading the model...")
+
+model_pipeline = None
+request_pipe = None
+pipeline_lock = threading.Lock()
+initializer = None
+config = None
+
+def load_models():
+    global model_pipeline, request_pipe, initializer, config
+
+    logger.info("Loading configuration...")
+    
+    config = load_config_cli() 
+    model_name = config.get("model")
+
+    if not model_name:
+        raise ValueError("No model specified in configuration. Please configure a model first.")
+    
+    logger.info(f"Loading model: {model_name}")
+    
+    try:
+        initializer = ModelPipelineInit(model=model_name)
+        model_pipeline = initializer.initialize_pipeline()
+        model_pipeline.start()
+        
+        request_pipe = RequestScopedPipeline(model_pipeline.pipeline)
+        
+        logger.info(f"Model '{model_name}' loaded successfully")
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize model pipeline: {e}")
+        raise
+
+try:
+    load_models()
+except Exception as e:
+    logger.error(f"Failed to initialize models: {e}")
+    raise
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    app.state.total_requests = 0
+    app.state.active_inferences = 0
+    app.state.metrics_lock = asyncio.Lock()
+    app.state.metrics_task = None
+    app.state.config = await load_config_app()
+
+    app.state.MODEL_INITIALIZER = initializer
+    app.state.MODEL_PIPELINE = model_pipeline
+    app.state.REQUEST_PIPE = request_pipe
+    app.state.PIPELINE_LOCK = pipeline_lock
+
+    # dumb config
+    app.state.utils_app = Utils(
+            host="0.0.0.0",
+            port=5500,
+        )
+
+    async def metrics_loop():
+            try:
+                while True:
+                    async with app.state.metrics_lock:
+                        total = app.state.total_requests
+                        active = app.state.active_inferences
+                    logger.info(f"[METRICS] total_requests={total} active_inferences={active}")
+                    await asyncio.sleep(5)
+            except asyncio.CancelledError:
+                logger.info("Metrics loop cancelled")
+                raise
+
+    app.state.metrics_task = asyncio.create_task(metrics_loop())
+
+    try:
+        yield
+    finally:
+        task = app.state.metrics_task
+        if task:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+        try:
+            stop_fn = getattr(model_pipeline, "stop", None) or getattr(model_pipeline, "close", None)
+            if callable(stop_fn):
+                await run_in_threadpool(stop_fn)
+        except Exception as e:
+            logger.warning(f"Error during pipeline shutdown: {e}")
+
+        if model_pipeline:
+            try:
+                stop_fn = getattr(model_pipeline, "stop", None) or getattr(model_pipeline, "close", None)
+                if callable(stop_fn):
+                    await run_in_threadpool(stop_fn)
+                    logger.info("Model pipeline stopped successfully")
+            except Exception as e:
+                logger.warning(f"Error during pipeline shutdown: {e}")
+
+        logger.info("Lifespan shutdown complete")
+
+app = FastAPI(title="Aquiles-Image", lifespan=lifespan)
+
+@app.middleware("http")
+async def count_requests_middleware(request: Request, call_next):
+    async with app.state.metrics_lock:
+        app.state.total_requests += 1
+    response = await call_next(request)
+    return response
+
+@app.post("/images/generations", response_model=ImagesResponse, tags=["Generation"])
+async def create_image(input_r: CreateImageRequest):
+    def make_generator():
+        g = torch.Generator(device=initializer.device)
+        return g.manual_seed(random.randint(0, 10_000_000))
+
+    req_pipe = app.state.REQUEST_PIPE
+    pass
+
+@app.post("/images/edits", response_model=ImagesResponse, tags=["Edit"])  
+async def create_image_edit(input_r: CreateImageEditRequest, image: UploadFile = File(...), mask:  UploadFile | None = File(default=None)):
+    def make_generator():
+        g = torch.Generator(device=initializer.device)
+        return g.manual_seed(random.randint(0, 10_000_000))
+
+    req_pipe = app.state.REQUEST_PIPE
+    pass
+
+@app.post("/images/variations", response_model=ImagesResponse, tags=["Variations"])
+async def create_image_variation(input_r: CreateImageVariationRequest, image: UploadFile = File(...)):
+    def make_generator():
+        g = torch.Generator(device=initializer.device)
+        return g.manual_seed(random.randint(0, 10_000_000))
+
+    req_pipe = app.state.REQUEST_PIPE
+    pass
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=5500)

aquiles_image-0.1.0/aquilesimage/models/__init__.py

@@ -0,0 +1,5 @@
+from .models import (ImageModel, ResponseFormat, OutputFormat, BackgroundType, QualityType, StyleType, 
+                    ImageSize, InputFidelity, ModerationLevel, ImageGenInputUsageDetails, ImageGenUsage,
+                    Image, ImagesResponse, ImageGenPartialImageEvent, ImagesUsage, ImageGenCompletedEvent, 
+                    ImageEditPartialImageEvent, ImageEditCompletedEvent, ImageGenStreamEvent, ImageEditStreamEvent,
+                    CreateImageRequest, CreateImageEditRequest, CreateImageVariationRequest, ConfigsServe)