version bump

Author: savelkouls

CHANGELOG.md

@@ -50,10 +50,10 @@
 * Fix the implementation of #203, allowing users to pass their own bottle instances into Eel.
 
 ## v0.11.0
-* Added support for `app` parameter to `aal.start`, which will override the bottle app instance used to run aal. This
-allows developers to apply any middleware they wish to before handing over to aal.
-* Disable page caching by default via new `disable_cache` parameter to `aal.start`.
-* Add support for listening on all network interfaces via new `all_interfaces` parameter to `aal.start`.
+* Added support for `app` parameter to `paling.start`, which will override the bottle app instance used to run paling. This
+allows developers to apply any middleware they wish to before handing over to paling.
+* Disable page caching by default via new `disable_cache` parameter to `paling.start`.
+* Add support for listening on all network interfaces via new `all_interfaces` parameter to `paling.start`.
 * Support for Microsoft Edge
 
 ### v0.10.4
@@ -70,7 +70,7 @@ allows developers to apply any middleware they wish to before handing over to aa
 
 ## v0.10.0
 * Corrective version bump after new feature included in 0.9.13
-* Fix a bug with example 06 for Jinja templating; the `templates` kwarg to `aal.start` takes a filepath, not a bool.
+* Fix a bug with example 06 for Jinja templating; the `templates` kwarg to `paling.start` takes a filepath, not a bool.
 
 ### v0.9.13
 * Add support for Jinja templating.

README.md

@@ -1,11 +1,11 @@
-# Eel, but then Aal
+# Eel, but then Paling
 
