automatic import of python-azf-wsgi

3 files changed, 309 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..2cda701 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/azf-wsgi-0.3.1.tar.gz
diff --git a/python-azf-wsgi.spec b/python-azf-wsgi.spec
new file mode 100644
index 0000000..923d101
--- /dev/null
+++ b/python-azf-wsgi.spec
@@ -0,0 +1,307 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-azf-wsgi
+Version:	0.3.1
+Release:	1
+Summary:	Azure Functions WSGI implementation [deprecated]
+License:	MIT License
+URL:		https://github.com/vtbassmatt/azf-wsgi
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/41/2a/839c624faee7d740e5d9f25da5dc61e98c3bd4a5f1cccca53121e48938be/azf-wsgi-0.3.1.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-azure-functions
+
+%description
+This was an adapter package to let you run WSGI apps (Django, Flask, etc.) on Azure Functions.
+Example:
+```python
+import azure.functions as func
+# note that the package is "azf-wsgi" but the import is "azf_wsgi"
+from azf_wsgi import AzureFunctionsWsgi
+# Django, for example, but works with any WSGI app
+from my_django_app.wsgi import application
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req, context)
+```
+## Usage
+### Install Azure Functions
+Follow the instructions [here](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-python) to get set up locally.
+I created a Function called "DjangoTrigger", but you can call yours whatever.
+### Install your WSGI app
+I found it's easiest if you package your WSGI app using a setup.py script, then `pip install` it.
+If you don't want to do that, you'll have to make sure your WSGI entrypoint is importable from the module where you define your Azure Function.
+I'm no Python imports expert, so I just added `sys.path.insert(0, './my_proj')` right before I try to import the package.
+### Install this package
+`pip install azf-wsgi` - no need to put this in Django's `INSTALLED_APPS` or anything like that.
+Be sure to update `requirements.txt` to include `azf-wsgi` as a requirement.
+### Configure Azure Functions to hand off to your WSGI app
+First, we want to delegate routing to your WSGI app. Edit your `function.json` to include a catch-all route called "{*route}":
+```json
+{
+  "scriptFile": "__init__.py",
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": [
+        "get",
+        "post"
+      ],
+      "route": "app/{*route}"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "$return"
+    }
+  ]
+}
+```
+I also didn't want the default 'api/' path on all my routes, so I fixed my `host.json` to look like this:
+```json
+{
+    "version":  "2.0",
+    "extensions": {
+        "http": {
+            "routePrefix": ""
+        }
+    }
+}
+```
+Without this configuration, the only paths your WSGI app would ever see would start with "api/\<FunctionName\>/".
+That works, but it would require you to repeat those boilerplate prefixes on every route you configured.
+**However**, you don't want to completely take over all routes (by having an empty `routePrefix` _and_ a catch-all route in your function) because this disables important Azure machinery.
+Finally, setup your Function's `__init__.py` to delegate to the WSGI adapter:
+```python
+import azure.functions as func
+from azf_wsgi import AzureFunctionsWsgi
+from my_django_app.wsgi import application
+def main(req: func.HttpRequest) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req)
+```
+The adapter optionally takes the `Context` object as well:
+```python
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req, context)
+```
+The adapter will stuff in the OS's environment block much like a CGI request. If for some reason you don't want that, you can pass `False` to `include_os_environ`:
+```python
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application, False).main(req, context)
+```
+
+%package -n python3-azf-wsgi
+Summary:	Azure Functions WSGI implementation [deprecated]
+Provides:	python-azf-wsgi
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-azf-wsgi
+This was an adapter package to let you run WSGI apps (Django, Flask, etc.) on Azure Functions.
+Example:
+```python
+import azure.functions as func
+# note that the package is "azf-wsgi" but the import is "azf_wsgi"
+from azf_wsgi import AzureFunctionsWsgi
+# Django, for example, but works with any WSGI app
+from my_django_app.wsgi import application
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req, context)
+```
+## Usage
+### Install Azure Functions
+Follow the instructions [here](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-python) to get set up locally.
+I created a Function called "DjangoTrigger", but you can call yours whatever.
+### Install your WSGI app
+I found it's easiest if you package your WSGI app using a setup.py script, then `pip install` it.
+If you don't want to do that, you'll have to make sure your WSGI entrypoint is importable from the module where you define your Azure Function.
+I'm no Python imports expert, so I just added `sys.path.insert(0, './my_proj')` right before I try to import the package.
+### Install this package
+`pip install azf-wsgi` - no need to put this in Django's `INSTALLED_APPS` or anything like that.
+Be sure to update `requirements.txt` to include `azf-wsgi` as a requirement.
+### Configure Azure Functions to hand off to your WSGI app
+First, we want to delegate routing to your WSGI app. Edit your `function.json` to include a catch-all route called "{*route}":
+```json
+{
+  "scriptFile": "__init__.py",
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": [
+        "get",
+        "post"
+      ],
+      "route": "app/{*route}"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "$return"
+    }
+  ]
+}
+```
+I also didn't want the default 'api/' path on all my routes, so I fixed my `host.json` to look like this:
+```json
+{
+    "version":  "2.0",
+    "extensions": {
+        "http": {
+            "routePrefix": ""
+        }
+    }
+}
+```
+Without this configuration, the only paths your WSGI app would ever see would start with "api/\<FunctionName\>/".
+That works, but it would require you to repeat those boilerplate prefixes on every route you configured.
+**However**, you don't want to completely take over all routes (by having an empty `routePrefix` _and_ a catch-all route in your function) because this disables important Azure machinery.
+Finally, setup your Function's `__init__.py` to delegate to the WSGI adapter:
+```python
+import azure.functions as func
+from azf_wsgi import AzureFunctionsWsgi
+from my_django_app.wsgi import application
+def main(req: func.HttpRequest) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req)
+```
+The adapter optionally takes the `Context` object as well:
+```python
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req, context)
+```
+The adapter will stuff in the OS's environment block much like a CGI request. If for some reason you don't want that, you can pass `False` to `include_os_environ`:
+```python
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application, False).main(req, context)
+```
+
+%package help
+Summary:	Development documents and examples for azf-wsgi
+Provides:	python3-azf-wsgi-doc
+%description help
+This was an adapter package to let you run WSGI apps (Django, Flask, etc.) on Azure Functions.
+Example:
+```python
+import azure.functions as func
+# note that the package is "azf-wsgi" but the import is "azf_wsgi"
+from azf_wsgi import AzureFunctionsWsgi
+# Django, for example, but works with any WSGI app
+from my_django_app.wsgi import application
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req, context)
+```
+## Usage
+### Install Azure Functions
+Follow the instructions [here](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-python) to get set up locally.
+I created a Function called "DjangoTrigger", but you can call yours whatever.
+### Install your WSGI app
+I found it's easiest if you package your WSGI app using a setup.py script, then `pip install` it.
+If you don't want to do that, you'll have to make sure your WSGI entrypoint is importable from the module where you define your Azure Function.
+I'm no Python imports expert, so I just added `sys.path.insert(0, './my_proj')` right before I try to import the package.
+### Install this package
+`pip install azf-wsgi` - no need to put this in Django's `INSTALLED_APPS` or anything like that.
+Be sure to update `requirements.txt` to include `azf-wsgi` as a requirement.
+### Configure Azure Functions to hand off to your WSGI app
+First, we want to delegate routing to your WSGI app. Edit your `function.json` to include a catch-all route called "{*route}":
+```json
+{
+  "scriptFile": "__init__.py",
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": [
+        "get",
+        "post"
+      ],
+      "route": "app/{*route}"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "$return"
+    }
+  ]
+}
+```
+I also didn't want the default 'api/' path on all my routes, so I fixed my `host.json` to look like this:
+```json
+{
+    "version":  "2.0",
+    "extensions": {
+        "http": {
+            "routePrefix": ""
+        }
+    }
+}
+```
+Without this configuration, the only paths your WSGI app would ever see would start with "api/\<FunctionName\>/".
+That works, but it would require you to repeat those boilerplate prefixes on every route you configured.
+**However**, you don't want to completely take over all routes (by having an empty `routePrefix` _and_ a catch-all route in your function) because this disables important Azure machinery.
+Finally, setup your Function's `__init__.py` to delegate to the WSGI adapter:
+```python
+import azure.functions as func
+from azf_wsgi import AzureFunctionsWsgi
+from my_django_app.wsgi import application
+def main(req: func.HttpRequest) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req)
+```
+The adapter optionally takes the `Context` object as well:
+```python
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application).main(req, context)
+```
+The adapter will stuff in the OS's environment block much like a CGI request. If for some reason you don't want that, you can pass `False` to `include_os_environ`:
+```python
+def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
+    return AzureFunctionsWsgi(application, False).main(req, context)
+```
+
+%prep
+%autosetup -n azf-wsgi-0.3.1
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-azf-wsgi -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed May 17 2023 Python_Bot <Python_Bot@openeuler.org> - 0.3.1-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..66c22c9
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+ba8e83207b9b535777ba1261003ccf6e  azf-wsgi-0.3.1.tar.gz