Omega!
Omega - The web platform that "has an app for that"
What is Omega?
Omega is an attempt to bring back innovation to Python web frameworks. Its goal is to be more than a web framework; Omega aims to be a platform on which any type of web application can be built, batteries included. That means Omega ships with support for creating ORM-backed CRUD applications, NoSQL REST APIs, real-time applications using Websockets, and simple, mostly static page applications.
To this end, Omega will include the tools/libraries listed below. Of course, it's still in its infancy, so many of the items below are vaporware.
search
Support for full-text search in web applications. Coming Soon.
kvs
A pure-Python NoSQL database usable as a backing store for a web application. In progress.
queue
A distributed, asychronous task queue for out-of-band/background task execution in web
applications. Includes support for cron
-like job scheduling. In progress.
log/stat
A centralized logging/metrics server with fully browsable logs and metric reporting. Includes monitoring for metrics like process uptime, request speed, number of exceptions, etc. Coming Soon
settings
A centralized live-settings server capable of providing service discovery capabilities as well as a management frontent for traditional database-backed application settings. Coming Soon
http
A micro web framework with macro capabilities. In progress.
Here are a few examples of the vastly different types of applications you can already build in an instant:
ORM-backed CRUD application
runserver.py
from omega.http.core import create_app
from omega.http.orm import create_engine
from werkzeug import run_simple
from models import Twoot, User
if __name__ == '__main__':
app = create_app(__name__)
app.engine(create_engine('sqlite+pysqlite:///db.sqlite3'))
app.orm_resource(Twoot)
app.orm_resource(User)
app.auto_generate_home()
run_simple('127.0.0.1', 5000, app, use_debugger=True, use_reloader=True)
models.py
import datetime
from omega.http.orm import Model, Column, String, DateTime, Integer, relationship, ForeignKey
class User(Model):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
user_name = Column(String)
joined_at = Column(DateTime, default=datetime.datetime.now())
def __str__(self):
return self.user_name
class Twoot(Model):
__tablename__ = 'twoot'
id = Column(Integer, primary_key=True)
content = Column(String)
posted_at = Column(DateTime, default=datetime.datetime.now())
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship(User)
This gives you the following, for free:
Homepage
List of objects
By adding a sockets.py
file with the following contents (and creating a new
route function using the route
decorator):
from socketio.namespace import BaseNamespace
class ChatNamespace(BaseNamespace):
sockets = {}
def on_chat(self, msg):
self.emit('chat', msg)
def recv_connect(self):
self.sockets[id(self)] = self
def disconnect(self, *args, **kwargs):
if id(self) in self.sockets:
del self.sockets[id(self)]
super(ChatNamespace, self).disconnect(*args, **kwargs)
@classmethod
def broadcast(self, event, message):
for ws in self.sockets.values():
ws.emit(event, message)
(in runserver.py
):
@app.route('/chat', methods=['POST'])
def chat(request):
"""Route chat posts to the *chat* handler function. Broadcast the message
to all users."""
message = '{}: {}'.format(request.form['user'], request.form['message'])
if message:
ChatNamespace.broadcast('message', message)
return Response()
You now have free real-time chat that degrades gracefully via socket.io. Connect two browsers to the root page and type a message in one browser. It will pop up in the chat area of the other browser.