在线时间:8:00-16:00
迪恩网络APP
随时随地掌握行业动态
扫描二维码
关注迪恩网络微信公众号
开源软件名称(OpenSource Name):ChrisKnott/Eel开源软件地址(OpenSource Url):https://github.com/ChrisKnott/Eel开源编程语言(OpenSource Language):Python 75.2%开源软件介绍(OpenSource Introduction):EelEel is a little Python library for making simple Electron-like offline HTML/JS GUI apps, with full access to Python capabilities and libraries.
Eel is designed to take the hassle out of writing short and simple GUI applications. If you are familiar with Python and web development, probably just jump to this example which picks random file names out of the given folder (something that is impossible from a browser). IntroThere 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. It is a bit heavy weight for what I wanted. Eel is not as fully-fledged as Electron or cefpython - it is probably not suitable for making full blown applications like Atom - but it is very suitable for making the GUI equivalent of little utility scripts that you use internally in your team. For some reason many of the best-in-class number crunching and maths libraries are in Python (Tensorflow, Numpy, Scipy etc) but many of the best visualization libraries are in Javascript (D3, THREE.js etc). Hopefully Eel makes it easy to combine these into simple utility apps for assisting your development. Join Eel's users and maintainers on Discord, if you like. InstallInstall from pypi with pip install eel To include support for HTML templating, currently using Jinja2: pip install eel[jinja2] UsageDirectory StructureAn Eel application will be split into a frontend consisting of various web-technology files (.html, .js, .css) and a backend consisting of various Python scripts. All the frontend files should be put in a single directory (they can be further divided into folders inside this if necessary).
Starting the appSuppose you put all the frontend files in a directory called import eel
eel.init('web')
eel.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. If Chrome or Chromium is installed then by default it will open in that in App Mode (with the App optionsAdditional options can be passed to 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. As of Eel v0.12.0, the following options are available to
Exposing functionsIn addition to the files in the frontend folder, a Javascript library will be served at <script type="text/javascript" src="/eel.js"></script> Including this library creates an Any functions in the Python code which are decorated with @eel.expose
def my_python_function(a, b):
print(a, b, a + b) ...will appear as methods on the console.log("Calling Python...");
eel.my_python_function(1, 2); // This calls the Python function that was decorated Similarly, any Javascript functions which are exposed like this... eel.expose(my_javascript_function);
function my_javascript_function(a, b, c, d) {
if (a < b) {
console.log(c * d);
}
} can be called from the Python side like this... print('Calling Javascript...')
eel.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: eel.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). Eello, World!
Putting this together into a Hello, World! example, we have a short HTML page, <!DOCTYPE html>
<html>
<head>
<title>Hello, World!</title>
<!-- Include eel.js - note this file doesn't exist in the 'web' directory -->
<script type="text/javascript" src="/eel.js"></script>
<script type="text/javascript">
eel.expose(say_hello_js); // Expose this function to Python
function say_hello_js(x) {
console.log("Hello from " + x);
}
say_hello_js("Javascript World!");
eel.say_hello_py("Javascript World!"); // Call a Python function
</script>
</head>
<body>
Hello, World!
</body>
</html> and a short Python script import eel
# Set web files folder and optionally specify which file types to check for eel.expose()
# *Default allowed_extensions are: ['.js', '.html', '.txt', '.htm', '.xhtml']
eel.init('web', allowed_extensions=['.js', '.html'])
@eel.expose # Expose this function to Javascript
def say_hello_py(x):
print('Hello from %s' % x)
say_hello_py('Python World!')
eel.say_hello_js('Python World!') # Call a Javascript function
eel.start('hello.html') # Start (this blocks and enters loop) If we run the Python script (
...in the terminal, and...
...in the browser console (press F12 to open). You will notice that in the Python code, the Javascript function is called before the browser window is even started - any early calls like this are queued up and then sent once the websocket has been established. Return valuesWhile we want to think of our code as comprising a single application, the Python interpreter and the browser window run in separate processes. This can make communicating back and forth between them a bit of a mess, especially if we always had to explicitly send values from one side to the other. 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 CallbacksWhen you call an exposed function, you can immediately pass a callback function afterwards. This callback will automatically be called asynchrounously with the return value when the function has finished executing on the other side. For example, if we have the following function defined and exposed in Javascript: eel.expose(js_random);
function js_random() {
return Math.random();
} Then in Python we can retrieve random values from the Javascript side like so: def print_num(n):
print('Got this from Javascript:', n)
# Call Javascript function, and pass explicit callback function
eel.js_random()(print_num)
# Do the same with an inline lambda as callback
eel.js_random()(lambda n: print('Got this from Javascript:', n)) (It works exactly the same the other way around). Synchronous returnsIn most situations, the calls to the other side are to quickly retrieve some piece of data, such as the state of a widget or contents of an input field. In these cases it is more convenient to just synchronously wait a few milliseconds then continue with your code, rather than breaking the whole thing up into callbacks. To synchronously retrieve the return value, simply pass nothing to the second set of brackets. So in Python we would write: n = eel.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 In Javascript, the language doesn't allow us to block while we wait for a callback, except by using async function run() {
// Inside a function marked 'async' we can use the 'await' keyword.
let n = await eel.py_random()(); // Must prefix call with 'await', otherwise it's the same syntax
console.log("Got this from Python: " + n);
}
run(); Asynchronous PythonEel is built on Bottle and Gevent, which provide an asynchronous event loop similar to Javascript. A lot of Python's standard library implicitly assumes there is a single execution thread - to deal with this, Gevent can "monkey patch" many of the standard modules such as For most cases you should be fine by avoiding using In this example... import eel
eel.init('web')
def my_other_thread():
while True:
print("I'm a thread")
eel.sleep(1.0) # Use eel.sleep(), not time.sleep()
eel.spawn(my_other_thread)
eel.start('main.html', block=False) # Don't block on this call
while True:
print("I'm a main loop")
eel.sleep(1.0) # Use eel.sleep(), not time.sleep() ...we would then have three "threads" (greenlets) running;
Building distributable binary with PyInstallerIf you want to package your app into a program that can be run on a computer without a Python interpreter installed, you should use PyInstaller.
Consult the documentation for PyInstaller for more options. Microsoft EdgeFor Windows 10 users, Microsoft Edge (
|
2023-10-27
2022-08-15
2022-08-17
2022-09-23
2022-08-13
请发表评论