-[![PyPI version](https://img.shields.io/pypi/v/Eel?style=for-the-badge)](https://pypi.org/project/Eel/)
-[![PyPi Downloads](https://img.shields.io/pypi/dm/Eel?style=for-the-badge)](https://pypistats.org/packages/eel)
-![Python](https://img.shields.io/pypi/pyversions/Eel?style=for-the-badge)
-[![License](https://img.shields.io/pypi/l/Eel.svg?style=for-the-badge)](https://pypi.org/project/Eel/)
+[![PyPI version](https://img.shields.io/pypi/v/Eel?style=for-the-badge)](https://pypi.org/project/Paling/)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/Eel?style=for-the-badge)](https://pypistats.org/packages/paling)
+![Python](https://img.shields.io/pypi/pyversions/Paling?style=for-the-badge)
+[![License](https://img.shields.io/pypi/l/Eel.svg?style=for-the-badge)](https://pypi.org/project/Paling/)
 
-Eel is a little Python library for making simple Electron-like offline HTML/JS GUI apps, with full access to Python capabilities and libraries.
+Paling is a updated version of Eel, the Python library for making simple Electron-like offline HTML/JS GUI apps, with full access to Python capabilities and libraries.
 
 > **Eel hosts a local webserver, then lets you annotate functions in Python so that they can be called from Javascript, and vice versa.**
 
@@ -36,6 +36,8 @@ Eel is designed to take the hassle out of writing short and simple GUI applicati
 
 ## Intro
 
+Eel has always been our favorite library for writing UI's in python, because it made it very simple to create a beautiful interface. Unfortunately the project has not been maintained, and now we are taking over.
+
 There are several options for making GUI apps in Python, but if you want to use HTML/JS (in order to use jQueryUI or Bootstrap, for example) then you generally have to write a lot of boilerplate code to communicate from the Client (Javascript) side to the Server (Python) side.
 
 The closest Python equivalent to Electron (to my knowledge) is [cefpython](https://github.com/cztomczak/cefpython). It is a bit heavy weight for what I wanted.
@@ -51,7 +53,7 @@ Join Eel's users and maintainers on [Discord](https://discord.com/invite/3nqXPFX
 Install from pypi with `pip`:
 
 ```shell
-pip install eel
+pip install paling
 ```
 
 To include support for HTML templating, currently using [Jinja2](https://pypi.org/project/Jinja2/#description):
@@ -85,8 +87,8 @@ Suppose you put all the frontend files in a directory called `web`, including yo
 
 ```python
 import eel
-aal.init('web')
-aal.start('main.html')
+paling.init('web')
+paling.start('main.html')
 ```
 
 This will start a webserver on the default settings (http://localhost:8000) and open a browser to http://localhost:8000/main.html.
@@ -95,7 +97,7 @@ If Chrome or Chromium is installed then by default it will open in that in App M
 
 ### App options
 
-Additional options can be passed to `aal.start()` as keyword arguments.
+Additional options can be passed to `paling.start()` as keyword arguments.
 
 Some of the options include the mode the app is in (e.g. 'chrome'), the port the app runs on, the host name of the app, and adding additional command line flags.
 
@@ -105,30 +107,30 @@ As of Eel v0.12.0, the following options are available to `start()`:
  - **port**, an int specifying what port to use for the Bottle server. Use `0` for port to be picked automatically. *Default: `8000`*.
  - **block**, a bool saying whether or not the call to `start()` should block the calling thread. *Default: `True`*
  - **jinja_templates**, a string specifying a folder to use for Jinja2 templates, e.g. `my_templates`. *Default:  `None`*
- - **cmdline_args**, a list of strings to pass to the command to start the browser. For example, we might add extra flags for Chrome; ```aal.start('main.html', mode='chrome-app', port=8080, cmdline_args=['--start-fullscreen', '--browser-startup-dialog'])```. *Default: `[]`*
+ - **cmdline_args**, a list of strings to pass to the command to start the browser. For example, we might add extra flags for Chrome; ```paling.start('main.html', mode='chrome-app', port=8080, cmdline_args=['--start-fullscreen', '--browser-startup-dialog'])```. *Default: `[]`*
  - **size**, a tuple of ints specifying the (width, height) of the main window in pixels *Default: `None`*
  - **position**, a tuple of ints specifying the (left, top) of the main window in pixels *Default: `None`*
  - **geometry**, a dictionary specifying the size and position for all windows. The keys should be the relative path of the page, and the values should be a dictionary of the form `{'size': (200, 100), 'position': (300, 50)}`. *Default: {}*
  - **close_callback**, a lambda or function that is called when a websocket to a window closes (i.e. when the user closes the window). It should take two arguments; a string which is the relative path of the page that just closed, and a list of other websockets that are still open. *Default: `None`*
- - **app**, an instance of Bottle which will be used rather than creating a fresh one. This can be used to install middleware on the instance before starting eel, e.g. for session management, authentication, etc. If your `app` is not a Bottle instance, you will need to call `aal.register_eel_routes(app)` on your custom app instance.
+ - **app**, an instance of Bottle which will be used rather than creating a fresh one. This can be used to install middleware on the instance before starting eel, e.g. for session management, authentication, etc. If your `app` is not a Bottle instance, you will need to call `paling.register_eel_routes(app)` on your custom app instance.
  - **shutdown_delay**, timer configurable for Eel's shutdown detection mechanism, whereby when any websocket closes, it waits `shutdown_delay` seconds, and then checks if there are now any websocket connections. If not, then Eel closes. In case the user has closed the browser and wants to exit the program. By default, the value of **shutdown_delay** is `1.0` second
 
 
 
 ### Exposing functions
 
-In addition to the files in the frontend folder, a Javascript library will be served at `/aal.js`. You should include this in any pages:
+In addition to the files in the frontend folder, a Javascript library will be served at `/paling.js`. You should include this in any pages:
 
 ```html
-<script type="text/javascript" src="/aal.js"></script>
+<script type="text/javascript" src="/paling.js"></script>
 ```
 
 Including this library creates an `eel` object which can be used to communicate with the Python side.
 
-Any functions in the Python code which are decorated with `@aal.expose` like this...
+Any functions in the Python code which are decorated with `@paling.expose` like this...
 
 ```python
-@aal.expose
+@paling.expose
 def my_python_function(a, b):
     print(a, b, a + b)
 ```
@@ -137,13 +139,13 @@ def my_python_function(a, b):
 
 ```javascript
 console.log("Calling Python...");
-aal.my_python_function(1, 2); // This calls the Python function that was decorated
+paling.my_python_function(1, 2); // This calls the Python function that was decorated
 ```
 
 Similarly, any Javascript functions which are exposed like this...
 
 ```javascript
-aal.expose(my_javascript_function);
+paling.expose(my_javascript_function);
 function my_javascript_function(a, b, c, d) {
   if (a < b) {
     console.log(c * d);
@@ -155,13 +157,13 @@ can be called from the Python side like this...
 
 ```python
 print('Calling Javascript...')
-aal.my_javascript_function(1, 2, 3, 4)  # This calls the Javascript function
+paling.my_javascript_function(1, 2, 3, 4)  # This calls the Javascript function
 ```
 
 The exposed name can also be overridden by passing in a second argument. If your app minifies JavaScript during builds, this may be necessary to ensure that functions can be resolved on the Python side:
 
 ```javascript
-aal.expose(someFunction, "my_javascript_function");
+paling.expose(someFunction, "my_javascript_function");
 ```
 
 When passing complex objects as arguments, bear in mind that internally they are converted to JSON and sent down a websocket (a process that potentially loses information).
@@ -178,16 +180,16 @@ Putting this together into a **Hello, World!** example, we have a short HTML pag
   <head>
     <title>Hello, World!</title>
 
-    <!-- Include aal.js - note this file doesn't exist in the 'web' directory -->
-    <script type="text/javascript" src="/aal.js"></script>
+    <!-- Include paling.js - note this file doesn't exist in the 'web' directory -->
+    <script type="text/javascript" src="/paling.js"></script>
     <script type="text/javascript">
-      aal.expose(say_hello_js); // Expose this function to Python
+      paling.expose(say_hello_js); // Expose this function to Python
       function say_hello_js(x) {
         console.log("Hello from " + x);
       }
 
       say_hello_js("Javascript World!");
-      aal.say_hello_py("Javascript World!"); // Call a Python function
+      paling.say_hello_py("Javascript World!"); // Call a Python function
     </script>
   </head>
 
@@ -202,18 +204,18 @@ and a short Python script `hello.py`:
 ```python
 import eel
 
-# Set web files folder and optionally specify which file types to check for aal.expose()
+# Set web files folder and optionally specify which file types to check for paling.expose()
 #   *Default allowed_extensions are: ['.js', '.html', '.txt', '.htm', '.xhtml']
-aal.init('web', allowed_extensions=['.js', '.html'])
+paling.init('web', allowed_extensions=['.js', '.html'])
 
-@aal.expose                         # Expose this function to Javascript
+@paling.expose                         # Expose this function to Javascript
 def say_hello_py(x):
     print('Hello from %s' % x)
 
 say_hello_py('Python World!')
-aal.say_hello_js('Python World!')   # Call a Javascript function
+paling.say_hello_js('Python World!')   # Call a Javascript function
 
-aal.start('hello.html')             # Start (this blocks and enters loop)
+paling.start('hello.html')             # Start (this blocks and enters loop)
 ```
 
 If we run the Python script (`python hello.py`), then a browser window will open displaying `hello.html`, and we will see...
@@ -241,7 +243,7 @@ While we want to think of our code as comprising a single application, the Pytho
 Eel supports two ways of retrieving _return values_ from the other side of the app, which helps keep the code concise.
 
 To prevent hanging forever on the Python side, a timeout has been put in place for trying to retrieve values from
-the JavaScript side, which defaults to 10000 milliseconds (10 seconds). This can be changed with the `_js_result_timeout` parameter to `aal.init`. There is no corresponding timeout on the JavaScript side.
+the JavaScript side, which defaults to 10000 milliseconds (10 seconds). This can be changed with the `_js_result_timeout` parameter to `paling.init`. There is no corresponding timeout on the JavaScript side.
 
 #### Callbacks
 
@@ -250,7 +252,7 @@ When you call an exposed function, you can immediately pass a callback function
 For example, if we have the following function defined and exposed in Javascript:
 
 ```javascript
-aal.expose(js_random);
+paling.expose(js_random);
 function js_random() {
   return Math.random();
 }
@@ -263,10 +265,10 @@ def print_num(n):
     print('Got this from Javascript:', n)
 
 # Call Javascript function, and pass explicit callback function
-aal.js_random()(print_num)
+paling.js_random()(print_num)
 
 # Do the same with an inline lambda as callback
-aal.js_random()(lambda n: print('Got this from Javascript:', n))
+paling.js_random()(lambda n: print('Got this from Javascript:', n))
 ```
 
 (It works exactly the same the other way around).
@@ -278,19 +280,19 @@ In most situations, the calls to the other side are to quickly retrieve some pie
 To synchronously retrieve the return value, simply pass nothing to the second set of brackets. So in Python we would write:
 
 ```python
-n = aal.js_random()()  # This immediately returns the value
+n = paling.js_random()()  # This immediately returns the value
 print('Got this from Javascript:', n)
 ```
 
-You can only perform synchronous returns after the browser window has started (after calling `aal.start()`), otherwise obviously the call will hang.
+You can only perform synchronous returns after the browser window has started (after calling `paling.start()`), otherwise obviously the call will hang.
 
 In Javascript, the language doesn't allow us to block while we wait for a callback, except by using `await` from inside an `async` function. So the equivalent code from the Javascript side would be:
 
 ```javascript
 async function run() {
   // Inside a function marked 'async' we can use the 'await' keyword.
 
-  let n = await aal.py_random()(); // Must prefix call with 'await', otherwise it's the same syntax
+  let n = await paling.py_random()(); // Must prefix call with 'await', otherwise it's the same syntax
   console.log("Got this from Python: " + n);
 }
 
@@ -307,20 +309,20 @@ In this example...
 
 ```python
 import eel
-aal.init('web')
+paling.init('web')
 
 def my_other_thread():
     while True:
         print("I'm a thread")
-        aal.sleep(1.0)                  # Use aal.sleep(), not time.sleep()
+        paling.sleep(1.0)                  # Use paling.sleep(), not time.sleep()
 
-aal.spawn(my_other_thread)
+paling.spawn(my_other_thread)
 
-aal.start('main.html', block=False)     # Don't block on this call
+paling.start('main.html', block=False)     # Don't block on this call
 
 while True:
     print("I'm a main loop")
-    aal.sleep(1.0)                      # Use aal.sleep(), not time.sleep()
+    paling.sleep(1.0)                      # Use paling.sleep(), not time.sleep()
 ```
 
 ...we would then have three "threads" (greenlets) running;
@@ -344,7 +346,7 @@ Consult the [documentation for PyInstaller](http://PyInstaller.readthedocs.io/en
 
 ## Microsoft Edge
 
-For Windows 10 users, Microsoft Edge (`aal.start(.., mode='edge')`) is installed by default and a useful fallback if a preferred browser is not installed. See the examples:
+For Windows 10 users, Microsoft Edge (`paling.start(.., mode='edge')`) is installed by default and a useful fallback if a preferred browser is not installed. See the examples:
 
 - A Hello World example using Microsoft Edge: [examples/01 - hello_world-Edge/](https://github.com/ChrisKnott/Eel/tree/master/examples/01%20-%20hello_world-Edge)
 - Example implementing browser-fallbacks: [examples/07 - CreateReactApp/eel_CRA.py](https://github.com/ChrisKnott/Eel/tree/master/examples/07%20-%20CreateReactApp/eel_CRA.py)

examples/01 - hello_world-Edge/hello.py

@@ -9,30 +9,30 @@
 # Use the same static files as the original Example
 os.chdir(os.path.join('..', '01 - hello_world'))
 
-# Set web files folder and optionally specify which file types to check for aal.expose()
-aal.init('web', allowed_extensions=['.js', '.html'])
+# Set web files folder and optionally specify which file types to check for paling.expose()
+paling.init('web', allowed_extensions=['.js', '.html'])
 
 
-@aal.expose                         # Expose this function to Javascript
+@paling.expose                         # Expose this function to Javascript
 def say_hello_py(x):
     print('Hello from %s' % x)
 
 
 say_hello_py('Python World!')
-aal.say_hello_js('Python World!')   # Call a Javascript function
+paling.say_hello_js('Python World!')   # Call a Javascript function
 
 # Launch example in Microsoft Edge only on Windows 10 and above
 if sys.platform in ['win32', 'win64'] and int(platform.release()) >= 10:
-    aal.start('hello.html', mode='edge')
+    paling.start('hello.html', mode='edge')
 else:
     raise EnvironmentError('Error: System is not Windows 10 or above')
 
 # # Launching Edge can also be gracefully handled as a fall back
 # try:
-#     aal.start('hello.html', mode='chrome-app', size=(300, 200))
+#     paling.start('hello.html', mode='chrome-app', size=(300, 200))
 # except EnvironmentError:
 #     # If Chrome isn't found, fallback to Microsoft Edge on Win10 or greater
 #     if sys.platform in ['win32', 'win64'] and int(platform.release()) >= 10:
-#         aal.start('hello.html', mode='edge')
+#         paling.start('hello.html', mode='edge')
 #     else:
 #         raise

examples/01 - hello_world/hello.py

@@ -1,13 +1,13 @@
 import aal
 
 # Set web files folder
-aal.init('web')
+paling.init('web')
 
-@aal.expose                         # Expose this function to Javascript
+@paling.expose                         # Expose this function to Javascript
 def say_hello_py(x):
     print('Hello from %s' % x)
 
 say_hello_py('Python World!')
-aal.say_hello_js('Python World!')   # Call a Javascript function
+paling.say_hello_js('Python World!')   # Call a Javascript function
 
-aal.start('hello.html', size=(300, 200))  # Start
+paling.start('hello.html', size=(300, 200))  # Start

examples/01 - hello_world/web/hello.html

@@ -1,24 +1,26 @@
 <!DOCTYPE html>
 <html>
-    <head>
-        <title>Hello, World!</title>
-        
-        <!-- Include aal.js - note this file doesn't exist in the 'web' directory -->
-        <script type="text/javascript" src="/aal.js"></script>
-        <script type="text/javascript">
-        
-        aal.expose(say_hello_js);               // Expose this function to Python
+
+<head>
+    <title>Hello, World!</title>
+
+    <!-- Include paling.js - note this file doesn't exist in the 'web' directory -->
+    <script type="text/javascript" src="/paling.js"></script>
+    <script type="text/javascript">
+
+        paling.expose(say_hello_js);               // Expose this function to Python
         function say_hello_js(x) {
             console.log("Hello from " + x);
         }
-        
+
         say_hello_js("Javascript World!");
-        aal.say_hello_py("Javascript World!");  // Call a Python function
-        
-        </script>
-    </head>
-    
-    <body>
-        Hello, World!
-    </body>
+        paling.say_hello_py("Javascript World!");  // Call a Python function
+
+    </script>
+</head>
+
+<body>
+    Hello, World!
+</body>
+
 </html>