Mezzanine is a powerful, consistent, and flexible content management platform. Built using the Django framework, Mezzanine provides a simple yet highly extensible architecture that encourages diving in and hacking on the code. Mezzanine is BSD licensed and supported by a diverse and active community.
In some ways, Mezzanine resembles tools such as Wordpress, providing an intuitive interface for managing pages, blog posts, form data, store products, and other types of content. But Mezzanine is also different. Unlike many other platforms that make extensive use of modules or reusable applications, Mezzanine provides most of its functionality by default. This approach yields a more integrated and efficient platform.
Hierarchical page navigation
Save as draft and preview on site
Drag-and-drop page ordering
In-line page editing
Drag-and-drop HTML5 forms builder with CSV export
SEO friendly URLs and metadata
E-commerce / Shopping cart module (Cartridge)
Configurable dashboard widgets
Free Themes, and a Premium Themes Marketplace
User accounts and profiles with email verification
Translated to over 35 languages
Sharing via Facebook or Twitter
Custom templates per page or blog post
Twitter Bootstrap integration
API for custom content types
Search engine and API
Mezzanine is an open source project managed using both the Git and Mercurial version control systems.
1) Developer Ready
2) Instant Feedback
Fast interactive watch mode runs only test files related to changed files and is optimized to give signal quickly.
3) Snapshot Testing
Capture snapshots of React trees or other serializable values to simplify testing and to analyze how state changes over time.
What is Redmine? Redmine is a flexible project management web application. Written using the Ruby on Rails framework, it is cross-platform and cross-database.
Redmine is open source and released under the terms of the GNU General Public License v2 (GPL).
It is a cross-platform, cross-database, and open source tool that also has issue-tracking features. Users can manage multiple projects and subprojects, and have access to many planning, tracking, and documenting features available from similar commercial products.
Redmine has a news area where members can publish news items. It allows the creation of documents, such as user documentation or technical documentation, which can be downloaded by others. A Files module is a table that lists all uploaded files and its details.
Users can easily create project wikis with the help of a toolbar. Other features include custom fields for creating additional information, and a Repository to view a given revision and the latest commits. The software can be configured to receive emails for issue creation and comments. It also supports particular versions of different databases, such as MySQL, PostgreSQL, MS SQL Server, and SQLite. API and plug-ins are also available.
Multiple projects support
Flexible role based access control
Flexible issue tracking system
Gantt chart and calendar
News, documents & files management
Feeds & email notifications
Per project wiki
Per project forums
Custom fields for issues, time-entries, projects and users
SCM integration (SVN, CVS, Git, Mercurial and Bazaar)
It is a specification that describes how a web server communicates with web applications, and how web applications can be chained together to process one request.
WSGI is a specification, laid out in PEP 333, for a standardized interface between Web servers and Python Web frameworks/applications.
The goal is to provide a relatively simple yet comprehensive interface capable of supporting all (or most) interactions between a Web server and a Web framework. (Think "CGI" but programmatic rather than I/O based.)
An additional goal is to support "middleware" components for pre- and post-processing of requests: think gzip, recording, proxy, load-balancing.
- WSGI gives you flexibility.
Application developers can swap out web stack components for others. For example, a developer can switch from Green Unicorn to uWSGI without modifying the application or framework that implements WSGI. From PEP 3333:
- WSGI servers promote scaling.
Serving thousands of requests for dynamic content at once is the domain of WSGI servers, not frameworks. WSGI servers handle processing requests from the web server and deciding how to communicate those requests to an application framework's process. The segregation of responsibilities is important for efficiently scaling web traffic.
Written on top of Flask, Plotly.js, and React.js, Dash is ideal for building data visualization apps with highly custom user interfaces in pure Python. It's particularly suited for anyone who works with data in Python.
Through a couple of simple patterns, Dash abstracts away all of the technologies and protocols that are required to build an interactive web-based application. Dash is simple enough that you can bind a user interface around your Python code in an afternoon.
Dash apps are rendered in the web browser. You can deploy your apps to servers and then share them through URLs. Since Dash apps are viewed in the web browser, Dash is inherently cross-platform and mobile-ready.
1) Lightweight - Dash apps require very little boilerplate to get started: An app like this weighs in at just 40 lines of pure Python. Dash provides direct control 2) Direct Control - Dash provides a simple interface for tying UI controls, like sliders, dropdowns, and graphs, with your Python data analysis code. Dash is Composable and Modular 3) Completely Customizable - Every aesthetic element of a Dash app is customizable. Dash apps are built and published in the Web, so the full power of CSS is available.
PyTorchis an open source machine learning library for Python, based on Torch, used for applications such as natural language processing. It is primarily developed by Facebook's artificial-intelligence research group, and Uber's "Pyro" software for probabilistic programming is built on it.
PyTorch is a python package that provides two high-level features:
Tensor computation (like numpy) with strong GPU acceleration
Deep Neural Networks built on a tape-based autodiff system
PyTorch has a unique way of building neural networks: using and replaying a tape recorder.
Most frameworks such as TensorFlow, Theano, Caffe and CNTK have a static view of the world. One has to build a neural network, and reuse the same structure again and again. Changing the way the network behaves means that one has to start from scratch.
With PyTorch, we use a technique called Reverse-mode auto-differentiation, which allows you to change the way your network behaves arbitrarily with zero lag or overhead.
Our inspiration comes from several research papers on this topic, as well as current and past work such as autograd, autograd, Chainer, etc.