Create JSON:API and Web App from database, with LogicBank -- 40X more concise, Python for extensibility.
Project description
API Logic Server
There is widespread agreement that APIs are strategic to the business, required for mobile apps and internal / external systems integration.
The problem is that they are time-consuming and costly to develop. This reduces strategic business agility.
API Logic Server provides exceptional strategic business agility, by creating an executable server for a database, instantly. Working Software, now.
As illustrated below, the ApiLogicServer CLI
(command line interface) creates an API Logic Server,
from your database. An Api Logic Server implements these features:
Feature | Using | Providing | Why it Matters |
---|---|---|---|
1. JSON:API and Swagger | SAFRS | APIs that clients can configure to reduce network traffic |
Unblock Client App Dev |
2. Transactional Logic | Logic Bank | Spreadsheet-like Rules are 40X more concise Compare Check Credit with legacy code |
Strategic Business Agility |
3. Basic Web App | Flask App Builder, fab-quickstart |
Instant multi-page, multi-table web app | Engage Business Users Back-office Admin |
4. Model Creation | SQLAlchemy | Python-friendly ORM | Custom Data Access Used by API and Basic Web App |
This declarative approach is based on standard Python tooling, and can be installed and customized with standard approaches as described below.
Tutorials
There are a number of facilities that will quickly enable you to get familiar with API Logic Server:
- Tutorial walks you through the steps of creating a server
- Video shows the steps of creating a server
- Cloud Demo enables you to run the demo using a cloud-based (MyBinder) install
Quick Start - Create and Run
With a single command, create and run a logic-enabled JSON:API and web app for your database:
Run ApiLogicServer CLI
As illustrated above, you run the ApiLogicServer CLI:
ApiLogicServer run # note: you can also create (without execution)
The CLI provides a number of options you can discover with ApiLogicServer --help
.
In particular:
-
The
-db_url
parameter defaults to a supplied sample database.- Specify a SQLAlchemy url to use your own database.
-
By default, the project name (directory) is
api_logic_server
- override it with the-project_name
option. -
Discover other options with
ApiLogicServer run --help
Creates Customizable Project
The CLI introspects your database, and creates a project. You can open this in your IDE and customize it as shown below.
Runs Project - Working Software Now
The CLI then starts the API. As illustrated above, the project implements:
-
Your API, available in Swagger
-
With underlying logic
-
And a
basic_web_app
Customize the Created Project
Here is the created project; you can open it in any IDE or Editor - here it is in PyCharm:
Typical customizations include (explore the default sample database to see examples):
-
Customize API: edit
api/expose_services.py
to define your own endpoints, complementing those created from the model -
Customize Model: edit
models_ext.py
, for example- to define relationships, critical for multi-table logic, APIs, and web apps
- to describe derived attributes, so that your API, logic and apps are not limited to the physical data model
-
Customize Logic: edit
models/logic_bank.py
(initially empty) to declare logic- The default sample database project contains some simple rules you can review; learn more about rules in the Logic Bank
After customization, your api_logic_server
project can be re-executed (without creating).
To run it:
-
Specify a proper
venv
(virtual environment)- The one used for ApiLogicServer install is fine, or you can use a project-specific virtual environment
-
Then:
python api_logic_server_run.py
python ui/basic_web_app/run.py
Features
API: SAFRS JSON:API and Swagger
Your API is instantly ready to support ui and integration development, available in swagger:
Customize your API by editing
api/expose_services.py
, and see Customizing
Logic
Transactional business logic - multi-table derivations and constraints - is a significant portion of database systems, often nearly half. Procedural coding is time-consuming to develop and maintain, reducing business agility.
ApiLogicServer integrates Logic Bank, spreadsheet-like rules that reduce transaction logic by 40X. Logic is declared in Python (example below), and is:
-
Extensible: logic consists of rules (see below), plus standard Python code
-
Multi-table: rules like
sum
automate multi-table transactions -
Scalable: rules are pruned and optimized; for example, sums are processed as 1 row adjustment updates, rather than expensive SQL aggregate queries
-
Manageable: develop and debug your rules in IDEs, manage it in SCS systems (such as
git
) using existing procedures
The following 5 rules represent the same logic as 200 lines of Python:
Declare your logic by editing:
logic/logic_bank.py
Basic Web App - Flask Appbuilder
UI development takes time. That's a problem since
-
Such effort may not be warranted for admin "back office" screens, and
-
Agile approaches depend on getting working software soon, to drive collaboration and iteration.
ApiLogicServer CLI therefore creates working software now: multi-page, multi-table applications as shown below:
-
Multi-page: apps include 1 page per table
-
Multi-table: pages include
related_views
for each related child table, and join in parent data -
Favorite fields first: first-displayed field is "name", or
contains
"name" (configurable) -
Predictive joins: favorite field of each parent is shown (product name - not product id)
-
Ids last: such boring fields are not shown on lists, and at the end on other pages
Customize your app by editing:
ui/basic_web_app/app/views.py
Before running, some setup is required for Flask App Builder (except for Northwind, which is pre-created).
Installation
Caution: Python install is rather more than running an installer. Use this page to Verify / Install Python.
Then, install the ApiLogicServer CLI in the usual manner:
virtualenv venv # may require python3 -m venv venv
source venv/bin/activate # windows venv\Scripts\activate
pip install ApiLogicServer # you may need to restart your terminal session
Important News - Certificate Issues
We are starting to see Python / Flask AppBuilder Certificate issues - see Troubleshooting.
Default Python version
In some cases, your computer may have multiple Python versions, such as python3
. ApiLogicServer run
relies on the default Python being 3.8 or higher. You can resolve this by:
- making this the default
- using
ApiLogicServer create
, and runningpython3 api_logic_server_run.py
Learning
Take the tutorial to run your locally installed software.
If you'd like to try it with no install on the Cloud, use this version of the Tutorial.
Project Information
Status
Initially released 1/19/2021, the project has stabilized:
-
The default Northwind project is working with for both the API and the web app, with pre-created logic (good to explore for examples)
-
We have tested several sqlite databases, and several MySQL databases - see status here. These are successfully creating / executing the API and the web app.
We are tracking issues in git.
Acknowledgements
Many thanks to
- Armin Ronacher, for Flask
- Mike Bayer, for SQLAlchemy
- Thomas Pollet, for SAFRS
- Daniel Gaspar, for Flask AppBuilder
- Alex Grönholm, for Sqlacodegen
- Denny McKinney, for Tutorial review
- Achim Götz, for design collaboration and testing
- Michael Holleran, for design collaboration and testing
- Nishanth Shyamsundar, for review and testing
- Thomas Peters, for review and testing
- Gloria Huber and Denny McKinney, for doc review
Articles
There are a few articles that provide some orientation to Logic Bank and Flask App Builder. These technologies are automatically created when you use ApiLogicServer:
- Instant Database Backends
- Extensible Rules - defining new rule types, using Python
- Declarative - exploring multi-statement declarative technology
- Automate Business Logic With Logic Bank - general introduction, discussions of extensibility, manageability and scalability
- Agile Design Automation With Logic Bank - focuses on automation, design flexibility and agile iterations
- Instant Web Apps
Change Log
04/20/2021 - 02.00.12: pythonanywhere - port option, wsgi creation
04/13/2021 - 02.00.10: Improved model error recovery; fix sql/server char type (issues # 13)
04/11/2021 - 02.00.06: Minor - additional CLI info
04/09/2021 - 02.00.05: Bug Fix - View names with spaces
03/30/2021 - 02.00.02: Create Services table to avoid startup issues
03/23/2021 - 02.00.01: Minor doc changes, CLI argument simplification for default db_url
03/17/2021 - 02.00.00: Create create_admin.sh, copy sqlite3 DBs locally, model_ext
03/10/2021 - 01.04.10: Fix issues in creating Basic Web App
03/03/2021 - 01.04.09: Services, cleanup main api_run
02/23/2021 - 01.04.08: Minor - proper log level for APIs
02/20/2021 - 01.04.07: Tutorial, Logic Bank 0.9.4 (bad warning message)
02/08/2021 - 01.04.05: add employee audit foreign key in nw.sqlite
02/07/2021 - 01.04.04: fix default project name
02/07/2021 - 01.04.03: db_url default (for Jupyter)
02/07/2021 - 01.04.02: Internal Renaming
02/06/2021 - 01.04.00: Fix constraint reporting, get related (issues 7,8)
01/31/2021 - 01.03.00: Resolve n:m relationships (revised models.py)
01/29/2021 - 01.02.04: Minor cleanup
01/29/2021 - 01.02.03: Flask AppBuilder fixes - Admin setup, class vs table names (wip)
01/28/2021 - 01.02.02: Command line cleanup
01/27/2021 - 01.02.00: Many
- Host option
- --from_git defaults to local directory
- hello world example
- nw rules pre-created
01/25/2021 - 01.01.01: MySQL fixes
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for ApiLogicServer-2.0.14-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 8ae84bca425314cb58b1fbb6da0c28f5b3ef3e82374d1bc3df006b17aa0bff0c |
|
MD5 | c9e78ba4c96e8a078de7a4e45bedd15d |
|
BLAKE2b-256 | 9d866ee1f90895259108d93bd806bd4b301e4a854090c06e89a503216d661d41 |