fastapi-redis-utils 1.0.2__py3-none-any.whl

fastapi_redis_utils/__init__.py

@@ -0,0 +1,14 @@
+"""
+FastAPI Redis Utils
+
+Async Redis manager with FastAPI integration, connection pooling and retry mechanism.
+"""
+
+__version__ = "1.0.2"
+
+from .dependency import create_redis_client_dependencies
+from .manager import RedisManager
+from .models import BaseResultModel
+from .repository import BaseRepository
+
+__all__ = ["RedisManager", "create_redis_client_dependencies", "BaseRepository", "BaseResultModel"]

fastapi_redis_utils/dependency.py

@@ -0,0 +1,24 @@
+from collections.abc import Awaitable, Callable
+
+import redis.asyncio as redis
+
+from .manager import RedisManager
+
+
+def create_redis_client_dependencies(redis_manager: RedisManager) -> Callable[[], Awaitable[redis.Redis]]:
+    """
+    Create FastAPI dependency for Redis manager.
+
+    Args:
+        redis_manager: RedisManager instance
+
+    Returns:
+        get_redis_client function
+    """
+
+    async def get_redis_client() -> redis.Redis:
+        """Dependency to get Redis client instance with connection validation"""
+        await redis_manager.ensure_connection()
+        return redis_manager.get_client()
+
+    return get_redis_client

fastapi_redis_utils/manager.py

@@ -0,0 +1,137 @@
+import asyncio
+import logging
+from collections.abc import Callable
+from typing import Any
+
+import redis.asyncio as redis
+
+logger = logging.getLogger(__name__)
+
+
+class RedisManager:
+    """Async Redis manager with connection pooling and retry mechanism."""
+
+    def __init__(
+        self,
+        dsn: str,
+        max_connections: int = 20,
+        retry_attempts: int = 3,
+        retry_delay: float = 1.0,
+        socket_connect_timeout: int = 5,
+        socket_timeout: int = 5,
+    ):
+        """
+        Initialize Redis manager.
+
+        Args:
+            dsn: Redis connection DSN
+            max_connections: Maximum number of connections in the pool
+            retry_attempts: Number of retry attempts for connection
+            retry_delay: Base delay between retry attempts
+            socket_connect_timeout: Socket connection timeout in seconds
+            socket_timeout: Socket operation timeout in seconds
+        """
+        self.dsn = dsn
+        self.max_connections = max_connections
+        self.retry_attempts = retry_attempts
+        self.retry_delay = retry_delay
+        self.socket_connect_timeout = socket_connect_timeout
+        self.socket_timeout = socket_timeout
+
+        self.redis_client: redis.Redis | None = None
+        self._connection_pool: redis.ConnectionPool | None = None
+        self._is_connected: bool = False
+
+    async def connect(self) -> None:
+        """Create Redis connection with retry mechanism."""
+        for attempt in range(self.retry_attempts):
+            try:
+                logger.info(f"Attempting to connect to Redis (attempt {attempt + 1}/{self.retry_attempts})")
+
+                self._connection_pool = redis.ConnectionPool.from_url(
+                    self.dsn,
+                    decode_responses=True,
+                    max_connections=self.max_connections,
+                    retry_on_timeout=True,
+                    socket_connect_timeout=self.socket_connect_timeout,
+                    socket_timeout=self.socket_timeout,
+                )
+
+                self.redis_client = redis.Redis(connection_pool=self._connection_pool)
+
+                await self.redis_client.ping()
+                self._is_connected = True
+
+                logger.info("Successfully connected to Redis")
+                return
+
+            except Exception as e:
+                logger.error(f"Failed to connect to Redis (attempt {attempt + 1}): {e}")
+                if attempt < self.retry_attempts - 1:
+                    await asyncio.sleep(self.retry_delay * (attempt + 1))
+                else:
+                    self._is_connected = False
+                    raise ConnectionError(f"Failed to connect to Redis after {self.retry_attempts} attempts: {e}")
+
+    async def ensure_connection(self) -> None:
+        """Ensure Redis connection is available."""
+        if not self._is_connected:
+            await self.connect()
+
+    async def close(self) -> None:
+        """Close Redis connection and cleanup."""
+        self._is_connected = False
+        if self.redis_client:
+            try:
+                await self.redis_client.aclose()
+                logger.info("Redis connection closed")
+            except Exception as e:
+                logger.error(f"Error closing Redis connection: {e}")
+            finally:
+                self.redis_client = None
+
+        if self._connection_pool:
+            try:
+                await self._connection_pool.disconnect()
+                logger.info("Redis connection pool closed")
+            except Exception as e:
+                logger.error(f"Error closing Redis connection pool: {e}")
+            finally:
+                self._connection_pool = None
+
+    async def health_check(self) -> bool:
+        """
+        Check if Redis connection is healthy.
+
+        This method can be used for external monitoring/metrics collection.
+        """
+        if not self.redis_client or not self._is_connected:
+            return False
+
+        try:
+            await self.redis_client.ping()
+            return True
+        except Exception as e:
+            logger.exception(f"Redis health check failed: {e}")
+            self._is_connected = False
+            return False
+
+    def get_client(self) -> redis.Redis:
+        """Get Redis client instance with connection validation."""
+        if not self.redis_client or not self._is_connected:
+            raise RuntimeError("Redis client not initialized or disconnected. Call connect() first.")
+        return self.redis_client
+
+    async def execute_with_retry(self, operation: Callable, *args: Any, **kwargs: Any) -> Any:
+        """Execute Redis operation with retry mechanism."""
+        for attempt in range(self.retry_attempts):
+            try:
+                if not self._is_connected:
+                    await self.connect()
+                return await operation(*args, **kwargs)
+            except Exception as e:
+                logger.warning(f"Redis operation failed (attempt {attempt + 1}): {e}")
+                if attempt < self.retry_attempts - 1:
+                    await asyncio.sleep(self.retry_delay * (attempt + 1))
+                else:
+                    raise

