PyWSGIRef 1.0.0__tar.gz

pywsgiref-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Leander Kafemann
+
+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.

pywsgiref-1.0.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: PyWSGIRef
+Version: 1.0.0
+Summary: display colors in console
+Author-email: Leander Kafemann <leander@kafemann.berlin>
+Project-URL: Homepage, https://github.com/LeanderKafemann/PyWSGIRef
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: typing
+Dynamic: license-file
+
+# PyWSGIRef
+easy server-setup
+## Advantage
+Many web services offer simple ways to set up a WSGI webserver.<br/>
+The built-in WSGI server in Python is, however, not very easy to use.<br/>
+PyWSGIRef provides a simple way to set up a WSGI server with minimal code.<br/><br/>
+Also, a problem with many of those web services is that they aren't able to make web requests<br/>
+and it's very slow to read files once the server is running.<br/>
+PyWSGIRef solves this problem by providing a simple way to load PyHTML files from the web or from the local filesystem<br/>
+before the server is running.<br/><br/>
+PyHTML files are HTML files that can contain {}-s for Python formatting or<br/>
+(upcoming) code blocks or shortened HTML, which can be used to create dynamic HTML content.<br/>
+PyWSGIRef also provides a simple way to decode these.
+## Installation
+### Using *pip*
+You can install PyWSGIRef via pip using
+<li>in a commandline:</li><br/>
+
+```bash
+py -m pip install PyWSGIRef
+```
+<br/>
+<li>in a python script:</li><br/>
+
+```python
+import os
+os.system('py -m pip install PyWSGIRef')
+```
+## Usage
+### Setting up the WSGI server
+```python
+from PyWSGIRef import *
+
+# Create a WSGI application object
+def simple_app(path: str) -> str:
+	return f"Hello, you visited {path}!"
+application = makeWSGIApp(simple_app)
+
+# Create a WSGI server
+server = makeWSGIServer(application, port=8000)
+server.serve_forever()
+```
+The <code>makeWSGIApp</code> function requires a callable that takes a single argument (the path) and returns a string response.<br/>
+The <code>makeWSGIServer</code> function creates a WSGI server that listens on the specified port (default is 8000)<br/>
+and calls the application object with the environ.<br/>
+You can also use your own application object instead of the one created by <code>makeWSGIApp</code>.
+### Loading PyHTML
+PyWSGIRef also provides a simple way to load PyHTML files:
+```python
+from PyWSGIRef import *
+
+# load from file
+html = loadFromFile('index.pyhtml')
+
+# load from web
+html = loadFromWeb('https://example.com/index.pyhtml')
+```
+This is useful for serving dynamic HTML content in your WSGI application.<br/>
+The funcs are callable unless you set up a server.
+### Using Templates
+PyWSGIRef also provides a simple way to use templates in your WSGI application:
+```python
+from PyWSGIRef import *
+
+# add template to template dictionary
+# -> saves as PyHTML object
+addSchablone("index", loadedPyHTMLFile)
+
+# load template from dictionary
+# get HTML code from PyHTML object
+html = SCHABLONEN["index"].decoded()
+# use Python formatting
+serverPageContent = html.format("Hello, World!")
+```
+Note that you may only use the <code>addSchablone</code> function before you set up a server.
+### Default HTML templates
+PyWSGIRef comes with some default HTML templates that you can use in your WSGI application.<br/>
+You can access them via the <code>PyWSGIRef.defaults</code>:
+```python
+from PyWSGIRef import *
+
+# load default HTML template
+addSchablone("hello", HELLO_WORLD)
+addSchablone("error", ERROR)
+```
+### __main__ script
+You may produce a simple WSGI server by using either:<br/>
+```python
+from PyWSGIRef import *
+
+main()
+```
+or (from a commandline)
+```bash
+py -m PyWSGIRef
+```
+### Others
+Use the following to get information about your release and the author of the module:
+```python
+pycols.about()
+```
+### More coming soon

pywsgiref-1.0.0/README.md

