apiformat 0.1.0__tar.gz

apiformat-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Core Developer
+
+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.

apiformat-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: apiformat
+Version: 0.1.0
+Summary: A lightweight, framework-agnostic Python package for standardized API responses.
+Author: Core Developer
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: django
+Requires-Dist: django; extra == "django"
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == "fastapi"
+Requires-Dist: pydantic; extra == "fastapi"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# apiformat
+
+A lightweight, framework-agnostic Python package that enforces a single, consistent response format across all API endpoints.
+
+## Installation
+
+```bash
+pip install apiformat
+```
+
+## Core Module (No Dependencies)
+
+```python
+from apiformat import success, error
+
+# Success response
+response = success(
+    data={"id": 1, "name": "John"},
+    message="User created successfully"
+)
+# Output:
+# {
+#   "status": "success",
+#   "message": "User created successfully",
+#   "data": {"id": 1, "name": "John"},
+#   "meta": {}
+# }
+
+# Error response
+response = error(
+    message="User not found",
+    status_code=404
+)
+# Output:
+# {
+#   "status": "error",
+#   "message": "User not found",
+#   "data": None,
+#   "meta": {}
+# }
+```
+
+## Django Integration
+
+```python
+from apiformat.integrations.django import success_response, error_response
+
+def create_user(request):
+    user = User.objects.create(name="John")
+    return success_response(
+        data={"id": user.id, "name": user.name},
+        message="User created",
+        status=201
+    )
+
+def get_user(request, user_id):
+    try:
+        user = User.objects.get(id=user_id)
+        return success_response(data={"id": user.id, "name": user.name})
+    except User.DoesNotExist:
+        return error_response(message="User not found", status=404)
+```
+
+## FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from apiformat.integrations.fastapi import success_response, error_response
+
+app = FastAPI()
+
+@app.post("/users")
+async def create_user(name: str):
+    user = User(name=name)
+    user.save()
+    return success_response(
+        data={"id": user.id, "name": user.name},
+        message="User created",
+        status_code=201
+    )
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    user = User.get_by_id(user_id)
+    if not user:
+        return error_response(message="User not found", status_code=404)
+    return success_response(data={"id": user.id, "name": user.name})
+```
+
+## License
+
+MIT

apiformat-0.1.0/README.md

@@ -0,0 +1,92 @@
+# apiformat
+
+A lightweight, framework-agnostic Python package that enforces a single, consistent response format across all API endpoints.
+
+## Installation
+
+```bash
+pip install apiformat
+```
+
+## Core Module (No Dependencies)
+
+```python
+from apiformat import success, error
+
+# Success response
+response = success(
+    data={"id": 1, "name": "John"},
+    message="User created successfully"
+)
+# Output:
+# {
+#   "status": "success",
+#   "message": "User created successfully",
+#   "data": {"id": 1, "name": "John"},
+#   "meta": {}
+# }
+
+# Error response
+response = error(
+    message="User not found",
+    status_code=404
+)
+# Output:
+# {
+#   "status": "error",
+#   "message": "User not found",
+#   "data": None,
+#   "meta": {}
+# }
+```
+
+## Django Integration
+
+```python
+from apiformat.integrations.django import success_response, error_response
+
+def create_user(request):
+    user = User.objects.create(name="John")
+    return success_response(
+        data={"id": user.id, "name": user.name},
+        message="User created",
+        status=201
+    )
+
+def get_user(request, user_id):
+    try:
+        user = User.objects.get(id=user_id)
+        return success_response(data={"id": user.id, "name": user.name})
+    except User.DoesNotExist:
+        return error_response(message="User not found", status=404)
+```
+
+## FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from apiformat.integrations.fastapi import success_response, error_response
+
+app = FastAPI()
+
+@app.post("/users")
+async def create_user(name: str):
+    user = User(name=name)
+    user.save()
+    return success_response(
+        data={"id": user.id, "name": user.name},
+        message="User created",
+        status_code=201
+    )
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    user = User.get_by_id(user_id)
+    if not user:
+        return error_response(message="User not found", status_code=404)
+    return success_response(data={"id": user.id, "name": user.name})
+```
+
+## License
+
+MIT

apiformat-0.1.0/apiformat/__init__.py

@@ -0,0 +1,4 @@
+from .core import success, error, APIResponse
+from .exceptions import APIException
+
+__all__ = ["success", "error", "APIResponse", "APIException"]

apiformat-0.1.0/apiformat/core.py

