vialframe 0.1.0__tar.gz

vialframe-0.1.0/LICENSE

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

vialframe-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: vialframe
+Version: 0.1.0
+Summary: A simple Python Web Framework for building web applications.
+Home-page: https://github.com/Alimov-8/vial
+Author: Abdullokh Alimov
+Author-email: abdullokh@alimov.io
+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.13.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: webob
+Requires-Dist: parse
+Requires-Dist: requests
+Requires-Dist: Jinja2
+Requires-Dist: whitenoise
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# 🧪 Vial
+A simple Python Web Framework for building web applications.
+
+![img.png](img.png)
+
+---
+
+**WSGI** (Web Server Gateway Interface) is simply a bridge or translator that lets Python web applications talk to web servers ([PEP 3333](https://peps.python.org/pep-3333/)).
+In Python web development, we need WSGI because Python web applications cannot natively talk to traditional web servers like Nginx, Apache, or IIS.
+Without a standard interface like WSGI, every web framework would need custom code for every web server, creating severe ecosystem fragmentation.
+
+---
+
+**How WSGI Works in Vial?** When a user sends an HTTP request to application:
+1. The WSGI Server receives the incoming HTTP request.
+2. The server constructs the environ dictionary and calls Vial application instance.
+3. Vial parses the environ data, routes the request to the matching controller or handler, processes view logic, and prepares a response.
+4. Vial invokes start_response(status, headers) and returns the response body as an iterable (typically a list of bytes).
+5. The WSGI Server formats the raw HTTP response and sends it back to the client's browser.
+
+### Steps for Building Framework
+1. Setup WSGI
+2. Add request and response
+3. Add routing
+4. Add function-based and class-based handlers.
+5. Add unit tests
+6. Add Django style routing
+7. Add templates
+8. Add custom exception handler
+9. Add static files
+10. Add middlewares
+11. Add allowed methods to function based handlers
+12. Add custom responses for webob
+13. Upload to PyPi
+
+#### Resources
+- [PEP 3333 – Python Web Server Gateway Interface](https://peps.python.org/pep-3333/)
+- [WebOb WSGI request and response objects](https://webob.org/)
+- [Parse strings using a specification based on the Python format() syntax.](https://pypi.org/project/parse/)
+- [Pytest: helps you write better programs](https://docs.pytest.org/en/stable/)
+- [Requests: HTTP for Humans](https://requests.readthedocs.io/en/latest/)
+- [Requests for Unit Tests](https://github.com/seanbrant/requests-wsgi-adapter)
+- [Pytest coverage](https://pypi.org/project/pytest-cov/)
+- [Jinja is a fast, expressive, extensible templating engine.](https://jinja.palletsprojects.com/en/stable/)
+- [Radically simplified static file serving for Python web apps](https://whitenoise.readthedocs.io/en/latest/)
+- [Setup.py for Humans](https://github.com/navdeep-G/setup.py)
+- [Twine is a utility for publishing Python packages to PyPI](https://twine.readthedocs.io/en/latest/)

vialframe-0.1.0/README.md

@@ -0,0 +1,47 @@
+# 🧪 Vial
+A simple Python Web Framework for building web applications.
+
+![img.png](img.png)
+
+---
+
+**WSGI** (Web Server Gateway Interface) is simply a bridge or translator that lets Python web applications talk to web servers ([PEP 3333](https://peps.python.org/pep-3333/)).
+In Python web development, we need WSGI because Python web applications cannot natively talk to traditional web servers like Nginx, Apache, or IIS.
+Without a standard interface like WSGI, every web framework would need custom code for every web server, creating severe ecosystem fragmentation.
+
+---
+
+**How WSGI Works in Vial?** When a user sends an HTTP request to application:
+1. The WSGI Server receives the incoming HTTP request.
+2. The server constructs the environ dictionary and calls Vial application instance.
+3. Vial parses the environ data, routes the request to the matching controller or handler, processes view logic, and prepares a response.
+4. Vial invokes start_response(status, headers) and returns the response body as an iterable (typically a list of bytes).
+5. The WSGI Server formats the raw HTTP response and sends it back to the client's browser.
+
+### Steps for Building Framework
+1. Setup WSGI
+2. Add request and response
+3. Add routing
+4. Add function-based and class-based handlers.
+5. Add unit tests
+6. Add Django style routing
+7. Add templates
+8. Add custom exception handler
+9. Add static files
+10. Add middlewares
+11. Add allowed methods to function based handlers
+12. Add custom responses for webob
+13. Upload to PyPi
+
+#### Resources
+- [PEP 3333 – Python Web Server Gateway Interface](https://peps.python.org/pep-3333/)
+- [WebOb WSGI request and response objects](https://webob.org/)
+- [Parse strings using a specification based on the Python format() syntax.](https://pypi.org/project/parse/)
+- [Pytest: helps you write better programs](https://docs.pytest.org/en/stable/)
+- [Requests: HTTP for Humans](https://requests.readthedocs.io/en/latest/)
+- [Requests for Unit Tests](https://github.com/seanbrant/requests-wsgi-adapter)
+- [Pytest coverage](https://pypi.org/project/pytest-cov/)
+- [Jinja is a fast, expressive, extensible templating engine.](https://jinja.palletsprojects.com/en/stable/)
+- [Radically simplified static file serving for Python web apps](https://whitenoise.readthedocs.io/en/latest/)
+- [Setup.py for Humans](https://github.com/navdeep-G/setup.py)
+- [Twine is a utility for publishing Python packages to PyPI](https://twine.readthedocs.io/en/latest/)

vialframe-0.1.0/setup.cfg

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

vialframe-0.1.0/setup.py

@@ -0,0 +1,135 @@
+#!/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
+
+NAME = 'vialframe'
+DESCRIPTION = 'A simple Python Web Framework for building web applications.'
+URL = 'https://github.com/Alimov-8/vial'
+EMAIL = 'abdullokh@alimov.io'
+AUTHOR = 'Abdullokh Alimov'
+REQUIRES_PYTHON = '>=3.13.2'
+VERSION = '0.1.0'
+
+# What packages are required for this module to be executed?
+REQUIRED = [
+    'webob',
+    'parse',
+    'requests',
+    'Jinja2',
+    'whitenoise',
+]
+
+
+# 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,
+    },
+)

vialframe-0.1.0/vial/app.py

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

vialframe-0.1.0/vial/middleware.py

@@ -0,0 +1,19 @@
+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

vialframe-0.1.0/vial/response.py

@@ -0,0 +1,35 @@
+import json
+
+from webob import Response as WebobResponse
+
+
+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 is not None:
+            self.body = json.dumps(self.json).encode()
+            self.content_type = "application/json"
+
+        if self.html is not None:
+            self.body = self.html.encode()
+            self.content_type = "text/html"
+
+        if self.text is not None:
+            self.body = self.text
+            self.content_type = "text/plain"
+
+    def __call__(self, environ, start_response):
+        self.set_body_and_content_type()
+
+        response = WebobResponse(
+            body=self.body, content_type=self.content_type, status=self.status_code,
+        )
+
+        return response(environ, start_response)

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

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: vialframe
+Version: 0.1.0
+Summary: A simple Python Web Framework for building web applications.
+Home-page: https://github.com/Alimov-8/vial
+Author: Abdullokh Alimov
+Author-email: abdullokh@alimov.io
+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.13.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: webob
+Requires-Dist: parse
+Requires-Dist: requests
+Requires-Dist: Jinja2
+Requires-Dist: whitenoise
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# 🧪 Vial
+A simple Python Web Framework for building web applications.
+
+![img.png](img.png)
+
+---
+
+**WSGI** (Web Server Gateway Interface) is simply a bridge or translator that lets Python web applications talk to web servers ([PEP 3333](https://peps.python.org/pep-3333/)).
+In Python web development, we need WSGI because Python web applications cannot natively talk to traditional web servers like Nginx, Apache, or IIS.
+Without a standard interface like WSGI, every web framework would need custom code for every web server, creating severe ecosystem fragmentation.
+
+---
+
+**How WSGI Works in Vial?** When a user sends an HTTP request to application:
+1. The WSGI Server receives the incoming HTTP request.
+2. The server constructs the environ dictionary and calls Vial application instance.
+3. Vial parses the environ data, routes the request to the matching controller or handler, processes view logic, and prepares a response.
+4. Vial invokes start_response(status, headers) and returns the response body as an iterable (typically a list of bytes).
+5. The WSGI Server formats the raw HTTP response and sends it back to the client's browser.
+
+### Steps for Building Framework
+1. Setup WSGI
+2. Add request and response
+3. Add routing
+4. Add function-based and class-based handlers.
+5. Add unit tests
+6. Add Django style routing
+7. Add templates
+8. Add custom exception handler
+9. Add static files
+10. Add middlewares
+11. Add allowed methods to function based handlers
+12. Add custom responses for webob
+13. Upload to PyPi
+
+#### Resources
+- [PEP 3333 – Python Web Server Gateway Interface](https://peps.python.org/pep-3333/)
+- [WebOb WSGI request and response objects](https://webob.org/)
+- [Parse strings using a specification based on the Python format() syntax.](https://pypi.org/project/parse/)
+- [Pytest: helps you write better programs](https://docs.pytest.org/en/stable/)
+- [Requests: HTTP for Humans](https://requests.readthedocs.io/en/latest/)
+- [Requests for Unit Tests](https://github.com/seanbrant/requests-wsgi-adapter)
+- [Pytest coverage](https://pypi.org/project/pytest-cov/)
+- [Jinja is a fast, expressive, extensible templating engine.](https://jinja.palletsprojects.com/en/stable/)
+- [Radically simplified static file serving for Python web apps](https://whitenoise.readthedocs.io/en/latest/)
+- [Setup.py for Humans](https://github.com/navdeep-G/setup.py)
+- [Twine is a utility for publishing Python packages to PyPI](https://twine.readthedocs.io/en/latest/)

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+vial/__init__.py
+vial/app.py
+vial/middleware.py
+vial/response.py
+vialframe.egg-info/PKG-INFO
+vialframe.egg-info/SOURCES.txt
+vialframe.egg-info/dependency_links.txt
+vialframe.egg-info/requires.txt
+vialframe.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,5 @@
+webob
+parse
+requests
+Jinja2
+whitenoise

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

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