tiny-object-storage 0.1.1__py3-none-any.whl

tiny_object_storage/services/object_service.py

@@ -0,0 +1,79 @@
+from typing import Any, BinaryIO
+
+from tiny_object_storage.logging_config import get_logger
+from tiny_object_storage.storage.base import BaseStorage, StoredObject
+
+
+class ObjectService:
+    # Handle object-related business logic.
+
+    def __init__(self, storage: BaseStorage):
+        # Store the configured storage backend.
+        self.storage = storage
+        self.logger = get_logger("tiny_object_storage.services.object")
+
+    def put_object(
+        self,
+        bucket_name: str,
+        object_key: str,
+        data: bytes | BinaryIO,
+        content_type: str | None = None,
+    ) -> dict[str, Any]:
+        # Store an object and return its metadata.
+        self.logger.info(
+            "Uploading object bucket=%s key=%s content_type=%s",
+            bucket_name,
+            object_key,
+            content_type,
+        )
+        metadata = self.storage.put_object(
+            bucket_name=bucket_name,
+            object_key=object_key,
+            data=data,
+            content_type=content_type,
+        )
+        self.logger.info(
+            "Object uploaded bucket=%s key=%s size=%s etag=%s",
+            bucket_name,
+            object_key,
+            metadata["size"],
+            metadata["etag"],
+        )
+        return metadata
+
+    def get_object(self, bucket_name: str, object_key: str) -> StoredObject:
+        # Return a stored object from the backend.
+        self.logger.info("Downloading object bucket=%s key=%s", bucket_name, object_key)
+        stored_object = self.storage.get_object(bucket_name=bucket_name, object_key=object_key)
+        self.logger.info(
+            "Object downloaded bucket=%s key=%s size=%s",
+            bucket_name,
+            object_key,
+            stored_object.metadata["size"],
+        )
+        return stored_object
+
+    def delete_object(self, bucket_name: str, object_key: str) -> None:
+        # Delete an object from the backend.
+        self.logger.info("Deleting object bucket=%s key=%s", bucket_name, object_key)
+        self.storage.delete_object(bucket_name=bucket_name, object_key=object_key)
+        self.logger.info("Object deleted bucket=%s key=%s", bucket_name, object_key)
+
+    def list_objects(self, bucket_name: str) -> list[dict[str, Any]]:
+        # Return all objects for the requested bucket.
+        self.logger.info("Listing objects bucket=%s", bucket_name)
+        objects = self.storage.list_objects(bucket_name=bucket_name)
+        self.logger.info("Objects listed bucket=%s count=%s", bucket_name, len(objects))
+        return objects
+
+    def object_exists(self, bucket_name: str, object_key: str) -> bool:
+        # Return whether the given object exists.
+        self.logger.debug("Checking object existence bucket=%s key=%s", bucket_name, object_key)
+        exists = self.storage.object_exists(bucket_name=bucket_name, object_key=object_key)
+        self.logger.debug(
+            "Object existence checked bucket=%s key=%s exists=%s",
+            bucket_name,
+            object_key,
+            exists,
+        )
+        return exists

tiny_object_storage/storage/base.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, BinaryIO
+
+
+@dataclass(slots=True)
+class StoredObject:
+    # Represent an object returned from the storage backend.
+    bucket_name: str
+    object_key: str
+    data: bytes
+    metadata: dict[str, Any]
+
+
+class BaseStorage(ABC):
+    # Define the storage backend contract.
+
+    @abstractmethod
+    def create_bucket(self, bucket_name: str) -> None:
+        # Create a new bucket.
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_bucket(self, bucket_name: str) -> None:
+        # Delete an existing bucket.
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_buckets(self) -> list[dict[str, Any]]:
+        # Return all available buckets.
+        raise NotImplementedError
+
+    @abstractmethod
+    def bucket_exists(self, bucket_name: str) -> bool:
+        # Check whether a bucket exists.
+        raise NotImplementedError
+
+    @abstractmethod
+    def put_object(
+        self,
+        bucket_name: str,
+        object_key: str,
+        data: bytes | BinaryIO,
+        content_type: str | None = None,
+    ) -> dict[str, Any]:
+        # Store an object and return its metadata.
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_object(self, bucket_name: str, object_key: str) -> StoredObject:
+        # Read and return an object.
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_object(self, bucket_name: str, object_key: str) -> None:
+        # Delete an object.
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_objects(self, bucket_name: str) -> list[dict[str, Any]]:
+        # Return all objects in a bucket.
+        raise NotImplementedError
+
+    @abstractmethod
+    def object_exists(self, bucket_name: str, object_key: str) -> bool:
+        # Check whether an object exists.
+        raise NotImplementedError