@@ -0,0 +1,102 @@
+# PyWSGIRef
+easy server-setup
+## Advantage
+Many web services offer simple ways to set up a WSGI webserver.<br/>
+The built-in WSGI server in Python is, however, not very easy to use.<br/>
+PyWSGIRef provides a simple way to set up a WSGI server with minimal code.<br/><br/>
+Also, a problem with many of those web services is that they aren't able to make web requests<br/>
+and it's very slow to read files once the server is running.<br/>
+PyWSGIRef solves this problem by providing a simple way to load PyHTML files from the web or from the local filesystem<br/>
+before the server is running.<br/><br/>
+PyHTML files are HTML files that can contain {}-s for Python formatting or<br/>
+(upcoming) code blocks or shortened HTML, which can be used to create dynamic HTML content.<br/>
+PyWSGIRef also provides a simple way to decode these.
+## Installation
+### Using *pip*
+You can install PyWSGIRef via pip using
+<li>in a commandline:</li><br/>
+
+```bash
+py -m pip install PyWSGIRef
+```
+<br/>
+<li>in a python script:</li><br/>
+
+```python
+import os
+os.system('py -m pip install PyWSGIRef')
+```
+## Usage
+### Setting up the WSGI server
+```python
+from PyWSGIRef import *
+
+# Create a WSGI application object
+def simple_app(path: str) -> str:
+	return f"Hello, you visited {path}!"
+application = makeWSGIApp(simple_app)
+
+# Create a WSGI server
+server = makeWSGIServer(application, port=8000)
+server.serve_forever()
+```
+The <code>makeWSGIApp</code> function requires a callable that takes a single argument (the path) and returns a string response.<br/>
+The <code>makeWSGIServer</code> function creates a WSGI server that listens on the specified port (default is 8000)<br/>
+and calls the application object with the environ.<br/>
+You can also use your own application object instead of the one created by <code>makeWSGIApp</code>.
+### Loading PyHTML
+PyWSGIRef also provides a simple way to load PyHTML files:
+```python
+from PyWSGIRef import *
+
+# load from file
+html = loadFromFile('index.pyhtml')
+
+# load from web
+html = loadFromWeb('https://example.com/index.pyhtml')
+```
+This is useful for serving dynamic HTML content in your WSGI application.<br/>
+The funcs are callable unless you set up a server.
+### Using Templates
+PyWSGIRef also provides a simple way to use templates in your WSGI application:
+```python
+from PyWSGIRef import *
+
+# add template to template dictionary
+# -> saves as PyHTML object
+addSchablone("index", loadedPyHTMLFile)
+
+# load template from dictionary
+# get HTML code from PyHTML object
+html = SCHABLONEN["index"].decoded()
+# use Python formatting
+serverPageContent = html.format("Hello, World!")
+```
+Note that you may only use the <code>addSchablone</code> function before you set up a server.
+### Default HTML templates
+PyWSGIRef comes with some default HTML templates that you can use in your WSGI application.<br/>
+You can access them via the <code>PyWSGIRef.defaults</code>:
+```python
+from PyWSGIRef import *
+
+# load default HTML template
+addSchablone("hello", HELLO_WORLD)
+addSchablone("error", ERROR)
+```
+### __main__ script
+You may produce a simple WSGI server by using either:<br/>
+```python
+from PyWSGIRef import *
+
+main()
+```
+or (from a commandline)
+```bash
+py -m PyWSGIRef
+```
+### Others
+Use the following to get information about your release and the author of the module:
+```python
+pycols.about()
+```
+### More coming soon

pywsgiref-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "PyWSGIRef"
+version = "1.0.0"
+authors = [
+  {name="Leander Kafemann", email="leander@kafemann.berlin" },
+]
+description = "display colors in console"
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+	"requests",
+    "typing",
+]
+
+[project.urls]
+Homepage = "https://github.com/LeanderKafemann/PyWSGIRef"

pywsgiref-1.0.0/setup.cfg

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

pywsgiref-1.0.0/src/PyWSGIRef/__init__.py

@@ -0,0 +1,81 @@
+"""
+PYWSGIREF
+"""
+from typing import Callable
+import requests
+from wsgiref.simple_server import make_server, WSGIServer
+
+from .exceptions import *
+from .pyhtml import PyHTML
+from .defaults import *
+
+def about():
+    """
+    Returns information about your release and other projects by LK
+    """
+    return {"Version":(1, 0, 0), "Author":"Leander Kafemann", "date":"07.06.2025",\
+            "recommend":("Büro by LK",  "pyimager by LK", "naturalsize by LK"), "feedbackTo": "leander@kafemann.berlin"}
+
+SCHABLONEN = {}
+finished = False
+
+def loadFromWeb(url: str, data: dict = {}) -> str:
+    """
+    Loads content from the given URL with the given data.
+    """
+    if finished:
+        raise ServerAlreadyGeneratedError()
+    if not url.endswith(".pyhtml"):
+        raise InvalidFiletypeError()
+    rq = requests.post(url, data).content
+    return rq.decode()
+
+def loadFromFile(filename: str) -> str:
+    """
+    Loads a file from the given filename.
+    """
+    if finished:
+        raise ServerAlreadyGeneratedError()
+    if not filename.endswith(".pyhtml"):
+        raise InvalidFiletypeError()
+    with open(filename, "r", encoding="utf-8") as f:
+        content = f.read()
+    return content
+
+def addSchablone(name: str, content: str):
+    """
+    Adds a template to the SCHABLONEN dictionary.
+    """
+    global SCHABLONEN
+    SCHABLONEN += {name: PyHTML(content)}
+
+def makeApplicationObject(contentGeneratingFunction: Callable) -> Callable:
+    """
+    Returns a WSGI application object based on your contentGeneratingFunction.
+    The contentGeneratingFunction should take a single argument (the path) and return the content as a string.
+    """
+    if not callable(contentGeneratingFunction):
+        raise InvalidCallableError()
+    def simpleApplication(environ, start_response) -> list:
+        """
+        A simple WSGI application object that serves as a template.
+        """
+        type_ = "text/html" 
+        status = "200 OK"
+        content = contentGeneratingFunction(environ["PATH_INFO"])
+        headers = [("Content-Type", type_),
+                   ("Content-Length", str(len(content))),
+                   ('Access-Control-Allow-Origin', '*')]
+        start_response(status, headers)
+        return [content.encode("utf-8")]
+    return simpleApplication
+
+def setUpServer(application: Callable) -> WSGIServer:
+    """
+    Creates a WSGI server.
+    No additional Schablonen can be loaded from the web.
+    """
+    global finished
+    finished = True
+    server = make_server('', 8000, application)
+    return server

