pyframex7 0.1.0__tar.gz

pyframex7-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: pyframex7
+Version: 0.1.0
+Summary: This is simple python web framework which written for learning purposes
+Home-page: https://github.com/Abduqodir7007/custom-framework
+Author: Abduqodir Arifjanov
+Author-email: abdukodirarifzanov@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6.0
+Description-Content-Type: text/markdown
+Requires-Dist: gunicorn==25.1.0
+Requires-Dist: webob==1.8.9
+Requires-Dist: requests==2.32.5
+Requires-Dist: requests-wsgi-adapter==0.4.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+
+![Purpose](https://img.shields.io/badge/purpose-learning-blue)
+![Status](https://img.shields.io/badge/status-experimental-orange)
+
+> **PyFrame can be downloaded and installed from [PyPI](https://pypi.org/project/pyframe/).**
+
+# PyFrame
+
+PyFrame is a custom Python web framework created for learning purposes. 
+
+## Features
+- Minimal and easy to understand
+- Custom middleware support
+- Simple request/response handling
+- Supports both class-based and function-based handlers
+- Designed for educational use
+
+## Installation
+
+You can install PyFrame locally by cloning this repository and installing it in editable mode:
+
+
+PyFrame supports both function-based and class-based handlers for defining routes.
+
+### Function-Based Handler Example
+```python
+from app import App
+from response import Response
+
+app = App()
+
+@app.route("/")
+def home(request):
+    return Response("Hello, World!")
+
+```
+
+### Class-Based Handler Example
+```python
+from app import App, Handler
+from response import Response
+
+app = App()
+
+class HelloHandler(Handler):
+    def get(self, request):
+        return Response("Hello from class-based handler!")
+
+app.add_route("/hello", HelloHandler)
+```
+
+- Define your routes using the `@app.route` decorator for function-based handlers or `app.add_route` for class-based handlers.
+- Return a `Response` object from your route handlers.
+- Run your application with `app.run()`.
+    app.run()
+```
+
+- Define your routes using the `@app.route` decorator.
+- Return a `Response` object from your route handlers.
+- Run your application with `app.run()`.
+
+
+## Use Cases
+- Learning how web frameworks work
+- Experimenting with middleware and routing
+- Building simple web applications for educational purposes
+
+## License
+This project is for learning and educational purposes only.

pyframex7-0.1.0/README.md

@@ -0,0 +1,69 @@
+
+![Purpose](https://img.shields.io/badge/purpose-learning-blue)
+![Status](https://img.shields.io/badge/status-experimental-orange)
+
+> **PyFrame can be downloaded and installed from [PyPI](https://pypi.org/project/pyframe/).**
+
+# PyFrame
+
+PyFrame is a custom Python web framework created for learning purposes. 
+
+## Features
+- Minimal and easy to understand
+- Custom middleware support
+- Simple request/response handling
+- Supports both class-based and function-based handlers
+- Designed for educational use
+
+## Installation
+
+You can install PyFrame locally by cloning this repository and installing it in editable mode:
+
+
+PyFrame supports both function-based and class-based handlers for defining routes.
+
+### Function-Based Handler Example
+```python
+from app import App
+from response import Response
+
+app = App()
+
+@app.route("/")
+def home(request):
+    return Response("Hello, World!")
+
+```
+
+### Class-Based Handler Example
+```python
+from app import App, Handler
+from response import Response
+
+app = App()
+
+class HelloHandler(Handler):
+    def get(self, request):
+        return Response("Hello from class-based handler!")
+
+app.add_route("/hello", HelloHandler)
+```
+
+- Define your routes using the `@app.route` decorator for function-based handlers or `app.add_route` for class-based handlers.
+- Return a `Response` object from your route handlers.
+- Run your application with `app.run()`.
+    app.run()
+```
+
+- Define your routes using the `@app.route` decorator.
+- Return a `Response` object from your route handlers.
+- Run your application with `app.run()`.
+
+
+## Use Cases
+- Learning how web frameworks work
+- Experimenting with middleware and routing
+- Building simple web applications for educational purposes
+
+## License
+This project is for learning and educational purposes only.

pyframex7-0.1.0/pyframe/app.py

@@ -0,0 +1,108 @@
+import inspect
+import requests
+import wsgiadapter
+from parse import parse
+from webob import Request
+from .response import Response
+from .middleware import Middleware
+from typing import List
+
+
+class PyFramework:
+    def __init__(self) -> None:
+        self.routes = dict()
+        self.exception_handler = None
+        self.middleware = Middleware(self)
+
+    def __call__(self, environ, start_response):
+        # status = "200 CREATED"
+
+        # response_header = [("Content-type", "text/plain")]
+        # start_response(status, response_header)
+        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 add_exception_handler(self, handler):
+        self.exception_handler = handler
+
+    def handle_request(self, request):
+        response = Response()
+
+        handler, kwargs, allowed_methods = self.find_handler(request)
+
+        if inspect.isclass(handler):
+
+            handler_method = getattr(handler(), request.method.lower(), None)
+
+            if handler_method is None:
+                return self.method_not_allowed_response(request, response)
+            try:
+                handler_method(request, response, **kwargs)
+            except Exception as e:
+                if self.exception_handler is not None:
+                    self.exception_handler(request, response, e)
+                else:
+                    raise e
+        elif inspect.isfunction(handler):
+            try:
+                if request.method.lower() not in allowed_methods:
+                    return self.method_not_allowed_response(request, response)
+
+                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, request):
+        allowed_method = None
+        for path, handler in self.routes.items():
+            handler, allowed_method = handler
+
+            result = parse(path, request.path)
+
+            if result is not None:
+                return handler, result.named, allowed_method
+
+        return None, None, allowed_method
+
+    def add_middleware(self, middleware_class):
+        self.middleware.add(middleware_class)
+
+    def default_response(self, response):
+        response.status_code = 404
+        response.text = "Not found"
+
+    def method_not_allowed_response(self, request, response):
+        response.text = "METHOD NOT ALLOWED"
+        response.status_code = 405
+        return response
+
+    def router(self, path: str, allowed_methods: List[str] = ["get"]):
+        assert path not in self.routes, f"Path {path} already exists"
+
+        def wrapper(handler):
+            self.routes[path] = (handler, allowed_methods)
+            return handler
+
+        return wrapper
+
+    def add_router(self, path, handler, allowed_methods: List[str] = ["get"]):
+        assert path not in self.routes, f"Path {path} already exists"
+        self.routes[path] = (handler, allowed_methods)
+
+    def test_session(self):
+        session = requests.Session()
+        session.mount("http://testserver", wsgiadapter.WSGIAdapter(self))
+        return session

pyframex7-0.1.0/pyframe/middleware.py

@@ -0,0 +1,30 @@
+from webob import Request, Response
+from typing import Any
+
+
+class Middleware:
+    def __init__(self, app):
+        self.app = app
+
+    def add(self, middleware_class):
+        self.app = middleware_class(self.app)
+
+    def process_request(self, request):
+        pass
+
+    def process_response(self, request, response):
+        pass
+
+    def handle_request(self, request):
+        self.process_request(request)
+        response = self.app.handle_request(request)
+        self.process_response(request, response)
+
+        return response
+    
+    def __call__(self, environ, start_response):
+        request = Request(environ)
+        response = self.app.handle_request(request)
+
+        return response(environ, start_response)
+        

pyframex7-0.1.0/pyframe/response.py

@@ -0,0 +1,31 @@
+import json
+from typing import Any
+
+from webob import Response as WebobResponse
+
+
+class Response:
+    def __init__(self) -> None:
+        self.json = None
+        self.text = None
+        self.content_type = None
+        self.body = b""
+        self.status_code = 200
+
+    def change_response(self):
+
+        if self.json is not None:
+            self.body = json.dumps(self.json).encode()
+            self.content_type = "application/json"
+
+        if self.text is not None:
+            self.body = self.text
+            self.content_type = "text/plain"
+
+    def __call__(self, environ, start_response) -> Any:
+        self.change_response()
+        response = WebobResponse(
+            body=self.body, status=self.status_code, content_type=self.content_type
+        )
+
+        return response(environ, start_response)

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

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: pyframex7
+Version: 0.1.0
+Summary: This is simple python web framework which written for learning purposes
+Home-page: https://github.com/Abduqodir7007/custom-framework
+Author: Abduqodir Arifjanov
+Author-email: abdukodirarifzanov@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6.0
+Description-Content-Type: text/markdown
+Requires-Dist: gunicorn==25.1.0
+Requires-Dist: webob==1.8.9
+Requires-Dist: requests==2.32.5
+Requires-Dist: requests-wsgi-adapter==0.4.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+
+![Purpose](https://img.shields.io/badge/purpose-learning-blue)
+![Status](https://img.shields.io/badge/status-experimental-orange)
+
+> **PyFrame can be downloaded and installed from [PyPI](https://pypi.org/project/pyframe/).**
+
+# PyFrame
+
+PyFrame is a custom Python web framework created for learning purposes. 
+
+## Features
+- Minimal and easy to understand
+- Custom middleware support
+- Simple request/response handling
+- Supports both class-based and function-based handlers
+- Designed for educational use
+
+## Installation
+
+You can install PyFrame locally by cloning this repository and installing it in editable mode:
+
+
+PyFrame supports both function-based and class-based handlers for defining routes.
+
+### Function-Based Handler Example
+```python
+from app import App
+from response import Response
+
+app = App()
+
+@app.route("/")
+def home(request):
+    return Response("Hello, World!")
+
+```
+
+### Class-Based Handler Example
+```python
+from app import App, Handler
+from response import Response
+
+app = App()
+
+class HelloHandler(Handler):
+    def get(self, request):
+        return Response("Hello from class-based handler!")
+
+app.add_route("/hello", HelloHandler)
+```
+
+- Define your routes using the `@app.route` decorator for function-based handlers or `app.add_route` for class-based handlers.
+- Return a `Response` object from your route handlers.
+- Run your application with `app.run()`.
+    app.run()
+```
+
+- Define your routes using the `@app.route` decorator.
+- Return a `Response` object from your route handlers.
+- Run your application with `app.run()`.
+
+
+## Use Cases
+- Learning how web frameworks work
+- Experimenting with middleware and routing
+- Building simple web applications for educational purposes
+
+## License
+This project is for learning and educational purposes only.

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

@@ -0,0 +1,12 @@
+README.md
+setup.py
+pyframe/__init__.py
+pyframe/app.py
+pyframe/middleware.py
+pyframe/response.py
+pyframex7.egg-info/PKG-INFO
+pyframex7.egg-info/SOURCES.txt
+pyframex7.egg-info/dependency_links.txt
+pyframex7.egg-info/requires.txt
+pyframex7.egg-info/top_level.txt
+tests/test_app.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,4 @@
+gunicorn==25.1.0
+webob==1.8.9
+requests==2.32.5
+requests-wsgi-adapter==0.4.1

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

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

pyframex7-0.1.0/setup.cfg

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

pyframex7-0.1.0/setup.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Note: To use the 'upload' functionality of this file, you must:
+#   $ pipenv install twine --dev
+
+import io
+import os
+import sys
+from shutil import rmtree
+
+from setuptools import find_packages, setup, Command
+
+# Package meta-data.
+NAME = 'pyframex7'
+DESCRIPTION = 'This is simple python web framework which written for learning purposes'
+URL = 'https://github.com/Abduqodir7007/custom-framework'
+EMAIL = 'abdukodirarifzanov@gmail.com'
+AUTHOR = 'Abduqodir Arifjanov'
+REQUIRES_PYTHON = '>=3.6.0'
+VERSION = '0.1.0'
+
+# What packages are required for this module to be executed?
+REQUIRED = [
+    'gunicorn==25.1.0',
+    'webob==1.8.9',
+    'requests==2.32.5',
+    'requests-wsgi-adapter==0.4.1',
+]
+
+# What packages are optional?
+EXTRAS = {
+    # 'fancy feature': ['django'],
+}
+
+# The rest you shouldn't have to touch too much :)
+# ------------------------------------------------
+# Except, perhaps the License and Trove Classifiers!
+# If you do change the License, remember to change the Trove Classifier for that!
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+# Import the README and use it as the long-description.
+# Note: this will only work if 'README.md' is present in your MANIFEST.in file!
+try:
+    with io.open(os.path.join(here, 'README.md'), encoding='utf-8') as f:
+        long_description = '\n' + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+# Load the package's __version__.py module as a dictionary.
+about = {}
+if not VERSION:
+    project_slug = NAME.lower().replace("-", "_").replace(" ", "_")
+    with open(os.path.join(here, project_slug, '__version__.py')) as f:
+        exec(f.read(), about)
+else:
+    about['__version__'] = VERSION
+
+
+class UploadCommand(Command):
+    """Support setup.py upload."""
+
+    description = 'Build and publish the package.'
+    user_options = []
+
+    @staticmethod
+    def status(s):
+        """Prints things in bold."""
+        print('\033[1m{0}\033[0m'.format(s))
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        try:
+            self.status('Removing previous builds…')
+            rmtree(os.path.join(here, 'dist'))
+        except OSError:
+            pass
+
+        self.status('Building Source and Wheel (universal) distribution…')
+        os.system('{0} setup.py sdist bdist_wheel --universal'.format(sys.executable))
+
+        self.status('Uploading the package to PyPI via Twine…')
+        os.system('twine upload dist/*')
+
+        self.status('Pushing git tags…')
+        os.system('git tag v{0}'.format(about['__version__']))
+        os.system('git push --tags')
+
+        sys.exit()
+
+
+# Where the magic happens:
+setup(
+    name=NAME,
+    version=about['__version__'],
+    description=DESCRIPTION,
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    author=AUTHOR,
+    author_email=EMAIL,
+    python_requires=REQUIRES_PYTHON,
+    url=URL,
+    packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]),
+    # If your package is a single module, use this instead of 'packages':
+    # py_modules=['mypackage'],
+
+    # entry_points={
+    #     'console_scripts': ['mycli=mymodule:cli'],
+    # },
+    install_requires=REQUIRED,
+    extras_require=EXTRAS,
+    include_package_data=True,
+    license='MIT',
+    classifiers=[
+        # Trove classifiers
+        # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'Programming Language :: Python :: Implementation :: PyPy'
+    ],
+    # $ setup.py publish support.
+    cmdclass={
+        'upload': UploadCommand,
+    },
+)

pyframex7-0.1.0/tests/test_app.py

@@ -0,0 +1,182 @@
+import pytest
+import json
+from pyframe.middleware import Middleware
+from tests.conftest import app, test_client
+from pyframe.app import PyFramework
+
+
+class TestApp:
+    def test_route_registration(self, app: PyFramework):
+
+        @app.router("/home/")
+        def home(request, response):
+            response.text = "Hello from home"
+
+    def test_duplicate_route_registration(self, app: PyFramework):
+
+        @app.router("/home/")
+        def home(request, response):
+            response.text = "Hello from home"
+
+        with pytest.raises(Exception):
+
+            @app.router("/home/")
+            def home2(request, response):
+                response.text = "Hello from home"
+
+    def test_client(self, app: PyFramework, test_client):
+
+        @app.router("/home/")
+        def home(request, response):
+            response.text = "Hello from home"
+
+        res = test_client.get("http://testserver/home/")
+
+        assert res.text == "Hello from home"
+
+    def test_parametized_routing(self, app: PyFramework, test_client):
+
+        @app.router("/home/{name}/")
+        def home(request, response, name):
+            response.text = f"Hello {name}"
+
+        res = test_client.get("http://testserver/home/john/")
+
+        assert res.text == "Hello john"
+
+    def test_wrong_routes(self, test_client):
+
+        res = test_client.get("http://testserver/home/")
+
+        assert res.text == "Not found"
+        assert res.status_code == 404
+
+    def test_class_based_get_routing(self, app, test_client):
+
+        @app.router("/book/")
+        class Book:
+
+            def get(self, request, response):
+                response.text = "Getting books"
+
+        res1 = test_client.get("http://testserver/book/")
+        res2 = test_client.post("http://testserver/book/")
+
+        assert res1.text == "Getting books"
+        assert res2.text == "METHOD NOT ALLOWED"
+        assert res2.status_code == 405
+
+    def test_django_like_routing(self, app, test_client):
+
+        def book(request, response):
+            response.text = "Hello from book"
+
+        app.add_router("/book/", book)
+        res = test_client.get("http://testserver/book/")
+
+        assert res.text == "Hello from book"
+
+    def test_custom_exception_handler(self, app: PyFramework, test_client):
+
+        def on_exception(request, response, exp_class):
+            response.text = "Something went wrong"
+
+        app.add_exception_handler(on_exception)
+
+        @app.router("/exception/")
+        def exception(request, response):
+            raise AttributeError("some exception")
+
+        res = test_client.get("http://testserver/exception/")
+
+        assert res.text == "Something went wrong"
+
+    def test_custom_exception_handler_witj_class_based_router(
+        self, app: PyFramework, test_client
+    ):
+
+        def on_exception(request, response, exception):
+            response.text = "Exception from class"
+
+        app.add_exception_handler(on_exception)
+
+        @app.router("/book/")
+        class Book:
+
+            def get(self, request, response):
+                raise AttributeError("Error")
+
+        res = test_client.get("http://testserver/book/")
+
+        assert res.text == "Exception from class"
+
+    def test_middleware_methods_are_called(self, app: PyFramework, test_client):
+        is_process_request_called = False
+        is_process_response_called = False
+
+        class SimpleMiddleware(Middleware):
+            def __init__(self, app):
+                super().__init__(app)
+
+            def process_request(self, request):
+
+                nonlocal is_process_request_called
+                is_process_request_called = True
+
+            def process_response(self, request, response):
+                nonlocal is_process_response_called
+                is_process_response_called = True
+
+        app.add_middleware(SimpleMiddleware)
+
+        @app.router("/home/")
+        def home(request, response):
+            response.text = "Hello from middleware"
+
+        res = test_client.get("http://testserver/home/")
+
+        assert is_process_response_called is True
+        assert is_process_request_called is True
+
+    def test_function_based_allowed_method(self, app: PyFramework, test_client):
+
+        @app.router("/book/", allowed_methods=["get"])
+        def book(request, response):
+            response.text = "Hello world"
+
+        res = test_client.get("http://testserver/book/")
+
+        assert res.text == "Hello world"
+
+    def test_function_based_allowed_method_with_wrong_method(self, app, test_client):
+
+        @app.router("/book/", allowed_methods=["post"])
+        def book(request, response):
+            response.text = "Checking method allowed"
+
+        res = test_client.get("http://testserver/book/")
+
+        assert res.text == "METHOD NOT ALLOWED"
+
+    def test_json_response(self, app, test_client):
+
+        @app.router("/json")
+        def json_handler(request, response):
+
+            response_data = {"name": "tom", "number": 10}
+
+            response.body = response_data
+            res = test_client.get("http://testserver/json/").json()
+
+            assert res.headers["Content-Type"] == "application/json"
+            assert res.name == "tom"
+
+    def test_text_response(self, app, test_client):
+
+        @app.router("/text/")
+        def text_handler(request, response):
+            response.text = "this is the response"
+
+        res = test_client.get("http://testserver/text/")
+
+        assert "text/plain" in res.headers["Content-Type"]