fastapi_redis_utils/models.py

@@ -0,0 +1,11 @@
+import logging
+from abc import ABC, abstractmethod
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class BaseResultModel(ABC, BaseModel):
+    @abstractmethod
+    def set_id(self, id: str) -> None: ...

fastapi_redis_utils/repository.py

@@ -0,0 +1,180 @@
+import logging
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, ValidationError
+
+from .manager import RedisManager
+from .models import BaseResultModel
+
+logger = logging.getLogger(__name__)
+
+
+T = TypeVar("T", bound=BaseModel)
+CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel)
+UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)
+ResultSchemaType = TypeVar("ResultSchemaType", bound=BaseResultModel)
+
+
+class BaseRepository(Generic[CreateSchemaType, UpdateSchemaType, ResultSchemaType]):
+    def __init__(
+        self,
+        redis_manager: RedisManager,
+        create_model: type[CreateSchemaType],
+        update_model: type[UpdateSchemaType],
+        result_model: type[ResultSchemaType],
+        key_prefix: str | None = None,
+        default_ttl: int | None = None,
+    ):
+        self.redis_manager = redis_manager
+        self.create_model = create_model
+        self.update_model = update_model
+        self.result_model = result_model
+        self.key_prefix = key_prefix or f"{self.create_model.__name__.lower()}:"
+        self.default_ttl = default_ttl
+
+    def _make_key(self, key: str) -> str:
+        return f"{self.key_prefix}{key}"
+
+    def _serialize(self, data: T) -> str:
+        try:
+            return data.model_dump_json()
+        except Exception as e:
+            logger.error(f"Failed to serialize model: {e}")
+            raise ValueError("Failed to serialize model") from e
+
+    def _deserialize(self, data: str, model: type[T]) -> T:
+        try:
+            return model.model_validate_json(data)
+        except ValidationError as e:
+            logger.error(f"Failed to deserialize model: {e}")
+            raise ValueError("Failed to deserialize model") from e
+        except Exception as e:
+            logger.error(f"Unexpected error deserializing model: {e}")
+            raise ValueError("Failed to deserialize model") from e
+
+    def _create_result_model(self, data: CreateSchemaType, key: str) -> ResultSchemaType:
+        result_model = self.result_model(**data.model_dump())
+        result_model.set_id(key)
+        return result_model
+
+    async def create(self, key: str, data: CreateSchemaType, ttl: int | None = None) -> ResultSchemaType:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        serialized_data = self._serialize(data)
+        ttl_to_use = ttl if ttl is not None else self.default_ttl
+        if ttl_to_use is not None:
+            await redis_client.setex(full_key, ttl_to_use, serialized_data)
+        else:
+            await redis_client.set(full_key, serialized_data)
+        logger.debug(f"Created record with key: {full_key}")
+        return self._create_result_model(data, key)
+
+    async def get(self, key: str) -> ResultSchemaType | None:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        data = await redis_client.get(full_key)
+        if data is None:
+            return None
+
+        try:
+            stored_model = self._deserialize(data, self.create_model)
+            return self._create_result_model(stored_model, key)
+        except ValueError as e:
+            logger.error(f"Failed to deserialize data for key {full_key}: {e}")
+            return None
+
+    async def update(
+        self,
+        key: str,
+        data: UpdateSchemaType,
+        ttl: int | None = None,
+    ) -> ResultSchemaType | None:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        existing_data = await redis_client.get(full_key)
+        if existing_data is None:
+            return None
+
+        try:
+            existing_model = self._deserialize(existing_data, self.create_model)
+            update_dict = data.model_dump(exclude_unset=True)
+            updated_dict = existing_model.model_dump()
+            updated_dict.update(update_dict)
+            updated_model = self.create_model(**updated_dict)
+            serialized_data = self._serialize(updated_model)
+            ttl_to_use = ttl if ttl is not None else self.default_ttl
+            if ttl_to_use is not None:
+                await redis_client.setex(full_key, ttl_to_use, serialized_data)
+            else:
+                await redis_client.set(full_key, serialized_data)
+            logger.debug(f"Updated record with key: {full_key}")
+            return self._create_result_model(updated_model, key)
+        except ValueError as e:
+            logger.error(f"Failed to update data for key {full_key}: {e}")
+            return None
+
+    async def delete(self, key: str) -> bool:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        deleted: int = await redis_client.delete(full_key)
+        logger.debug(f"Deleted record with key: {full_key}")
+        return deleted > 0
+
+    async def exists(self, key: str) -> bool:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        return bool(await redis_client.exists(full_key))
+
+    async def list(self, pattern: str = "*", limit: int | None = None) -> list[ResultSchemaType]:
+        redis_client = await self.redis_manager.get_client()
+        full_pattern = f"{self.key_prefix}{pattern}"
+        keys = await redis_client.keys(full_pattern)
+        if limit:
+            keys = keys[:limit]
+
+        if not keys:
+            return []
+
+        pipeline = await redis_client.pipeline()
+        for key in keys:
+            await pipeline.get(key)
+        values = await pipeline.execute()
+        result = []
+        for key, value in zip(keys, values, strict=False):
+            if value is not None:
+                try:
+                    clean_key = key.decode() if isinstance(key, bytes) else key
+                    stored_model = self._deserialize(value, self.create_model)
+                    model_instance = self._create_result_model(stored_model, clean_key)
+                    result.append(model_instance)
+                except ValueError as e:
+                    logger.warning(f"Failed to deserialize data for key {clean_key}: {e}")
+                    continue
+        return result
+
+    async def count(self, pattern: str = "*") -> int:
+        redis_client = await self.redis_manager.get_client()
+        full_pattern = f"{self.key_prefix}{pattern}"
+        keys = await redis_client.keys(full_pattern)
+        return len(keys)
+
+    async def set_ttl(self, key: str, ttl: int) -> bool:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        return bool(await redis_client.expire(full_key, ttl))
+
+    async def get_ttl(self, key: str) -> int | None:
+        redis_client = await self.redis_manager.get_client()
+        full_key = self._make_key(key)
+        ttl = await redis_client.ttl(full_key)
+        return ttl if ttl != -2 else None
+
+    async def clear(self, pattern: str = "*") -> int:
+        redis_client = await self.redis_manager.get_client()
+        full_pattern = f"{self.key_prefix}{pattern}"
+        keys = await redis_client.keys(full_pattern)
+        if not keys:
+            return 0
+        deleted: int = await redis_client.delete(*keys)
+        logger.info(f"Cleared {deleted} records")
+        return deleted

