PyPI - py-flexo - Versions diffs - 0.1.0__tar.gz - Mend

py-flexo 0.1.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

py_flexo-0.1.0/PKG-INFO +391 -0
py_flexo-0.1.0/README.md +378 -0
py_flexo-0.1.0/py_flexo/__init__.py +0 -0
py_flexo-0.1.0/py_flexo/app.py +111 -0
py_flexo-0.1.0/py_flexo/middleware.py +26 -0
py_flexo-0.1.0/py_flexo/response.py +35 -0
py_flexo-0.1.0/py_flexo.egg-info/PKG-INFO +391 -0
py_flexo-0.1.0/py_flexo.egg-info/SOURCES.txt +11 -0
py_flexo-0.1.0/py_flexo.egg-info/dependency_links.txt +1 -0
py_flexo-0.1.0/py_flexo.egg-info/requires.txt +6 -0
py_flexo-0.1.0/py_flexo.egg-info/top_level.txt +1 -0
py_flexo-0.1.0/pyproject.toml +32 -0
py_flexo-0.1.0/setup.cfg +4 -0

py_flexo-0.1.0/PKG-INFO ADDED Viewed

@@ -0,0 +1,391 @@
+Metadata-Version: 2.4
+Name: py-flexo
+Version: 0.1.0
+Summary: Python Web Framework built for learning purposes
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: gunicorn>=26.0.0
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: parse>=1.22.1
+Requires-Dist: requests-wsgi-adapter>=0.4.1
+Requires-Dist: webob>=1.8.10
+Requires-Dist: whitenoise>=6.12.0
+# PyFlexo
+<p align="center">
+A modern, lightweight and extensible WSGI web framework for Python.
+</p>
+<p align="center">
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-passing-success)
+![Version](https://img.shields.io/badge/version-0.1.0-orange)
+</p>
+---
+## Why PyFlexo?
+PyFlexo is a lightweight WSGI web framework focused on simplicity, readability, and extensibility.
+Instead of hiding how web applications work, PyFlexo provides a clean API while remaining close to the WSGI specification. It is suitable for learning, small services, REST APIs, and custom web applications.
+## Features
+* Simple and intuitive routing
+* Function-based views
+* Class-based views
+* Dynamic URL parameters
+* Built-in template rendering (Jinja2)
+* Static file serving
+* JSON response helper
+* Global exception handlers
+* Middleware support
+* Pure Python implementation
+* WSGI compatible
+* Easy to extend
+---
+# Installation
+Using pip
+```bash
+pip install py_flexo
+```
+Using uv
+```bash
+uv add py_flexo
+```
+---
+# Quick Start
+main.py
+```python
+from py_flexo.app import PyFlexoApp
+app = PyFlexoApp()
+@app.route("/")
+def home(request, response):
+    response.text = "Hello, PyFlexo!"
+```
+Run your application with any WSGI server.
+Example:
+```bash
+gunicorn main:app
+```
+---
+# Routing
+## Function Based View
+```python
+@app.route("/")
+def index(request, response):
+    response.text = "Hello World"
+```
+---
+## Route Parameters
+```python
+@app.route("/hello/{name}")
+def hello(request, response, name):
+    response.text = f"Hello {name}"
+```
+Example
+```
+GET /hello/Alice
+```
+Response
+```
+Hello Alice
+```
+---
+## Class Based Views
+```python
+@app.route("/books")
+class Book:
+    def get(self, request, response):
+        response.text = "Book List"
+    def post(self, request, response):
+        response.text = "Create Book"
+```
+Supported methods
+* GET
+* POST
+* PUT
+* PATCH
+* DELETE
+---
+# Templates
+Directory
+```
+project/
+    templates/
+        home.html
+```
+Route
+```python
+@app.route("/home")
+def home(request, response):
+    response.html = app.template(
+        "home.html",
+        context={
+            "title": "PyFlexo",
+            "header": "Welcome"
+        }
+    )
+```
+Template
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{ title }}</title>
+</head>
+<body>
+<h1>{{ header }}</h1>
+</body>
+</html>
+```
+---
+# JSON Responses
+```python
+@app.route("/api")
+def api(request, response):
+    response.json = {
+        "framework": "PyFlexo",
+        "version": "0.1.0"
+    }
+```
+Output
+```json
+{
+    "framework": "PyFlexo",
+    "version": "0.1.0"
+}
+```
+---
+# Middleware
+```python
+from py_flexo.middleware import Middleware
+class LoggingMiddleware(Middleware):
+    def process_request(self, request):
+        print(request.method, request.path)
+    def process_response(self, response):
+        print(response.status_code)
+app.add_middleware(LoggingMiddleware)
+```
+---
+# Exception Handling
+```python
+def exception_handler(request, response, exception):
+    response.status_code = 500
+    response.text = "Internal Server Error"
+app.add_exception_handler(exception_handler)
+```
+---
+# Static Files
+Directory
+```
+project/
+    static/
+        style.css
+        app.js
+        logo.png
+```
+Static files are automatically available under
+```
+/static/
+```
+Example
+```
+/static/style.css
+```
+---
+# Project Structure
+```
+project/
+│
+├── main.py
+├── templates/
+│   └── home.html
+│
+├── static/
+│   ├── style.css
+│   └── app.js
+│
+└── pyproject.toml
+```
+---
+# Complete Example
+```python
+from py_flexo.app import PyFlexoApp
+from py_flexo.middleware import Middleware
+app = PyFlexoApp()
+@app.route("/")
+def index(request, response):
+    response.text = "Welcome to PyFlexo"
+@app.route("/hello/{name}")
+def hello(request, response, name):
+    response.text = f"Hello {name}"
+@app.route("/books")
+class Book:
+    def get(self, request, response):
+        response.text = "Book List"
+@app.route("/home")
+def home(request, response):
+    response.html = app.template(
+        "home.html",
+        context={
+            "title": "PyFlexo",
+            "header": "Welcome"
+        }
+    )
+@app.route("/api")
+def api(request, response):
+    response.json = {
+        "message": "Hello JSON"
+    }
+class LoggingMiddleware(Middleware):
+    def process_request(self, request):
+        print(request.path)
+    def process_response(self, response):
+        print(response.status_code)
+app.add_middleware(LoggingMiddleware)
+```
+---
+# Roadmap
+* Cookies
+* Sessions
+* Authentication
+* Blueprint support
+* Request validation
+* CLI
+* Dependency Injection
+* OpenAPI
+* ASGI support
+* WebSocket support
+---
+# Contributing
+Contributions are welcome.
+Please open an issue before submitting large changes.
+---
+# Author
+PyFlexo is an open-source project created for developers who enjoy building fast and elegant Python web applications.

py_flexo-0.1.0/README.md ADDED Viewed

@@ -0,0 +1,378 @@
+# PyFlexo
+<p align="center">
+A modern, lightweight and extensible WSGI web framework for Python.
+</p>
+<p align="center">
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-passing-success)
+![Version](https://img.shields.io/badge/version-0.1.0-orange)
+</p>
+---
+## Why PyFlexo?
+PyFlexo is a lightweight WSGI web framework focused on simplicity, readability, and extensibility.
+Instead of hiding how web applications work, PyFlexo provides a clean API while remaining close to the WSGI specification. It is suitable for learning, small services, REST APIs, and custom web applications.
+## Features
+* Simple and intuitive routing
+* Function-based views
+* Class-based views
+* Dynamic URL parameters
+* Built-in template rendering (Jinja2)
+* Static file serving
+* JSON response helper
+* Global exception handlers
+* Middleware support
+* Pure Python implementation
+* WSGI compatible
+* Easy to extend
+---
+# Installation
+Using pip
+```bash
+pip install py_flexo
+```
+Using uv
+```bash
+uv add py_flexo
+```
+---
+# Quick Start
+main.py
+```python
+from py_flexo.app import PyFlexoApp
+app = PyFlexoApp()
+@app.route("/")
+def home(request, response):
+    response.text = "Hello, PyFlexo!"
+```
+Run your application with any WSGI server.
+Example:
+```bash
+gunicorn main:app
+```
+---
+# Routing
+## Function Based View
+```python
+@app.route("/")
+def index(request, response):
+    response.text = "Hello World"
+```
+---
+## Route Parameters
+```python
+@app.route("/hello/{name}")
+def hello(request, response, name):
+    response.text = f"Hello {name}"
+```
+Example
+```
+GET /hello/Alice
+```
+Response
+```
+Hello Alice
+```
+---
+## Class Based Views
+```python
+@app.route("/books")
+class Book:
+    def get(self, request, response):
+        response.text = "Book List"
+    def post(self, request, response):
+        response.text = "Create Book"
+```
+Supported methods
+* GET
+* POST
+* PUT
+* PATCH
+* DELETE
+---
+# Templates
+Directory
+```
+project/
+    templates/
+        home.html
+```
+Route
+```python
+@app.route("/home")
+def home(request, response):
+    response.html = app.template(
+        "home.html",
+        context={
+            "title": "PyFlexo",
+            "header": "Welcome"
+        }
+    )
+```
+Template
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{ title }}</title>
+</head>
+<body>
+<h1>{{ header }}</h1>
+</body>
+</html>
+```
+---
+# JSON Responses
+```python
+@app.route("/api")
+def api(request, response):
+    response.json = {
+        "framework": "PyFlexo",
+        "version": "0.1.0"
+    }
+```
+Output
+```json
+{
+    "framework": "PyFlexo",
+    "version": "0.1.0"
+}
+```
+---
+# Middleware
+```python
+from py_flexo.middleware import Middleware
+class LoggingMiddleware(Middleware):
+    def process_request(self, request):
+        print(request.method, request.path)
+    def process_response(self, response):
+        print(response.status_code)
+app.add_middleware(LoggingMiddleware)
+```
+---
+# Exception Handling
+```python
+def exception_handler(request, response, exception):
+    response.status_code = 500
+    response.text = "Internal Server Error"
+app.add_exception_handler(exception_handler)
+```
+---
+# Static Files
+Directory
+```
+project/
+    static/
+        style.css
+        app.js
+        logo.png
+```
+Static files are automatically available under
+```
+/static/
+```
+Example
+```
+/static/style.css
+```
+---
+# Project Structure
+```
+project/
+│
+├── main.py
+├── templates/
+│   └── home.html
+│
+├── static/
+│   ├── style.css
+│   └── app.js
+│
+└── pyproject.toml
+```
+---
+# Complete Example
+```python
+from py_flexo.app import PyFlexoApp
+from py_flexo.middleware import Middleware
+app = PyFlexoApp()
+@app.route("/")
+def index(request, response):
+    response.text = "Welcome to PyFlexo"
+@app.route("/hello/{name}")
+def hello(request, response, name):
+    response.text = f"Hello {name}"
+@app.route("/books")
+class Book:
+    def get(self, request, response):
+        response.text = "Book List"
+@app.route("/home")
+def home(request, response):
+    response.html = app.template(
+        "home.html",
+        context={
+            "title": "PyFlexo",
+            "header": "Welcome"
+        }
+    )
+@app.route("/api")
+def api(request, response):
+    response.json = {
+        "message": "Hello JSON"
+    }
+class LoggingMiddleware(Middleware):
+    def process_request(self, request):
+        print(request.path)
+    def process_response(self, response):
+        print(response.status_code)
+app.add_middleware(LoggingMiddleware)
+```
+---
+# Roadmap
+* Cookies
+* Sessions
+* Authentication
+* Blueprint support
+* Request validation
+* CLI
+* Dependency Injection
+* OpenAPI
+* ASGI support
+* WebSocket support
+---
+# Contributing
+Contributions are welcome.
+Please open an issue before submitting large changes.
+---
+# Author
+PyFlexo is an open-source project created for developers who enjoy building fast and elegant Python web applications.