pywsgiref-1.0.0/src/PyWSGIRef/__main__.py

@@ -0,0 +1,53 @@
+"""
+Set up and run the PyWSGIRef server with a simple HTML response.
+"""
+from PyWSGIRef import *
+
+def main():
+    """
+    Main function to set up and run the PyWSGIRef server.
+    """
+    # define main html response
+    MAIN_HTML = """<!DOCTYPE html>
+    <html lang="de">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>PyWSGIRef Server</title>
+        </head>
+        <body>
+            <h1>Willkommen zum PyWSGIRef Server!</h1>
+            <p>Dies ist die Hauptseite des Servers.</p>
+            <p>Sie nutzen Version {} von PyWSGIRef.</p>
+        </body>
+    </html>"""
+
+    # add Schablone 'Hallo Welt' as main
+    addSchablone("main", MAIN_HTML)
+
+    # set up application object
+    def contentGenerator(path: str) -> str:
+        """
+        Serves as the main WSGI application.
+        """
+        match path:
+            case "/":
+                content = SCHABLONEN["main"].decoded().format(about()["Version"])
+            case "/hello":
+                content = HELLO_WORLD
+            case _:
+                content = ERROR
+        return content
+
+    # make the application object
+    application = makeApplicationObject(contentGenerator)
+
+    # set up server
+    server = setUpServer(application)
+    server.serve_forever()
+
+    # Note: This code is intended to be run as a script, not as a module.
+    print("Successfully started WSGI server on port 8000.")
+
+if __name__ == "__main__":
+    main()

pywsgiref-1.0.0/src/PyWSGIRef/defaults.py

@@ -0,0 +1,14 @@
+HELLO_WORLD = """<!DOCTYPE html>
+<html lang"de">
+    <body>
+        <h1>Hallo Welt!</h1>
+    </body>
+<html>"""
+
+ERROR = """<!DOCTYPE html>
+<html lang"de">
+    <body>
+        <h1>Fehler!</h1>
+        <p>Es ist ein Fehler aufgetreten.</p>
+    </body>
+</html>"""

pywsgiref-1.0.0/src/PyWSGIRef/exceptions.py

@@ -0,0 +1,24 @@
+class ServerAlreadyGeneratedError(Exception):
+    """
+    Raised when a server is already generated,
+    so that further modifications are not allowed.
+    """
+    def __init__(self, message="Server has already been generated."):
+        self.message = message
+        super().__init__(self.message)
+
+class InvalidFiletypeError(Exception):
+    """
+    Raised when an invalid file type (not PyHTML) is encountered.
+    """
+    def __init__(self, message="Invalid file type. Only .pyhtml files are allowed."):
+        self.message = message
+        super().__init__(self.message)
+
+class InvalidCallableError(Exception):
+    """
+    Raised when a callable is expected but not provided.
+    """
+    def __init__(self, message="Expected a callable object."):
+        self.message = message
+        super().__init__(self.message)

pywsgiref-1.0.0/src/PyWSGIRef/pyhtml.py

@@ -0,0 +1,16 @@
+from .defaults import HELLO_WORLD as DEFAULT
+
+class PyHTML:
+    def __init__(self, html: str = DEFAULT):
+        self.html = html
+    def decode(self):
+        """
+        Decodes the HTML content.
+        """
+        self.html = self.html.strip()
+    def decoded(self) -> str:
+        """
+        Returns the decoded HTML content.
+        """
+        self.decode()
+        return self.html