fastapi_redis_utils-1.0.2.dist-info/METADATA

@@ -0,0 +1,394 @@
+Metadata-Version: 2.4
+Name: fastapi-redis-utils
+Version: 1.0.2
+Summary: Async Redis manager with FastAPI integration, connection pooling and retry mechanism
+Project-URL: Homepage, https://github.com/serafinovsky/fastapi-redis-utils
+Project-URL: Documentation, https://github.com/serafinovsky/fastapi-redis-utils#readme
+Project-URL: Repository, https://github.com/serafinovsky/fastapi-redis-utils
+Project-URL: Issues, https://github.com/serafinovsky/fastapi-redis-utils/issues
+Author-email: Your Name <your.email@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: async,connection-pool,dependency-injection,fastapi,redis,utils
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: redis>=6.2.0
+Description-Content-Type: text/markdown
+
+# FastAPI Redis Utils
+
+Async Redis manager with FastAPI integration, connection pooling and retry mechanism.
+
+## Features
+
+- 🔄 **Async-first** - Full async/await support
+- 🏊 **Connection pooling** - Efficient connection management
+- 🔁 **Retry mechanism** - Automatic retries on failures
+- ⚡ **FastAPI integration** - Ready-to-use FastAPI dependencies
+- 🏥 **Health check** - Built-in connection status monitoring
+- 🛡️ **Type safety** - Full type hints support
+- 📦 **BaseRepository** - Base repository class with Pydantic model support
+
+## Documentation
+
+- 📖 **[Usage Guide](USAGE.md)** - Detailed usage examples and advanced features
+- 🚀 **[FastAPI Integration Example](examples/fastapi_integration.py)** - Complete FastAPI application with Redis integration
+
+## Installation
+
+### From PyPI
+
+```bash
+uv add fastapi-redis-utils
+```
+
+### From Git repository
+
+```bash
+uv add git+https://github.com/serafinovsky/fastapi-redis-utils.git
+```
+
+### For development
+
+```bash
+git clone https://github.com/serafinovsky/fastapi-redis-utils.git
+cd fastapi-redis-utils
+uv sync --dev
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import asyncio
+from fastapi_redis_utils import RedisManager
+
+async def main():
+    # Create manager
+    redis_manager = RedisManager(
+        dsn="redis://localhost:6379",
+        max_connections=20,
+        retry_attempts=3
+    )
+
+    # Connect
+    await redis_manager.connect()
+
+    # Use
+    client = redis_manager.get_client()
+    await client.set("key", "value")
+    value = await client.get("key")
+
+    # Close
+    await redis_manager.close()
+
+asyncio.run(main())
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI, Depends
+from fastapi_redis_utils import RedisManager, create_redis_client_dependencies
+import redis.asyncio as redis
+
+app = FastAPI()
+
+# Create Redis manager
+redis_manager = RedisManager(
+    dsn="redis://localhost:6379"
+)
+
+# Create FastAPI dependency
+get_redis_client = create_redis_client_dependencies(redis_manager)
+
+@app.on_event("startup")
+async def startup_event():
+    """Connect to Redis on application startup"""
+    await redis_manager.connect()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Close connection on application shutdown"""
+    await redis_manager.close()
+
+@app.get("/cache/{key}")
+async def get_cached_data(key: str, redis_client: redis.Redis = Depends(get_redis_client)):
+    """Get data from cache"""
+    value = await redis_client.get(key)
+    return {"key": key, "value": value}
+
+@app.post("/cache/{key}")
+async def set_cached_data(
+    key: str,
+    value: str,
+    redis_client: redis.Redis = Depends(get_redis_client)
+):
+    """Save data to cache"""
+    await redis_client.set(key, value)
+    return {"key": key, "value": value, "status": "saved"}
+
+@app.get("/health")
+async def health_check():
+    """Check Redis connection status"""
+    is_healthy = await redis_manager.health_check()
+    return {"redis_healthy": is_healthy}
+```
+
+### Using BaseRepository with Separate Create and Update Schemas
+
+```python
+import uuid
+from uuid import UUID
+from fastapi import HTTPException, status
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from fastapi_redis_utils import BaseRepository, RedisManager, BaseResultModel
+
+class CreateDemoSchema(BaseModel):
+    field1: str
+    field2: str
+
+
+class UpdateDemoSchema(BaseModel):
+    field1: str | None = None
+    field2: str | None = None
+
+
+class DemoSchema(BaseResultModel):
+    id: str | None = None
+    field1: str
+    field2: str
+
+    def set_id(self, id: str) -> None:
+        self.id = id
+
+
+class DemoRepository(BaseRepository[CreateDemoSchema, UpdateDemoSchema, DemoSchema]):
+    pass
+
+
+demo_crud = DemoRepository(redis_manager, CreateDemoSchema, UpdateDemoSchema, DemoSchema)
+
+
+@app.post("/repo/", response_model=DemoSchema, status_code=status.HTTP_201_CREATED)
+async def create_demo(demo_model: CreateDemoSchema) -> DemoSchema:
+    """Create a new demo record."""
+    demo_id = str(uuid.uuid4())
+    return await demo_crud.create(demo_id, demo_model)
+
+
+@app.get("/repo/{demo_id}", response_model=DemoSchema)
+async def get_demo(demo_id: UUID) -> DemoSchema:
+    """Get a demo record by ID."""
+    demo = await demo_crud.get(str(demo_id))
+    if demo is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Demo record with ID '{demo_id}' not found",
+        )
+
+    return demo
+
+
+@app.get("/repo/", response_model=list[DemoSchema])
+async def list_demos(limit: int = 100) -> list[DemoSchema]:
+    """List all demo records"""
+    return await demo_crud.list(limit=limit)
+
+
+@app.put("/repo/{demo_id}", response_model=DemoSchema)
+async def update_demo(demo_id: UUID, demo_update: UpdateDemoSchema) -> DemoSchema:
+    """Update a demo record."""
+    updated_demo = await demo_crud.update(str(demo_id), demo_update)
+    if updated_demo is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Demo record with ID '{demo_id}' not found",
+        )
+    return updated_demo
+
+
+@app.delete("/repo/{demo_id}")
+async def delete_demo(demo_id: UUID) -> dict[str, UUID]:
+    """Delete a demo record."""
+    deleted = await demo_crud.delete(str(demo_id))
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Demo record with ID '{demo_id}' not found",
+        )
+    return {"id": demo_id}
+
+
+@app.get("/repo/{demo_id}/exists")
+async def check_demo_exists(demo_id: UUID) -> dict[str, UUID | bool]:
+    """Check if a demo record exists."""
+    exists = await demo_crud.exists(str(demo_id))
+    return {"id": demo_id, "exists": exists}
+```
+
+### Executing Operations with Retry
+
+```python
+async def complex_operation():
+    async def operation():
+        client = redis_manager.get_client()
+        # Complex Redis operation
+        result = await client.execute_command("COMPLEX_COMMAND")
+        return result
+
+    # Automatic retries on failures
+    result = await redis_manager.execute_with_retry(operation)
+    return result
+```
+
+## Configuration
+
+### RedisManager Parameters
+
+| Parameter                | Type  | Default | Description                           |
+| ------------------------ | ----- | ------- | ------------------------------------- |
+| `dsn`                    | str   | `-`     | DSN for Redis connection              |
+| `max_connections`        | int   | `20`    | Maximum number of connections in pool |
+| `retry_attempts`         | int   | `3`     | Number of reconnection attempts       |
+| `retry_delay`            | float | `1.0`   | Base delay between attempts (seconds) |
+| `socket_connect_timeout` | int   | `5`     | Socket connection timeout (seconds)   |
+| `socket_timeout`         | int   | `5`     | Socket operation timeout (seconds)    |
+
+## API Reference
+
+### RedisManager
+
+Main class for managing Redis connections.
+
+#### Methods
+
+- `connect()` - Connect to Redis with retry mechanism
+- `ensure_connection()` - Ensure connection availability
+- `close()` - Close connection and cleanup resources
+- `health_check()` - Check connection status
+- `get_client()` - Get Redis client
+- `execute_with_retry()` - Execute operations with retry
+
+### create_redis_client_dependencies
+
+Creates FastAPI dependency for getting Redis client.
+
+### BaseRepository
+
+Base repository class for working with Pydantic models in Redis. Supports separate schemas for create, update, and result operations with partial updates.
+
+#### Generic Parameters
+
+- `CreateSchemaType` - Pydantic model for create operations
+- `UpdateSchemaType` - Pydantic model for update operations (all fields optional)
+- `ResultSchemaType` - Pydantic model for result operations (must inherit from BaseResultModel)
+
+#### Core Methods
+
+- `create(key, data: CreateSchemaType, ttl=None)` - Create record
+- `get(key)` - Get record (returns ResultSchemaType)
+- `update(key, data: UpdateSchemaType, ttl=None)` - Update record with partial update (only set fields)
+- `delete(key)` - Delete record
+- `exists(key)` - Check record existence
+- `list(pattern="*", limit=None)` - Get list of records
+- `count(pattern="*")` - Count records
+- `set_ttl(key, ttl)` - Set TTL
+- `get_ttl(key)` - Get TTL
+- `clear(pattern="*")` - Clear records
+
+#### Partial Update Feature
+
+The `update` method performs partial updates - only fields that are set in the update schema will be modified. Fields with `None` values are ignored.
+
+## Development
+
+### Install development dependencies
+
+```bash
+uv sync --dev
+```
+
+### Run tests
+
+```bash
+uv run pytest
+```
+
+### Code checks
+
+```bash
+uv run ruff check .
+uv run mypy .
+```
+
+### Build package
+
+```bash
+uv run build
+```
+
+### Makefile Commands
+
+The project includes convenient Makefile commands for development:
+
+```bash
+# Main commands
+make install          # Install development dependencies
+make test            # Run tests
+make lint            # Check code with linters
+make format          # Format code
+make build           # Build package
+make clean           # Clean temporary files
+
+# Version management
+make version         # Show current version
+
+# Publishing
+make publish         # Create and push git tag with current version
+make publish-dry-run # Show what would be done without creating tag
+make release         # Full release: build, test, tag and push
+
+# Additional commands
+make tags            # List all git tags
+make check           # Full pre-commit check
+make example-fastapi # Run FastAPI example
+```
+
+### Release Workflow
+
+1. Update version in `fastapi_redis_utils/__init__.py`
+2. Run full release: `make release`
+3. Or step by step:
+
+```bash
+make test          # Run tests
+make build         # Build package
+make publish       # Create and push tag
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request

fastapi_redis_utils-1.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+fastapi_redis_utils/__init__.py,sha256=nGOleNFxSV-3zpiWSxHyGJPuDyC16IxciBSlQBw2zjM,406
+fastapi_redis_utils/dependency.py,sha256=8OW5BMNUew3-54T3GyC_d-n8wDpL606yMxHlqVNEaJ0,642
+fastapi_redis_utils/manager.py,sha256=u2BLJm3MBlpXgzr2JGqfqWW0xEZklIZQbxH2HNXASmo,5158
+fastapi_redis_utils/models.py,sha256=pCfaYUz6l9FTiMlwx7ixaSLZszxQrQdrp-rKhvzLhb8,225
+fastapi_redis_utils/repository.py,sha256=pj0YIxhDfJEjgmLPJNbfxFnT6maHzH96BgGXMciG4VA,7295
+fastapi_redis_utils-1.0.2.dist-info/METADATA,sha256=jKmFx_Hb5OIyrbGB2Akej4AoaiQJ21tpjaHvH6SIOic,11382
+fastapi_redis_utils-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastapi_redis_utils-1.0.2.dist-info/licenses/LICENSE,sha256=KvgfMbLqWT7Xf9NBazC5Ip8y_llTK4_eb5rjUzuUKSo,1081
+fastapi_redis_utils-1.0.2.dist-info/RECORD,,

fastapi_redis_utils-1.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fastapi_redis_utils-1.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 FastAPI Redis Connection
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.