py_flexo-0.1.0/py_flexo/__init__.py ADDED Viewed

File without changes

py_flexo-0.1.0/py_flexo/app.py ADDED Viewed

@@ -0,0 +1,111 @@
+from webob import Request
+from .response import Response
+from parse import parse
+import requests
+import wsgiadapter
+import inspect
+from jinja2 import Environment, FileSystemLoader
+import os
+from whitenoise import WhiteNoise
+from .middleware import Middleware
+class PyFlexoApp:
+    def __init__(self, templates_dir="templates", static_dir = "static"):
+        self._routes = {}
+        self.template_env = Environment(
+            loader = FileSystemLoader(os.path.abspath(templates_dir))
+        )
+        self.exception_handler = None
+        self.whitenoise = WhiteNoise(self.wsgi_app, root=static_dir, prefix='/static')
+        self.middleware = Middleware(self)
+    def __call__(self, environ, start_response):
+        path_info = environ["PATH_INFO"]
+        if path_info.startswith('/static'):
+            return self.whitenoise(environ, start_response)
+        return self.middleware(environ, start_response)
+    def wsgi_app(self, environ, start_response):
+        request = Request(environ)
+        response = self.handle_request(request)
+        return response(environ, start_response)
+    def handle_request(self, request):
+        response = Response()
+        handler_data, kwargs = self.find_handler(request.path)
+        if handler_data:
+            handler = handler_data["handler"]
+            allow_methods = handler_data["allow_methods"]
+            if inspect.isclass(handler):
+                handler = getattr(handler(), request.method.lower(), None)
+                if handler:
+                    handler(request, response, **kwargs)
+                else:
+                    self.method_not_allowed_response(response)
+            else:
+                if request.method.lower() not in allow_methods:
+                    self.method_not_allowed_response(response)
+            try:
+                handler(request, response, **kwargs)
+            except Exception as e:
+                if self.exception_handler is not None:
+                    self.exception_handler(request, response, e)
+                else:
+                    raise e
+        else:
+            self.default_response(response)
+        return response
+    def find_handler(self, path):
+        for route, handler_data in self._routes.items():
+            result = parse(route, path)
+            if result:
+                return handler_data, result.named
+            if route == path:
+                return handler_data, None
+        return None, None
+    def default_response(self, response):
+        response.status_code = 404
+        response.text = 'Not Found'
+        return response
+    def method_not_allowed_response(self, res):
+        res.status_code = 405
+        res.text = 'Method Not Allowed'
+        return res
+    def add_route(self, path, handler, allow_methods = None):
+        assert path  not in self._routes, "Duplicate url. Please change the URL"
+        if allow_methods is None:
+            allow_methods = ["get", "post", "put", "path", "head", "options", "delete"]
+        self._routes[path] = {"handler":handler, "allow_methods": allow_methods}
+    def route(self, path, allow_methods = None):
+        def decorator(handler):
+            self.add_route(path, handler, allow_methods)
+            return handler
+        return decorator
+    def test_session(self):
+        session = requests.Session()
+        session.mount('http://testserver', wsgiadapter.WSGIAdapter(self))
+        return session
+    def template(self, template_name, context = None):
+        if context is None:
+            context = {}
+        return self.template_env.get_template(template_name).render(**context).encode()
+    def add_exception_handler(self, handler):
+        self.exception_handler = handler
+    def add_middleware(self, middleware_cls):
+        self.middleware.add(middleware_cls)