pywsgiref-1.0.0/src/PyWSGIRef.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: PyWSGIRef
+Version: 1.0.0
+Summary: display colors in console
+Author-email: Leander Kafemann <leander@kafemann.berlin>
+Project-URL: Homepage, https://github.com/LeanderKafemann/PyWSGIRef
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: typing
+Dynamic: license-file
+
+# PyWSGIRef
+easy server-setup
+## Advantage
+Many web services offer simple ways to set up a WSGI webserver.<br/>
+The built-in WSGI server in Python is, however, not very easy to use.<br/>
+PyWSGIRef provides a simple way to set up a WSGI server with minimal code.<br/><br/>
+Also, a problem with many of those web services is that they aren't able to make web requests<br/>
+and it's very slow to read files once the server is running.<br/>
+PyWSGIRef solves this problem by providing a simple way to load PyHTML files from the web or from the local filesystem<br/>
+before the server is running.<br/><br/>
+PyHTML files are HTML files that can contain {}-s for Python formatting or<br/>
+(upcoming) code blocks or shortened HTML, which can be used to create dynamic HTML content.<br/>
+PyWSGIRef also provides a simple way to decode these.
+## Installation
+### Using *pip*
+You can install PyWSGIRef via pip using
+<li>in a commandline:</li><br/>
+
+```bash
+py -m pip install PyWSGIRef
+```
+<br/>
+<li>in a python script:</li><br/>
+
+```python
+import os
+os.system('py -m pip install PyWSGIRef')
+```
+## Usage
+### Setting up the WSGI server
+```python
+from PyWSGIRef import *
+
+# Create a WSGI application object
+def simple_app(path: str) -> str:
+	return f"Hello, you visited {path}!"
+application = makeWSGIApp(simple_app)
+
+# Create a WSGI server
+server = makeWSGIServer(application, port=8000)
+server.serve_forever()
+```
+The <code>makeWSGIApp</code> function requires a callable that takes a single argument (the path) and returns a string response.<br/>
+The <code>makeWSGIServer</code> function creates a WSGI server that listens on the specified port (default is 8000)<br/>
+and calls the application object with the environ.<br/>
+You can also use your own application object instead of the one created by <code>makeWSGIApp</code>.
+### Loading PyHTML
+PyWSGIRef also provides a simple way to load PyHTML files:
+```python
+from PyWSGIRef import *
+
+# load from file
+html = loadFromFile('index.pyhtml')
+
+# load from web
+html = loadFromWeb('https://example.com/index.pyhtml')
+```
+This is useful for serving dynamic HTML content in your WSGI application.<br/>
+The funcs are callable unless you set up a server.
+### Using Templates
+PyWSGIRef also provides a simple way to use templates in your WSGI application:
+```python
+from PyWSGIRef import *
+
+# add template to template dictionary
+# -> saves as PyHTML object
+addSchablone("index", loadedPyHTMLFile)
+
+# load template from dictionary
+# get HTML code from PyHTML object
+html = SCHABLONEN["index"].decoded()
+# use Python formatting
+serverPageContent = html.format("Hello, World!")
+```
+Note that you may only use the <code>addSchablone</code> function before you set up a server.
+### Default HTML templates
+PyWSGIRef comes with some default HTML templates that you can use in your WSGI application.<br/>
+You can access them via the <code>PyWSGIRef.defaults</code>:
+```python
+from PyWSGIRef import *
+
+# load default HTML template
+addSchablone("hello", HELLO_WORLD)
+addSchablone("error", ERROR)
+```
+### __main__ script
+You may produce a simple WSGI server by using either:<br/>
+```python
+from PyWSGIRef import *
+
+main()
+```
+or (from a commandline)
+```bash
+py -m PyWSGIRef
+```
+### Others
+Use the following to get information about your release and the author of the module:
+```python
+pycols.about()
+```
+### More coming soon

pywsgiref-1.0.0/src/PyWSGIRef.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/PyWSGIRef/__init__.py
+src/PyWSGIRef/__main__.py
+src/PyWSGIRef/defaults.py
+src/PyWSGIRef/exceptions.py
+src/PyWSGIRef/pyhtml.py
+src/PyWSGIRef.egg-info/PKG-INFO
+src/PyWSGIRef.egg-info/SOURCES.txt
+src/PyWSGIRef.egg-info/dependency_links.txt
+src/PyWSGIRef.egg-info/requires.txt
+src/PyWSGIRef.egg-info/top_level.txt

pywsgiref-1.0.0/src/PyWSGIRef.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pywsgiref-1.0.0/src/PyWSGIRef.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+typing

pywsgiref-1.0.0/src/PyWSGIRef.egg-info/top_level.txt

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