PyPI 官网下载 | flask_boiler-0.0.2.dev15.tar.gz

# flask-boiler [](https://travis-ci.com/billyrrr/flask-boiler) [](https://coveralls.io/github/billyrrr/flask-boiler?branch=master) [](https://flask-boiler.readthedocs.io/en/latest/?badge=latest) "boiler": **B**ackend-**O**riginated **I**nstantly-**L**oaded **E**ntity **R**epository Note: in Context, a proxy is configured to support Firestore operation in China; This may result in safety issues. Make sure that this setting is okay with you. If not, raise an issue. ``` """ TODO: NOTE that PROXY is used here Best be replaced for Safety reasons ATTENTION: """ os.environ["HTTP_PROXY"] = "http://34.85.42.121:8899" os.environ["HTTPS_PROXY"] = "http://34.85.42.121:8899" ``` Flask-boiler manages your application state with Firestore. You can create view models that aggregates underlying data sources and store them immediately and permanently in Firestore. As a result, your front end development will be as easy as using Firestore. Flask-boiler is comparable to Spring Web Reactive. Demo: When you change the attendance status of one of the participants in the meeting, all other participants receive an updated version of the list of people attending the meeting.  Some reasons that you may want to use this framework or architectual practice: - You want to build a reactive system and not just a reactive view. - You want to build a scalable app that is native to distributed systems. - You want a framework with a higher level of abstraction, so you can exchange components such as transportion protocols - You want your code to be readable and clear and written mostly in python, while maintaining compatibility to different APIs. - You have constantly-shifting requirements, and want to have the flexibility to migrate different layers, for example, switch from REST API to WebSocket to serve a resource. This framework is at ***beta testing stage***. API is not guaranteed and ***may*** change. Documentations: [readthedocs](https://flask-boiler.readthedocs.io/) Quickstart: [Quickstart](https://flask-boiler.readthedocs.io/en/latest/quickstart_link.html) API Documentations: [API Docs](https://flask-boiler.readthedocs.io/en/latest/apidoc/flask_boiler.html) Example of a Project using flask-boiler: [gravitate-backend](https://github.com/billyrrr/gravitate-backend) [Related Technologies](https://medium.baqend.com/real-time-databases-explained-why-meteor-rethinkdb-parse-and-firebase-dont-scale-822ff87d2f87) ## Ideal Usage boiler will compile your python code into flink jobs, web servers, and more to be run on a kubernetes engine (not currently implemented).  ## Introduction boiler is technically MVVM (Model-View-ViewModel), where, 1. Model consists of a transactional database or datastore, and lives in back end. 2. ViewModel consists of a distributed state consists of Model and aggregator. It is the main part of boiler. For client-read, it receives the streams coming in from the Model layer, and output them as a View to the View layer. For client-write, it receives the change streams from View layer, and operate on Model layer to persist the change. ViewModel lives in the back end, and may be operated as boiler python code, or compiled as flink jobs in the case of big data application (to be implemented). 3. View is the presentational layer for the back end. It serves 1NF normalized data that are readable to the front end without further aggregation. Client reads and writes to View. View should be ephemeral, and can be rebuilt from ViewModel. View may be a remote system, eg. firestore or leancloud. ## Installation In your project directory, ``` pip install flask-boiler ``` See more in [Quickstart](https://flask-boiler.readthedocs.io/en/latest/quickstart_link.html). <!--## Usage--> <!--### Business Properties Binding--> <!--You can bind a view model to its business properties (underlying domain model).--> <!--See `examples/binding_example.py`. (Currently breaking)--> <!--```python--> <!--vm: Luggages = Luggages.new(vm_ref)--> <!--vm.bind_to(key=id_a, obj_type="LuggageItem", doc_id=id_a)--> <!--vm.bind_to(key=id_b, obj_type="LuggageItem", doc_id=id_b)--> <!--vm.register_listener()--> <!--```--> ### State Management You can combine information gathered in domain models and serve them in Firestore, so that front end can read all data required from a single document or collection, without client-side queries and excessive server roundtrip time. There is a medium [article](https://medium.com/resolvejs/resolve-redux-backend-ebcfc79bbbea) that explains a similar architecture called "reSolve" architecture. See ```examples/meeting_room/view_models``` on how to use flask-boiler to expose a "view model" in firestore that can be queried directly by front end without aggregation. ### Processor Modes `flask-boiler` is essentially a framework for source-sink operations: ``` Source(s) -> Processor -> Sink(s) ``` Take query as an example, - Boiler - NoSQL - Flink - staticmethods: converts to UDF - classmethods: converts to operators and aggregator's ### Declare View Model ```python class CityView(ViewModel): name = attrs.bproperty() country = attrs.bproperty() @classmethod def new(cls, snapshot): store = CityStore() store.add_snapshot("city", dm_cls=City, snapshot=snapshot) store.refresh() return cls(store=store) @name.getter def name(self): return self.store.city.city_name @country.getter def country(self): return self.store.city.country @property def doc_ref(self): return CTX.db.document(f"cityView/{self.store.city.doc_id}") ``` ### Document View ``` python class MeetingSessionGet(Mediator): from flask_boiler import source, sink source = source.domain_model(Meeting) sink = sink.firestore() # TODO: check variable resolution order @source.triggers.on_update @source.triggers.on_create def materialize_meeting_session(self, obj): meeting = obj assert isinstance(meeting, Meeting) def notify(obj): for ref in obj._view_refs: self.sink.emit(reference=ref, snapshot=obj.to_snapshot()) _ = MeetingSession.get( doc_id=meeting.doc_id, once=False, f_notify=notify ) # mediator.notify(obj=obj) @classmethod def start(cls): cls.source.start() ``` ### WebSocket View ```python class Demo(WsMediator): pass mediator = Demo(view_model_cls=rainbow_vm, mutation_cls=None, namespace="/palette") io = flask_socketio.SocketIO(app=app) io.on_namespace(mediator) ``` ### Create Flask View You can use a RestMediator to create a REST API. OpenAPI3 docs will be automatically generated in ```<site_url>/apidocs``` when you run ```_ = Swagger(app)```. ```python app = Flask(__name__) class MeetingSessionRest(Mediator): # from flask_boiler import source, sink view_model_cls = MeetingSessionC rest = RestViewModelSource() @rest.route('/<doc_id>', methods=('GET',)) def materialize_meeting_session(self, doc_id): meeting = Meeting.get(doc_id=doc_id) def notify(obj): d = obj.to_snapshot().to_dict() content = jsonify(d) self.rest.emit(content) _ = MeetingSessionC.get( doc_id=meeting.doc_id,