py_flexo-0.1.0/py_flexo/middleware.py ADDED Viewed

@@ -0,0 +1,26 @@
+from webob import Request
+class Middleware:
+    def __init__(self, app):
+        self.app = app
+    def add(self, middleware_cls):
+        self.app = middleware_cls(self.app)
+    def process_request(self, req):
+        pass
+    def process_response(self, resp):
+        pass
+    def handle_request(self, request):
+        self.process_request(request)
+        response = self.app.handle_request(request)
+        self.process_response(response)
+        return response
+    def __call__(self, environ, start_response):
+        request = Request(environ)
+        response = self.app.handle_request(request)
+        return response(environ, start_response)

py_flexo-0.1.0/py_flexo/response.py ADDED Viewed

@@ -0,0 +1,35 @@
+from webob import Response as WebResponse
+import json
+class Response:
+    def __init__(self):
+        self.json = None
+        self.html = None
+        self.text = None
+        self.content_type = None
+        self.body = b''
+        self.status_code = 200
+    def set_body_and_content_type(self):
+        if self.json:
+            self.body = json.dumps(self.json).encode()
+            self.content_type = "application/json"
+        if self.html:
+            self.body = self.html.encode()
+            self.content_type = "text/html"
+        if self.text:
+            self.body = self.text
+            self.content_type = "text/plain"
+    def __call__(self, environ, start_response):
+        self.set_body_and_content_type()
+        response = WebResponse(
+            body = self.body,
+            content_type=self.content_type,
+            status = self.status_code
+        )
+        return response(environ, start_response)