tiny_object_storage/storage/filesystem.py

@@ -0,0 +1,318 @@
+import mimetypes
+from pathlib import Path
+from typing import Any, BinaryIO
+
+from tiny_object_storage.core.errors import (
+    BucketAlreadyExistsError,
+    BucketNotEmptyError,
+    BucketNotFoundError,
+    ObjectNotFoundError,
+)
+from tiny_object_storage.core.utils import (
+    bucket_path,
+    compute_etag,
+    metadata_dir_path,
+    metadata_file_path,
+    object_path,
+    read_json,
+    utc_now_iso,
+    validate_bucket_name,
+    validate_object_key,
+    write_json,
+)
+from tiny_object_storage.logging_config import get_logger
+from tiny_object_storage.storage.base import BaseStorage, StoredObject
+
+
+class FilesystemStorage(BaseStorage):
+    # Implement the storage backend using the local filesystem.
+
+    def __init__(self, base_dir: str | Path):
+        # Initialize the storage backend.
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self.logger = get_logger("tiny_object_storage.storage.filesystem")
+        self.logger.info("Filesystem storage initialized base_dir=%s", self.base_dir)
+
+    def create_bucket(self, bucket_name: str) -> None:
+        # Create a new bucket as a directory with a metadata subdirectory.
+        validate_bucket_name(bucket_name)
+        path = bucket_path(self.base_dir, bucket_name)
+
+        if path.exists():
+            self.logger.warning("Bucket already exists bucket=%s", bucket_name)
+            raise BucketAlreadyExistsError(f"Bucket '{bucket_name}' already exists.")
+
+        path.mkdir(parents=True, exist_ok=False)
+        metadata_dir_path(self.base_dir, bucket_name).mkdir(parents=True, exist_ok=True)
+
+        bucket_metadata = {
+            "name": bucket_name,
+            "created_at": utc_now_iso(),
+        }
+        write_json(path / ".bucket.meta.json", bucket_metadata)
+
+        self.logger.info("Bucket created bucket=%s path=%s", bucket_name, path)
+
+    def delete_bucket(self, bucket_name: str) -> None:
+        # Delete an empty bucket.
+        path = self._require_bucket(bucket_name)
+
+        entries = [
+            entry for entry in path.iterdir() if entry.name not in {".meta", ".bucket.meta.json"}
+        ]
+        if entries:
+            self.logger.warning("Bucket not empty bucket=%s", bucket_name)
+            raise BucketNotEmptyError(f"Bucket '{bucket_name}' is not empty.")
+
+        meta_dir = path / ".meta"
+        if meta_dir.exists():
+            for meta_file in meta_dir.iterdir():
+                meta_file.unlink()
+            meta_dir.rmdir()
+
+        bucket_meta_file = path / ".bucket.meta.json"
+        if bucket_meta_file.exists():
+            bucket_meta_file.unlink()
+
+        path.rmdir()
+        self.logger.info("Bucket deleted bucket=%s path=%s", bucket_name, path)
+
+    def list_buckets(self) -> list[dict[str, Any]]:
+        # List all buckets stored under the base directory.
+        buckets: list[dict[str, Any]] = []
+
+        for path in sorted(self.base_dir.iterdir(), key=lambda item: item.name):
+            if not path.is_dir():
+                continue
+
+            bucket_meta_file = path / ".bucket.meta.json"
+            created_at = None
+            if bucket_meta_file.exists():
+                try:
+                    created_at = read_json(bucket_meta_file).get("created_at")
+                except Exception:
+                    self.logger.exception("Failed to read bucket metadata bucket=%s", path.name)
+
+            buckets.append(
+                {
+                    "name": path.name,
+                    "created_at": created_at,
+                }
+            )
+
+        self.logger.info("Buckets listed count=%s", len(buckets))
+        return buckets
+
+    def bucket_exists(self, bucket_name: str) -> bool:
+        # Return whether the given bucket exists.
+        validate_bucket_name(bucket_name)
+        exists = bucket_path(self.base_dir, bucket_name).is_dir()
+        self.logger.debug("Bucket existence checked bucket=%s exists=%s", bucket_name, exists)
+        return exists
+
+    def put_object(
+        self,
+        bucket_name: str,
+        object_key: str,
+        data: bytes | BinaryIO,
+        content_type: str | None = None,
+    ) -> dict[str, Any]:
+        # Write object data to disk and persist metadata.
+        self._require_bucket(bucket_name)
+        validate_object_key(object_key)
+
+        payload = self._read_bytes(data)
+        object_file_path = object_path(self.base_dir, bucket_name, object_key)
+        object_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        object_file_path.write_bytes(payload)
+
+        resolved_content_type = (
+            content_type or mimetypes.guess_type(object_key)[0] or "application/octet-stream"
+        )
+        now = utc_now_iso()
+
+        previous_metadata = self._read_metadata_if_exists(bucket_name, object_key)
+        created_at = previous_metadata.get("created_at", now) if previous_metadata else now
+
+        metadata = {
+            "bucket_name": bucket_name,
+            "object_key": object_key,
+            "size": len(payload),
+            "content_type": resolved_content_type,
+            "etag": compute_etag(payload),
+            "created_at": created_at,
+            "updated_at": now,
+        }
+
+        meta_path = metadata_file_path(self.base_dir, bucket_name, object_key)
+        write_json(meta_path, metadata)
+
+        self.logger.info(
+            "Object stored bucket=%s key=%s size=%s path=%s",
+            bucket_name,
+            object_key,
+            len(payload),
+            object_file_path,
+        )
+        return metadata
+
+    def get_object(self, bucket_name: str, object_key: str) -> StoredObject:
+        # Read an object from disk and return its bytes and metadata.
+        self._require_bucket(bucket_name)
+        validate_object_key(object_key)
+
+        object_file_path = object_path(self.base_dir, bucket_name, object_key)
+        if not object_file_path.is_file():
+            self.logger.warning("Object not found bucket=%s key=%s", bucket_name, object_key)
+            raise ObjectNotFoundError(
+                f"Object '{object_key}' was not found in bucket '{bucket_name}'."
+            )
+
+        data = object_file_path.read_bytes()
+        metadata = self._read_metadata_if_exists(bucket_name, object_key)
+        if not metadata:
+            metadata = {
+                "bucket_name": bucket_name,
+                "object_key": object_key,
+                "size": len(data),
+                "content_type": mimetypes.guess_type(object_key)[0] or "application/octet-stream",
+                "etag": compute_etag(data),
+                "created_at": None,
+                "updated_at": None,
+            }
+
+        self.logger.info("Object read bucket=%s key=%s size=%s", bucket_name, object_key, len(data))
+        return StoredObject(
+            bucket_name=bucket_name,
+            object_key=object_key,
+            data=data,
+            metadata=metadata,
+        )
+
+    def delete_object(self, bucket_name: str, object_key: str) -> None:
+        # Delete an object and its metadata.
+        self._require_bucket(bucket_name)
+        validate_object_key(object_key)
+
+        object_file_path = object_path(self.base_dir, bucket_name, object_key)
+        if not object_file_path.is_file():
+            self.logger.warning(
+                "Object not found for deletion bucket=%s key=%s", bucket_name, object_key
+            )
+            raise ObjectNotFoundError(
+                f"Object '{object_key}' was not found in bucket '{bucket_name}'."
+            )
+
+        object_file_path.unlink()
+
+        meta_path = metadata_file_path(self.base_dir, bucket_name, object_key)
+        if meta_path.exists():
+            meta_path.unlink()
+
+        self._cleanup_empty_parent_directories(bucket_name=bucket_name, object_key=object_key)
+
+        self.logger.info("Object deleted bucket=%s key=%s", bucket_name, object_key)
+
+    def list_objects(self, bucket_name: str) -> list[dict[str, Any]]:
+        # List all objects in a bucket recursively.
+        bucket_dir = self._require_bucket(bucket_name)
+        results: list[dict[str, Any]] = []
+
+        for path in sorted(bucket_dir.rglob("*"), key=lambda item: str(item)):
+            if not path.is_file():
+                continue
+
+            if path.name == ".bucket.meta.json":
+                continue
+
+            if ".meta" in path.parts:
+                continue
+
+            object_key = str(path.relative_to(bucket_dir)).replace("\\", "/")
+            metadata = self._read_metadata_if_exists(bucket_name, object_key)
+
+            if not metadata:
+                data = path.read_bytes()
+                metadata = {
+                    "bucket_name": bucket_name,
+                    "object_key": object_key,
+                    "size": len(data),
+                    "content_type": mimetypes.guess_type(object_key)[0]
+                    or "application/octet-stream",
+                    "etag": compute_etag(data),
+                    "created_at": None,
+                    "updated_at": None,
+                }
+
+            results.append(metadata)
+
+        self.logger.info("Objects listed bucket=%s count=%s", bucket_name, len(results))
+        return results
+
+    def object_exists(self, bucket_name: str, object_key: str) -> bool:
+        # Return whether the given object exists.
+        self._require_bucket(bucket_name)
+        validate_object_key(object_key)
+
+        exists = object_path(self.base_dir, bucket_name, object_key).is_file()
+        self.logger.debug(
+            "Object existence checked bucket=%s key=%s exists=%s",
+            bucket_name,
+            object_key,
+            exists,
+        )
+        return exists
+
+    def _require_bucket(self, bucket_name: str) -> Path:
+        # Return the bucket path or raise if the bucket does not exist.
+        validate_bucket_name(bucket_name)
+        path = bucket_path(self.base_dir, bucket_name)
+
+        if not path.is_dir():
+            self.logger.warning("Bucket not found bucket=%s", bucket_name)
+            raise BucketNotFoundError(f"Bucket '{bucket_name}' does not exist.")
+
+        return path
+
+    def _read_bytes(self, data: bytes | BinaryIO) -> bytes:
+        # Normalize supported input types into bytes.
+        if isinstance(data, bytes):
+            return data
+
+        return data.read()
+
+    def _read_metadata_if_exists(self, bucket_name: str, object_key: str) -> dict[str, Any] | None:
+        # Read metadata if the file exists.
+        meta_path = metadata_file_path(self.base_dir, bucket_name, object_key)
+        if not meta_path.exists():
+            return None
+
+        try:
+            metadata = read_json(meta_path)
+            self.logger.debug(
+                "Metadata read bucket=%s key=%s path=%s", bucket_name, object_key, meta_path
+            )
+            return metadata
+        except Exception:
+            self.logger.exception(
+                "Failed to read metadata bucket=%s key=%s path=%s",
+                bucket_name,
+                object_key,
+                meta_path,
+            )
+            return None
+
+    def _cleanup_empty_parent_directories(self, bucket_name: str, object_key: str) -> None:
+        # Remove empty object directories after deletion.
+        bucket_dir = bucket_path(self.base_dir, bucket_name)
+        object_file_path = object_path(self.base_dir, bucket_name, object_key)
+
+        current = object_file_path.parent
+        while current != bucket_dir and current.exists():
+            if any(current.iterdir()):
+                break
+            current.rmdir()
+            self.logger.debug("Removed empty directory path=%s", current)
+            current = current.parent