@@ -0,0 +1,51 @@
+from typing import Any, Optional, Dict
+
+def success(
+    data: Any = None,
+    message: str = "Success",
+    meta: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """Return a standardized success response."""
+    return {
+        "status": "success",
+        "message": message,
+        "data": data,
+        "meta": meta or {},
+    }
+
+def error(
+    message: str = "Error",
+    data: Any = None,
+    meta: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """Return a standardized error response."""
+    return {
+        "status": "error",
+        "message": message,
+        "data": data,
+        "meta": meta or {},
+    }
+
+class APIResponse:
+    """Encapsulates a standardized API response."""
+    
+    def __init__(
+        self,
+        status: str,
+        message: str = "",
+        data: Any = None,
+        meta: Optional[Dict] = None
+    ):
+        self.status = status
+        self.message = message
+        self.data = data
+        self.meta = meta or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation."""
+        return {
+            "status": self.status,
+            "message": self.message,
+            "data": self.data,
+            "meta": self.meta,
+        }

apiformat-0.1.0/apiformat/exceptions.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+class APIException(Exception):
+    """Base exception for API errors."""
+    
+    def __init__(self, message: str, status_code: int = 400, data: Any = None):
+        self.message = message
+        self.status_code = status_code
+        self.data = data
+        super().__init__(self.message)

apiformat-0.1.0/apiformat/integrations/__init__.py

@@ -0,0 +1 @@
+# Integrations package

apiformat-0.1.0/apiformat/integrations/django.py

@@ -0,0 +1,10 @@
+from django.http import JsonResponse
+from apiformat.core import success, error
+
+def success_response(data=None, message="Success", status=200):
+    """Return Django JsonResponse with standardized format."""
+    return JsonResponse(success(data, message), status=status)
+
+def error_response(message="Error", status=400, data=None):
+    """Return Django JsonResponse with standardized error format."""
+    return JsonResponse(error(message, data), status=status)

apiformat-0.1.0/apiformat/integrations/fastapi.py

@@ -0,0 +1,10 @@
+from fastapi.responses import JSONResponse
+from apiformat.core import success, error
+
+def success_response(data=None, message="Success", status_code=200):
+    """Return FastAPI JSONResponse with standardized format."""
+    return JSONResponse(success(data, message), status_code=status_code)
+
+def error_response(message="Error", status_code=400, data=None):
+    """Return FastAPI JSONResponse with standardized error format."""
+    return JSONResponse(error(message, data), status_code=status_code)

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

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: apiformat
+Version: 0.1.0
+Summary: A lightweight, framework-agnostic Python package for standardized API responses.
+Author: Core Developer
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: django
+Requires-Dist: django; extra == "django"
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == "fastapi"
+Requires-Dist: pydantic; extra == "fastapi"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# apiformat
+
+A lightweight, framework-agnostic Python package that enforces a single, consistent response format across all API endpoints.
+
+## Installation
+
+```bash
+pip install apiformat
+```
+
+## Core Module (No Dependencies)
+
+```python
+from apiformat import success, error
+
+# Success response
+response = success(
+    data={"id": 1, "name": "John"},
+    message="User created successfully"
+)
+# Output:
+# {
+#   "status": "success",
+#   "message": "User created successfully",
+#   "data": {"id": 1, "name": "John"},
+#   "meta": {}
+# }
+
+# Error response
+response = error(
+    message="User not found",
+    status_code=404
+)
+# Output:
+# {
+#   "status": "error",
+#   "message": "User not found",
+#   "data": None,
+#   "meta": {}
+# }
+```
+
+## Django Integration
+
+```python
+from apiformat.integrations.django import success_response, error_response
+
+def create_user(request):
+    user = User.objects.create(name="John")
+    return success_response(
+        data={"id": user.id, "name": user.name},
+        message="User created",
+        status=201
+    )
+
+def get_user(request, user_id):
+    try:
+        user = User.objects.get(id=user_id)
+        return success_response(data={"id": user.id, "name": user.name})
+    except User.DoesNotExist:
+        return error_response(message="User not found", status=404)
+```
+
+## FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from apiformat.integrations.fastapi import success_response, error_response
+
+app = FastAPI()
+
+@app.post("/users")
+async def create_user(name: str):
+    user = User(name=name)
+    user.save()
+    return success_response(
+        data={"id": user.id, "name": user.name},
+        message="User created",
+        status_code=201
+    )
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    user = User.get_by_id(user_id)
+    if not user:
+        return error_response(message="User not found", status_code=404)
+    return success_response(data={"id": user.id, "name": user.name})
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+apiformat/__init__.py
+apiformat/core.py
+apiformat/exceptions.py
+apiformat.egg-info/PKG-INFO
+apiformat.egg-info/SOURCES.txt
+apiformat.egg-info/dependency_links.txt
+apiformat.egg-info/requires.txt
+apiformat.egg-info/top_level.txt
+apiformat/integrations/__init__.py
+apiformat/integrations/django.py
+apiformat/integrations/fastapi.py
+tests/test_core.py
+tests/test_django_integration.py
+tests/test_exceptions.py
+tests/test_fastapi_integration.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,12 @@
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+mypy>=1.0.0
+
+[django]
+django
+
+[fastapi]
+fastapi
+pydantic

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

@@ -0,0 +1 @@
+apiformat

apiformat-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "apiformat"
+version = "0.1.0"
+description = "A lightweight, framework-agnostic Python package for standardized API responses."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Core Developer"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.optional-dependencies]
+django = ["django"]
+fastapi = ["fastapi", "pydantic"]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.0.0"
+]
+
+[tool.setuptools.packages.find]
+include = ["apiformat*"]
+exclude = ["tests*"]
+
+[tool.pytest.ini_options]
+addopts = "--cov=apiformat --cov-report=term-missing"
+testpaths = ["tests"]
+
+[tool.mypy]
+files = ["apiformat", "tests"]
+ignore_missing_imports = true

apiformat-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

apiformat-0.1.0/tests/test_core.py

@@ -0,0 +1,57 @@
+import pytest
+from apiformat.core import success, error, APIResponse
+
+def test_success_default():
+    result = success()
+    assert result == {
+        "status": "success",
+        "message": "Success",
+        "data": None,
+        "meta": {}
+    }
+
+def test_success_custom():
+    result = success(data=[1, 2], message="OK", meta={"page": 1})
+    assert result == {
+        "status": "success",
+        "message": "OK",
+        "data": [1, 2],
+        "meta": {"page": 1}
+    }
+
+def test_error_default():
+    result = error()
+    assert result == {
+        "status": "error",
+        "message": "Error",
+        "data": None,
+        "meta": {}
+    }
+
+def test_error_custom():
+    result = error(message="Not found", data={"id": 1}, meta={"code": 404})
+    assert result == {
+        "status": "error",
+        "message": "Not found",
+        "data": {"id": 1},
+        "meta": {"code": 404}
+    }
+
+def test_apiresponse_default():
+    response = APIResponse(status="success")
+    assert response.to_dict() == {
+        "status": "success",
+        "message": "",
+        "data": None,
+        "meta": {}
+    }
+
+def test_apiresponse_custom():
+    response = APIResponse(status="error", message="Failed", data="X", meta={"k": "v"})
+    print(response.to_dict())
+    assert response.to_dict() == {
+        "status": "error",
+        "message": "Failed",
+        "data": "X",
+        "meta": {"k": "v"}
+    }

apiformat-0.1.0/tests/test_django_integration.py

@@ -0,0 +1,25 @@
+from unittest.mock import patch
+from apiformat.integrations.django import success_response, error_response
+
+@patch('apiformat.integrations.django.JsonResponse')
+def test_django_success_response(mock_json_response):
+    success_response(data={"user": "test"}, message="Saved", status=201)
+    print(mock_json_response.call_args)
+    mock_json_response.assert_called_once_with({
+        "status": "success",
+        "message": "Saved",
+        "data": {"user": "test"},
+        "meta": {}
+    }, status=201)
+    
+
+@patch('apiformat.integrations.django.JsonResponse')
+def test_django_error_response(mock_json_response):
+    error_response(message="Invalid", status=403, data={"field": "name"})
+    
+    mock_json_response.assert_called_once_with({
+        "status": "error",
+        "message": "Invalid",
+        "data": {"field": "name"},
+        "meta": {}
+    }, status=403)

apiformat-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,16 @@
+import pytest
+from apiformat.exceptions import APIException
+
+def test_api_exception_default():
+    exc = APIException(message="Something went wrong")
+    assert exc.message == "Something went wrong"
+    assert exc.status_code == 400
+    assert exc.data is None
+    assert str(exc) == "Something went wrong"
+
+def test_api_exception_custom():
+    exc = APIException(message="Not found", status_code=404, data={"id": 5})
+    assert exc.message == "Not found"
+    assert exc.status_code == 404
+    assert exc.data == {"id": 5}
+    assert str(exc) == "Not found"

apiformat-0.1.0/tests/test_fastapi_integration.py

@@ -0,0 +1,24 @@
+from unittest.mock import patch
+from apiformat.integrations.fastapi import success_response, error_response
+
+@patch('apiformat.integrations.fastapi.JSONResponse')
+def test_fastapi_success_response(mock_json_response):
+    success_response(data=[1], message="Fetched", status_code=200)
+    
+    mock_json_response.assert_called_once_with({
+        "status": "success",
+        "message": "Fetched",
+        "data": [1],
+        "meta": {}
+    }, status_code=200)
+
+@patch('apiformat.integrations.fastapi.JSONResponse')
+def test_fastapi_error_response(mock_json_response):
+    error_response(message="Missing parameters", status_code=422, data={"param": "id"})
+    
+    mock_json_response.assert_called_once_with({
+        "status": "error",
+        "message": "Missing parameters",
+        "data": {"param": "id"},
+        "meta": {}
+    }, status_code=422)