py_flexo-0.1.0/py_flexo.egg-info/PKG-INFO ADDED Viewed

@@ -0,0 +1,391 @@
+Metadata-Version: 2.4
+Name: py-flexo
+Version: 0.1.0
+Summary: Python Web Framework built for learning purposes
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: gunicorn>=26.0.0
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: parse>=1.22.1
+Requires-Dist: requests-wsgi-adapter>=0.4.1
+Requires-Dist: webob>=1.8.10
+Requires-Dist: whitenoise>=6.12.0
+# PyFlexo
+<p align="center">
+A modern, lightweight and extensible WSGI web framework for Python.
+</p>
+<p align="center">
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-passing-success)
+![Version](https://img.shields.io/badge/version-0.1.0-orange)
+</p>
+---
+## Why PyFlexo?
+PyFlexo is a lightweight WSGI web framework focused on simplicity, readability, and extensibility.
+Instead of hiding how web applications work, PyFlexo provides a clean API while remaining close to the WSGI specification. It is suitable for learning, small services, REST APIs, and custom web applications.
+## Features
+* Simple and intuitive routing
+* Function-based views
+* Class-based views
+* Dynamic URL parameters
+* Built-in template rendering (Jinja2)
+* Static file serving
+* JSON response helper
+* Global exception handlers
+* Middleware support
+* Pure Python implementation
+* WSGI compatible
+* Easy to extend
+---
+# Installation
+Using pip
+```bash
+pip install py_flexo
+```
+Using uv
+```bash
+uv add py_flexo
+```
+---
+# Quick Start
+main.py
+```python
+from py_flexo.app import PyFlexoApp
+app = PyFlexoApp()
+@app.route("/")
+def home(request, response):
+    response.text = "Hello, PyFlexo!"
+```
+Run your application with any WSGI server.
+Example:
+```bash
+gunicorn main:app
+```
+---
+# Routing
+## Function Based View
+```python
+@app.route("/")
+def index(request, response):
+    response.text = "Hello World"
+```
+---
+## Route Parameters
+```python
+@app.route("/hello/{name}")
+def hello(request, response, name):
+    response.text = f"Hello {name}"
+```
+Example
+```
+GET /hello/Alice
+```
+Response
+```
+Hello Alice
+```
+---
+## Class Based Views
+```python
+@app.route("/books")
+class Book:
+    def get(self, request, response):
+        response.text = "Book List"
+    def post(self, request, response):
+        response.text = "Create Book"
+```
+Supported methods
+* GET
+* POST
+* PUT
+* PATCH
+* DELETE
+---
+# Templates
+Directory
+```
+project/
+    templates/
+        home.html
+```
+Route
+```python
+@app.route("/home")
+def home(request, response):
+    response.html = app.template(
+        "home.html",
+        context={
+            "title": "PyFlexo",
+            "header": "Welcome"
+        }
+    )
+```
+Template
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{ title }}</title>
+</head>
+<body>
+<h1>{{ header }}</h1>
+</body>
+</html>
+```
+---
+# JSON Responses
+```python
+@app.route("/api")
+def api(request, response):
+    response.json = {
+        "framework": "PyFlexo",
+        "version": "0.1.0"
+    }
+```
+Output
+```json
+{
+    "framework": "PyFlexo",
+    "version": "0.1.0"
+}
+```
+---
+# Middleware
+```python
+from py_flexo.middleware import Middleware
+class LoggingMiddleware(Middleware):
+    def process_request(self, request):
+        print(request.method, request.path)
+    def process_response(self, response):
+        print(response.status_code)
+app.add_middleware(LoggingMiddleware)
+```
+---
+# Exception Handling
+```python
+def exception_handler(request, response, exception):
+    response.status_code = 500
+    response.text = "Internal Server Error"
+app.add_exception_handler(exception_handler)
+```
+---
+# Static Files
+Directory
+```
+project/
+    static/
+        style.css
+        app.js
+        logo.png
+```
+Static files are automatically available under
+```
+/static/
+```
+Example
+```
+/static/style.css
+```
+---
+# Project Structure
+```
+project/
+│
+├── main.py
+├── templates/
+│   └── home.html
+│
+├── static/
+│   ├── style.css
+│   └── app.js
+│
+└── pyproject.toml
+```
+---
+# Complete Example
+```python
+from py_flexo.app import PyFlexoApp
+from py_flexo.middleware import Middleware
+app = PyFlexoApp()
+@app.route("/")
+def index(request, response):
+    response.text = "Welcome to PyFlexo"
+@app.route("/hello/{name}")
+def hello(request, response, name):
+    response.text = f"Hello {name}"
+@app.route("/books")
+class Book:
+    def get(self, request, response):
+        response.text = "Book List"
+@app.route("/home")
+def home(request, response):
+    response.html = app.template(
+        "home.html",
+        context={
+            "title": "PyFlexo",
+            "header": "Welcome"
+        }
+    )
+@app.route("/api")
+def api(request, response):
+    response.json = {
+        "message": "Hello JSON"
+    }
+class LoggingMiddleware(Middleware):
+    def process_request(self, request):
+        print(request.path)
+    def process_response(self, response):
+        print(response.status_code)
+app.add_middleware(LoggingMiddleware)
+```
+---
+# Roadmap
+* Cookies
+* Sessions
+* Authentication
+* Blueprint support
+* Request validation
+* CLI
+* Dependency Injection
+* OpenAPI
+* ASGI support
+* WebSocket support
+---
+# Contributing
+Contributions are welcome.
+Please open an issue before submitting large changes.
+---
+# Author
+PyFlexo is an open-source project created for developers who enjoy building fast and elegant Python web applications.

py_flexo-0.1.0/py_flexo.egg-info/SOURCES.txt ADDED Viewed

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+py_flexo/__init__.py
+py_flexo/app.py
+py_flexo/middleware.py
+py_flexo/response.py
+py_flexo.egg-info/PKG-INFO
+py_flexo.egg-info/SOURCES.txt
+py_flexo.egg-info/dependency_links.txt
+py_flexo.egg-info/requires.txt
+py_flexo.egg-info/top_level.txt

py_flexo-0.1.0/py_flexo.egg-info/dependency_links.txt ADDED Viewed

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

py_flexo-0.1.0/py_flexo.egg-info/requires.txt ADDED Viewed

@@ -0,0 +1,6 @@
+gunicorn>=26.0.0
+jinja2>=3.1.6
+parse>=1.22.1
+requests-wsgi-adapter>=0.4.1
+webob>=1.8.10
+whitenoise>=6.12.0

py_flexo-0.1.0/py_flexo.egg-info/top_level.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ py_flexo

py_flexo-0.1.0/pyproject.toml ADDED Viewed

@@ -0,0 +1,32 @@
+[project]
+name = "py-flexo"
+version = "0.1.0"
+description = "Python Web Framework built for learning purposes"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "gunicorn>=26.0.0",
+    "jinja2>=3.1.6",
+    "parse>=1.22.1",
+    "requests-wsgi-adapter>=0.4.1",
+    "webob>=1.8.10",
+    "whitenoise>=6.12.0"
+]
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "twine>=6.2.0",
+    "wheel>=0.47.0"
+]
+[tool.setuptools]
+include-package-data = true
+[tool.setuptools.packages.find]
+include = ["py_flexo*"]
+exclude = ["static*", "templates*", "tests*"]
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"

py_flexo-0.1.0/setup.cfg ADDED Viewed

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