tiny_object_storage-0.1.1.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: tiny-object-storage
+Version: 0.1.1
+Summary: A lightweight S3-compatible object storage server for local development and learning.
+Author: Ehsan Bitaraf
+License: MIT
+Project-URL: Homepage, https://github.com/EhsanBitaraf/tiny-object-storage
+Project-URL: Repository, https://github.com/EhsanBitaraf/tiny-object-storage
+Project-URL: Bug Tracker, https://github.com/EhsanBitaraf/tiny-object-storage/issues
+Keywords: s3,object-storage,minio,aws-s3,emulator,s3-compatible,mock,testing,fastapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi<1.0.0,>=0.115.0
+Requires-Dist: uvicorn[standard]<1.0.0,>=0.30.0
+Requires-Dist: pydantic<3.0.0,>=2.8.0
+Requires-Dist: pydantic-settings<3.0.0,>=2.4.0
+Requires-Dist: python-dotenv<2.0.0,>=1.0.1
+Requires-Dist: python-multipart<1.0.0,>=0.0.9
+Provides-Extra: dev
+Requires-Dist: pytest<9.0.0,>=8.3.0; extra == "dev"
+Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == "dev"
+Requires-Dist: httpx<1.0.0,>=0.27.0; extra == "dev"
+Requires-Dist: ruff<1.0.0,>=0.6.0; extra == "dev"
+Requires-Dist: mypy<2.0.0,>=1.11.0; extra == "dev"
+Requires-Dist: bandit<2.0.0,>=1.7.9; extra == "dev"
+Requires-Dist: safety<4.0.0,>=3.2.0; extra == "dev"
+Requires-Dist: pre-commit<4.0.0,>=3.8.0; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+  <img src="assets/logo.png" alt="tiny-object-storage logo" width="180" height="auto" />
+  <h1>🪣 tiny-object-storage</h1>
+  <p><i>A lightweight, S3-compatible object storage server for local development, testing, and learning.</i></p>
+
+[![Python](https://img.shields.io/badge/Python-3.11+-blue.svg?logo=python&logoColor=white)](https://www.python.org)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.115+-009688.svg?logo=fastapi&logoColor=white)](https://fastapi.tiangolo.com)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Mypy Strict](https://img.shields.io/badge/mypy-strict-success.svg)](https://mypy.readthedocs.io/en/stable/)
+[![Security: Bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![Coverage: 91%](https://img.shields.io/badge/Coverage-91%25-brightgreen.svg)](https://pytest-cov.readthedocs.io/en/latest/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+---
+
+## 📖 Overview
+
+`tiny-object-storage` is a fast, minimalistic object storage server written in Python using FastAPI. It acts as a local emulator that mimics the core functionality of Amazon S3, allowing developers to test S3-integrated applications locally without relying on external cloud services or heavy containers like MinIO.
+
+## ✨ Features
+
+- **S3 Compatibility**: Supports core S3 XML responses and basic HTTP methods (`GET`, `PUT`, `HEAD`, `DELETE`).
+- **Bucket Management**: Create, list, and delete buckets.
+- **Object Operations**: Upload, download, metadata lookup, listing (`list-type=2`), and deletion.
+- **Persistent Storage**: Filesystem-based persistence with dedicated metadata and data separation.
+- **Developer Experience**: Interactive Swagger UI and OpenAPI schema built-in.
+- **Enterprise Code Quality**: Enforced static typing (Mypy strict), linting (Ruff), and security analysis (Bandit).
+- **Flexible Configuration**: Configurable via CLI arguments, environment variables, or `.env` files.
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+**From PyPI (Recommended)**
+Install the package globally or in a virtual environment using `pip`:
+
+```bash
+pip install tiny-object-storage
+```
+
+**From Source (Development)**
+Clone the repository and install it in a virtual environment:
+
+```bash
+git clone https://github.com/EhsanBitaraf/tiny-object-storage.git
+cd tiny-object-storage
+python -m venv .venv
+
+# On Linux/macOS:
+source .venv/bin/activate
+# On Windows:
+.venv\Scripts\activate
+
+# Install the application and development dependencies
+pip install -e ".[dev]"
+```
+
+### Running the Server
+
+Start the server using the built-in CLI:
+
+```bash
+tos-server
+```
+
+Or run it directly with `uvicorn`:
+```bash
+uvicorn tiny_object_storage.main:app --reload --host 0.0.0.0 --port 9000
+```
+
+---
+
+## ⚙️ Configuration
+
+The server reads configuration in the following priority (highest to lowest):
+1. **Command-line arguments**
+2. **Environment variables**
+3. **`.env` file**
+
+### CLI Usage Examples
+
+```bash
+# View all available options
+tos-server --help
+
+# Load from a specific .env file
+tos-server --env-file .env.custom
+
+# Override host and port
+tos-server --host 127.0.0.1 --port 9001 --reload
+
+# Customize storage directories and log level
+tos-server --data-dir ./storage_data --log-dir ./logs --log-level debug
+```
+
+---
+
+## 🔌 S3 Client Compatibility
+
+`tiny-object-storage` acts as a local emulator and has been successfully verified against the following official SDKs and tools:
+
+- **MinIO Python SDK**
+- **Boto3 (AWS SDK for Python)**
+- **AWS CLI**
+
+> **Note:** For official SDKs to interact locally, configure them with `secure=False` (or `--no-verify-ssl`) and point the `endpoint_url` to `http://127.0.0.1:9000` with any dummy credentials.
+
+Sample scripts for verifying SDK interactions are included in the repository root (e.g., `test_boto3_sdk.py`, `test_minio_sdk.py`).
+
+---
+
+## 🛠 Testing & Code Quality
+
+The project includes an extensive test suite built with `pytest` achieving **100% test pass rate** over 63 edge-case scenarios.
+
+### Running Tests
+
+```bash
+pytest
+```
+*(Optionally, use `pytest --cov=src` to generate a coverage report).*
+
+### Code Quality Tools
+
+We use `pre-commit` to maintain our code quality. The suite includes:
+- **Ruff**: For ultra-fast linting and code formatting.
+- **Mypy**: For strict static type checking.
+- **Bandit**: For security vulnerability scanning.
+
+To run checks manually on all files:
+```bash
+pre-commit run --all-files
+```
+
+---
+
+## 🌐 API Endpoints (Examples)
+
+After starting the server, visit `/docs` for the interactive Swagger UI. Below are standard `curl` examples targeting common S3 actions:
+
+**Health check**
+```bash
+curl http://127.0.0.1:9000/health
+```
+
+**Create a bucket**
+```bash
+curl -X PUT http://127.0.0.1:9000/photos
+```
+
+**Upload an object**
+```bash
+curl -X PUT --data-binary @"cat.jpg" http://127.0.0.1:9000/photos/cat.jpg
+```
+
+**Download an object**
+```bash
+curl http://127.0.0.1:9000/photos/cat.jpg --output cat.jpg
+```
+
+**List objects (S3 Format)**
+```bash
+curl "http://127.0.0.1:9000/photos?list-type=2"
+```
+
+**Debug endpoints (JSON format)**
+```bash
+curl http://127.0.0.1:9000/_debug/buckets
+curl http://127.0.0.1:9000/_debug/photos
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome and highly appreciated! Please review our [Contributing Guidelines](CONTRIBUTING.md) to get started. By participating in this project, you agree to abide by the [Code of Conduct](.github/CODE_OF_CONDUCT.md).
+
+## 🔒 Security
+
+For instructions on reporting security vulnerabilities, please refer to our [Security Policy](SECURITY.md).
+
+## 📜 License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details.