vibe-coded-decorator 0.1.0__tar.gz

vibe_coded_decorator-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: vibe-coded-decorator
+Version: 0.1.0
+Summary: A decorator to mark functions as vibe-coded in their docstrings
+Author-email: Sep Keucheni <septimber@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/sepkeuchenius/vibe-coded-decorator
+Project-URL: Repository, https://github.com/sepkeuchenius/vibe-coded-decorator
+Keywords: decorator,docstring,vibe-coding,fastapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# vibe-coded-decorator
+
+A Python decorator that marks functions as "vibe-coded" by adding a notice to their docstrings. This notice will appear in automatic documentation tools like FastAPI's interactive docs.
+
+## Installation
+
+```bash
+pip install vibe-coded-decorator
+```
+
+Or install from source:
+
+```bash
+pip install .
+```
+
+## Usage
+
+Simply add the `@vibe_coded` decorator to any function:
+
+```python
+from vibe_coded_decorator import vibe_coded
+
+@vibe_coded
+def my_function():
+    """This is my function."""
+    return "Hello, world!"
+```
+
+The decorator will modify the function's docstring to include a notice at the beginning:
+
+```python
+print(my_function.__doc__)
+# Output: **THIS FUNCTION HAS BEEN VIBE CODED**
+#
+# This is my function.
+```
+
+### With FastAPI
+
+The decorator works seamlessly with FastAPI, and the notice will appear in the automatic API documentation:
+
+```python
+from fastapi import FastAPI
+from vibe_coded_decorator import vibe_coded
+
+app = FastAPI()
+
+@app.get("/hello")
+@vibe_coded
+def hello_world():
+    """Returns a greeting message."""
+    return {"message": "Hello, world!"}
+```
+
+When you visit the FastAPI docs at `/docs`, you'll see "**THIS FUNCTION HAS BEEN VIBE CODED**" at the top of the function's description.
+
+### Functions Without Docstrings
+
+The decorator also works with functions that don't have docstrings:
+
+```python
+@vibe_coded
+def no_docstring():
+    pass
+
+print(no_docstring.__doc__)
+# Output: **THIS FUNCTION HAS BEEN VIBE CODED**
+```
+
+## Development
+
+To install in development mode:
+
+```bash
+pip install -e .
+```
+
+## License
+
+MIT
+

vibe_coded_decorator-0.1.0/README.md

@@ -0,0 +1,82 @@
+# vibe-coded-decorator
+
+A Python decorator that marks functions as "vibe-coded" by adding a notice to their docstrings. This notice will appear in automatic documentation tools like FastAPI's interactive docs.
+
+## Installation
+
+```bash
+pip install vibe-coded-decorator
+```
+
+Or install from source:
+
+```bash
+pip install .
+```
+
+## Usage
+
+Simply add the `@vibe_coded` decorator to any function:
+
+```python
+from vibe_coded_decorator import vibe_coded
+
+@vibe_coded
+def my_function():
+    """This is my function."""
+    return "Hello, world!"
+```
+
+The decorator will modify the function's docstring to include a notice at the beginning:
+
+```python
+print(my_function.__doc__)
+# Output: **THIS FUNCTION HAS BEEN VIBE CODED**
+#
+# This is my function.
+```
+
+### With FastAPI
+
+The decorator works seamlessly with FastAPI, and the notice will appear in the automatic API documentation:
+
+```python
+from fastapi import FastAPI
+from vibe_coded_decorator import vibe_coded
+
+app = FastAPI()
+
+@app.get("/hello")
+@vibe_coded
+def hello_world():
+    """Returns a greeting message."""
+    return {"message": "Hello, world!"}
+```
+
+When you visit the FastAPI docs at `/docs`, you'll see "**THIS FUNCTION HAS BEEN VIBE CODED**" at the top of the function's description.
+
+### Functions Without Docstrings
+
+The decorator also works with functions that don't have docstrings:
+
+```python
+@vibe_coded
+def no_docstring():
+    pass
+
+print(no_docstring.__doc__)
+# Output: **THIS FUNCTION HAS BEEN VIBE CODED**
+```
+
+## Development
+
+To install in development mode:
+
+```bash
+pip install -e .
+```
+
+## License
+
+MIT
+

