OAz framework
Our framework is made of 4 software parts and one hardware section, for satisfying a great variety of possible demands.
We can take care of the entire data chain: from generation to visualization through processing.
OADB: a new database
Our database is the part of the framework that takes care of storing, cataloging and providing access to data..
OADB is a database that combines a documental model with some relational features, in order to have good performance in both reading and writing.
The database structure uses symbolic links to maintain data consistency by ensuring quick access while limitating the loading of superfluous data.
The special features are:
  • Structured data: based on verified objects according to a scheme (people, resources, objects, etc...) to maintain consistency. However, the structures can be extended by the configuration of the specific application
  • NOSQL: in order to implement a new data allocation structure
  • UUID-based: each type and each data is connected to a unique ID stored in the database structure, to have quick access to the reference data
  • JSON-like:to have an easy-to-use standard, compatible with the most popular languages (especially in web technologies)
The resulting database also has mapping and uniqueness capabilities for specific fields and object versioning.
  • Mapping: if a field is set for mapping, objects will be mapped based on its value, speeding up access.
  • Unicity: if a field is set as 'unique' the database will inhibit the possibility of having objects with two equal values of that field.
  • Versioning: if a data category is marked to have a 'history', all versions of the belonging objects will be kept, allowing complete chronological reconstruction.
  • Categorization: it is possible to categorize the data according to the containers that satisfy some logic conditions
  • Multilevel mapping: data can be mapped to multiple classifications simultaneously, each on a different level
  • Conditional data-collection: once the logical conditions and consequent actions have been defined, the database creates the corresponding statistics
libOAz/pyOAz: data interface
1 
from typing import Optional
2 
from fastapi import APIRouter
3 
from OA.PyOAZ.OADA import types, create_type, schema, ConfigFormats
4 
from OA.PyOAZ.Utils import mkuuid
5 
#from OA.PyOAZ import oa_log
6
7 
api = APIRouter(tags=["OADA Type System"])
8
9 
@api.get("/create/{basename}")
10 
def get_oada(basename: str, c: Optional[int]=None, header: Optional[bool]=False):
11 
    if c:
12 
        types = [ create_type(basename).to_json_full() for i in range(0, c) ]
13 
        return types
14
15 
    t = create_type(basename)
16 
    return t.to_json_full() if t else None
17
18 
@api.get("/schema/{basename}")
19 
def get_oada_schema(basename: str, tree: Optional[bool]=False):
20 
    return schema(basename, tree=tree)
21
22 
@api.get("/uuid")
23 
def get_uuid():
24 
    return mkuuid()
The libOAz library provides the interface between the database and applications, helping queries for optimize coding.
LibOAz is built in C++17 and bound in python, allowing for a simple interface in one of the most used languages in the world today, established as the de facto standard in artificial intelligence applications.
In fact, PyOAz is the link between OADB and the OAz web framework, managing the manipulation of the database and any errors generated, as well as the permission system of the various operators towards the database.
In addition to the functions related to the framework, libOAz also implements the signing and verification of documents through the digital signature standard CaDeS (.p7m), legally valid in Italy.
OAz WebFramework: modular webApp framework
oazhome.routes.tech.oazwebframeworkimg
The OAz web framework is based on a modular management: the applications are composed of independent modules that perform dedicated functions, which can be merged within the apps created.
Each application is made up of an 'oaz' module, containing the main logic and essential web components from which the other modules can draw, simplifying writing and standardizing the application interface.
Furthermore, the modules also incorporate the software requirements necessary for their operation, any translations and the definitions of colors and styles of the application.
It is also possible to define a module as main, causing some features of the app to use the definitions of that module as a priority over the oaz module.
Each module is composed of a backend and a frontend part, separated both in the code structure and in the web instances to improve application security.
Backend: written in python language, it contains the logic and data processing and provides APIs (through the fastAPI python library) that can be called from the frontend.
Frontend: written using Svelte + Tailwind CSS and contains the interfaces and API calls provided by the backend.
Our web framework also allow the use of accounts with different roles, and access management for each one. Roles and accesses can be set from the web configurator: an essential tool made available by the oaz module.
IDEO: IDE for OAz framework
oazhome.routes.tech.ideoimg
In order to develop our applications, we have created an IDE (integrated development environment) that is consistent with the OAz framework and automates some recurring actions during development.
IDEO, in addition to having an interface optimized for web development languages (python and svelte) and their main configurations, also incorporates the functions:
  • Modules management: you can indicate the main module of your application and easily manage its python and javascript dependencies.
  • Modules sharing: the modules that make up the application can be shared on a chosen server, giving the possibility to other developers to import the individual modules into other applications.
  • App testing: in the development phase, the application runs locally on the developer's computer, who can test the features on his browser with any changes are shown in real time.
  • App sharing: during development, the application can be shared on the server without being published, making it available to all developers who have access to the server.
  • App deploying: IDEO allows publication directly from its interface, choosing the server on which it will be published. The entire publishing process is fully automated.
  • CaDeS support: using the implementation present in the libOAz library, IDEO allows the verification and signing of digital documents in CaDeS format (.p7m).
ProtOAz: electronic DevBoard
Design screen of electronic custom board
We create multifunctional prototyping boards and electronic modules, adapting them to the various performance, computing power and consumption needs.
Depending on the need, we design the modules and boards to interface or integrate the modern standards used for open source For specific applications, we design custom boards for the required needs, implementing hardware and software