vibe_coded_decorator-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vibe-coded-decorator"
+version = "0.1.0"
+description = "A decorator to mark functions as vibe-coded in their docstrings"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "Sep Keucheni", email = "septimber@gmail.com"}
+]
+keywords = ["decorator", "docstring", "vibe-coding", "fastapi"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/sepkeuchenius/vibe-coded-decorator"
+Repository = "https://github.com/sepkeuchenius/vibe-coded-decorator"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[tool.setuptools]
+packages = ["vibe_coded_decorator"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+

vibe_coded_decorator-0.1.0/setup.cfg

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

vibe_coded_decorator-0.1.0/tests/test_vibe_coded.py

@@ -0,0 +1,190 @@
+"""Tests for the vibe_coded decorator."""
+
+import pytest
+from vibe_coded_decorator import vibe_coded
+
+
+def test_decorator_with_existing_docstring():
+    """Test that decorator prepends notice to existing docstring."""
+    @vibe_coded
+    def test_func():
+        """Original docstring."""
+        return "test"
+    
+    assert test_func.__doc__ == "**THIS FUNCTION HAS BEEN VIBE CODED**\n\nOriginal docstring."
+    assert test_func() == "test"
+
+
+def test_decorator_without_docstring():
+    """Test that decorator adds notice when no docstring exists."""
+    @vibe_coded
+    def test_func():
+        return "test"
+    
+    assert test_func.__doc__ == "**THIS FUNCTION HAS BEEN VIBE CODED**"
+    assert test_func() == "test"
+
+
+def test_decorator_preserves_function_metadata():
+    """Test that decorator preserves function name and other metadata."""
+    @vibe_coded
+    def original_function_name():
+        """Test function."""
+        return "test"
+    
+    assert original_function_name.__name__ == "original_function_name"
+    assert callable(original_function_name)
+
+
+def test_decorator_with_arguments():
+    """Test that decorator works with functions that have arguments."""
+    @vibe_coded
+    def test_func(arg1, arg2, kwarg1=None):
+        """Function with arguments."""
+        return arg1 + arg2 + (kwarg1 or 0)
+    
+    assert test_func.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert test_func(1, 2, kwarg1=3) == 6
+    assert test_func(1, 2) == 3
+
+
+def test_decorator_with_multiline_docstring():
+    """Test that decorator works with multiline docstrings."""
+    @vibe_coded
+    def test_func():
+        """This is a multiline docstring.
+        
+        It has multiple lines.
+        And more information here.
+        """
+        return "test"
+    
+    docstring = test_func.__doc__
+    assert docstring.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert "This is a multiline docstring" in docstring
+    assert "It has multiple lines" in docstring
+    assert "And more information here" in docstring
+
+
+def test_decorator_with_empty_docstring():
+    """Test that decorator handles empty docstring."""
+    @vibe_coded
+    def test_func():
+        """"""
+        return "test"
+    
+    # Empty docstring is falsy, so it should just have the notice
+    assert test_func.__doc__ == "**THIS FUNCTION HAS BEEN VIBE CODED**"
+
+
+def test_decorator_with_whitespace_only_docstring():
+    """Test that decorator handles whitespace-only docstring."""
+    @vibe_coded
+    def test_func():
+        """   """
+        return "test"
+    
+    # Whitespace-only docstring is truthy, so it should prepend
+    assert test_func.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert "   " in test_func.__doc__
+
+
+def test_decorator_on_class_method():
+    """Test that decorator works on class methods."""
+    class TestClass:
+        @vibe_coded
+        def method(self):
+            """A class method."""
+            return "method_result"
+        
+        @classmethod
+        @vibe_coded
+        def class_method(cls):
+            """A classmethod."""
+            return "class_method_result"
+        
+        @staticmethod
+        @vibe_coded
+        def static_method():
+            """A static method."""
+            return "static_method_result"
+    
+    instance = TestClass()
+    
+    # Test instance method
+    assert instance.method.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert instance.method() == "method_result"
+    
+    # Test classmethod (decorator order: @classmethod then @vibe_coded)
+    assert TestClass.class_method.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert TestClass.class_method() == "class_method_result"
+    
+    # Test staticmethod (decorator order: @staticmethod then @vibe_coded)
+    assert TestClass.static_method.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert TestClass.static_method() == "static_method_result"
+
+
+def test_decorator_on_async_function():
+    """Test that decorator works on async functions."""
+    @vibe_coded
+    async def async_func():
+        """An async function."""
+        return "async_result"
+    
+    assert async_func.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert "An async function" in async_func.__doc__
+
+
+def test_decorator_preserves_function_signature():
+    """Test that decorator preserves function signature for introspection."""
+    @vibe_coded
+    def test_func(a, b, c=10, *args, **kwargs):
+        """Function with complex signature."""
+        return a + b + c
+    
+    import inspect
+    sig = inspect.signature(test_func)
+    params = list(sig.parameters.keys())
+    
+    assert params == ['a', 'b', 'c', 'args', 'kwargs']
+    assert test_func(1, 2) == 13
+    assert test_func(1, 2, 3) == 6
+
+
+def test_decorator_notice_format():
+    """Test that the notice has the exact expected format."""
+    @vibe_coded
+    def test_func():
+        """Test."""
+        pass
+    
+    expected_notice = "**THIS FUNCTION HAS BEEN VIBE CODED**"
+    assert test_func.__doc__.startswith(expected_notice)
+    assert test_func.__doc__ == f"{expected_notice}\n\nTest."
+
+
+def test_multiple_decorators():
+    """Test that decorator can be combined with other decorators."""
+    def other_decorator(func):
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs) * 2
+        return wrapper
+    
+    @vibe_coded
+    @other_decorator
+    def test_func():
+        """Test function."""
+        return 5
+    
+    assert test_func.__doc__.startswith("**THIS FUNCTION HAS BEEN VIBE CODED**")
+    assert test_func() == 10
+
+
+def test_decorator_on_lambda():
+    """Test that decorator works on lambda functions (though unusual)."""
+    # Note: Lambdas typically don't have docstrings, but we can test the behavior
+    test_lambda = vibe_coded(lambda x: x * 2)
+    
+    assert test_lambda.__doc__ == "**THIS FUNCTION HAS BEEN VIBE CODED**"
+    assert test_lambda(5) == 10
+

vibe_coded_decorator-0.1.0/vibe_coded_decorator/__init__.py

@@ -0,0 +1,46 @@
+"""A decorator to mark functions as vibe-coded."""
+
+from functools import wraps
+
+
+def vibe_coded(func):
+    """
+    Decorator that adds a notice to the function's docstring indicating it was vibe-coded.
+    
+    This decorator prepends "**THIS FUNCTION HAS BEEN VIBE CODED**" to the function's
+    docstring, which will appear in documentation tools like FastAPI's automatic docs.
+    
+    Args:
+        func: The function to be decorated.
+    
+    Returns:
+        The decorated function with modified docstring.
+    
+    Example:
+        @vibe_coded
+        def my_function():
+            \"\"\"This is my function.\"\"\"
+            pass
+        
+        # The docstring will become:
+        # "**THIS FUNCTION HAS BEEN VIBE CODED**\n\nThis is my function."
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    
+    # Modify the docstring
+    notice = "**THIS FUNCTION HAS BEEN VIBE CODED**"
+    
+    if func.__doc__:
+        # If docstring exists, prepend the notice
+        wrapper.__doc__ = f"{notice}\n\n{func.__doc__}"
+    else:
+        # If no docstring exists, create one with just the notice
+        wrapper.__doc__ = notice
+    
+    return wrapper
+
+
+__all__ = ['vibe_coded']
+

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

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: vibe-coded-decorator
+Version: 0.1.0
+Summary: A decorator to mark functions as vibe-coded in their docstrings
+Author-email: Sep Keucheni <septimber@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/sepkeuchenius/vibe-coded-decorator
+Project-URL: Repository, https://github.com/sepkeuchenius/vibe-coded-decorator
+Keywords: decorator,docstring,vibe-coding,fastapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# vibe-coded-decorator
+
+A Python decorator that marks functions as "vibe-coded" by adding a notice to their docstrings. This notice will appear in automatic documentation tools like FastAPI's interactive docs.
+
+## Installation
+
+```bash
+pip install vibe-coded-decorator
+```
+
+Or install from source:
+
+```bash
+pip install .
+```
+
+## Usage
+
+Simply add the `@vibe_coded` decorator to any function:
+
+```python
+from vibe_coded_decorator import vibe_coded
+
+@vibe_coded
+def my_function():
+    """This is my function."""
+    return "Hello, world!"
+```
+
+The decorator will modify the function's docstring to include a notice at the beginning:
+
+```python
+print(my_function.__doc__)
+# Output: **THIS FUNCTION HAS BEEN VIBE CODED**
+#
+# This is my function.
+```
+
+### With FastAPI
+
+The decorator works seamlessly with FastAPI, and the notice will appear in the automatic API documentation:
+
+```python
+from fastapi import FastAPI
+from vibe_coded_decorator import vibe_coded
+
+app = FastAPI()
+
+@app.get("/hello")
+@vibe_coded
+def hello_world():
+    """Returns a greeting message."""
+    return {"message": "Hello, world!"}
+```
+
+When you visit the FastAPI docs at `/docs`, you'll see "**THIS FUNCTION HAS BEEN VIBE CODED**" at the top of the function's description.
+
+### Functions Without Docstrings
+
+The decorator also works with functions that don't have docstrings:
+
+```python
+@vibe_coded
+def no_docstring():
+    pass
+
+print(no_docstring.__doc__)
+# Output: **THIS FUNCTION HAS BEEN VIBE CODED**
+```
+
+## Development
+
+To install in development mode:
+
+```bash
+pip install -e .
+```
+
+## License
+
+MIT
+

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

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+tests/test_vibe_coded.py
+vibe_coded_decorator/__init__.py
+vibe_coded_decorator.egg-info/PKG-INFO
+vibe_coded_decorator.egg-info/SOURCES.txt
+vibe_coded_decorator.egg-info/dependency_links.txt
+vibe_coded_decorator.egg-info/requires.txt
+vibe_coded_decorator.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0.0

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

@@ -0,0 +1 @@
+vibe_coded_decorator