Terms
The words of the platform and what each means. One word — one notion.
Introduction
Each term is used in the documentation only in its set meaning. Using a term in another meaning is a mistake of the document, and the document is corrected.
The term «process» without a qualifier means a working process — a personal program of a person. A program started in the operating system is called an OS process. The kernel methods core.process.* work with OS processes, the methods of the function of the graph process.* — with working processes.
1 The product
Table 1 — The product
| Term | Definition |
|---|---|
| O.G.A.S., the platform | The kernel and the functions of the platform together: what starts modules, passes data and keeps documents |
| Instance | A started platform with its own data folder. There is one instance per data folder. Starting the workshop again does not make a second instance but passes the working instance a request to open the window |
| Data folder | The folder where an instance keeps processes, settings, runs and journals; by default core/data, set by the flag --data-dir |
| Workshop | The window of the platform in Windows. In it modules are added, processes and pulpits are built and used. The section of building has the same name — the left bar: graph, pulpit, modules, program journal |
| Section of the bars | A bar along the edge of the workshop as a part by meaning: «Workshop», «Programs», «Platform». At its top is the logo of the section, a sign without an action (The workshop, section 4) |
| Icon by the clock | The O.G.A.S. icon in the Windows notification area, beside the clock on the taskbar. A closed window goes to it, and the platform works on; a click on the icon brings the window back, its menu is «Open» and «Leave» (The workshop, 2.1) |
| Personal program | What a person builds in O.G.A.S.: a working process together with its pulpit |
| Analogue of a program | A program built on the platform to do the same as a known existing program. A measure of the platform: an analogue is built with the fewest modules, and a place where a module could not be done without shows a missing primitive |
| Owner | The only part that writes a thing and answers for its meaning: a document, a setting, a value, a button. The other parts go to the owner |
2 The working process
Table 2 — The working process
| Term | Definition |
|---|---|
| Working process, process | A personal program of a person: the graph, variables, the pulpit, the settings of the process, the versions of modules. The folder data/processes/<process_id>/ |
| The program is on | The state of a process in which it waits for events, keeps variables and keeps service modules running. A program that is on is not changed. Several programs can be on at once |
| Event | The cause of the start of a run: switching the program on, an element of the pulpit, a timer, a schedule, a call from another process, a message of another program, an output of a service module. The node event |
| Variable | A named value of a program, kept between runs. A variable marked «remember» is kept after the program is switched off as well |
| Variable of the run | A variable marked scope: "run": each run has its own value, from the initial one, and it goes with the run; other runs do not see what was written (The program: graph and runs, section 7) |
| Hot and cold input | An input data come to by an ordinary link is hot: the data start the node. An input joined to a variable or a constant is cold: the node does not wait for it and takes its current value at the moment of the step |
| Frame | A node inside which other nodes are placed on the canvas: «Repeat» (repeat) and «For each» (for_each) |
| Graph | The nodes and links of a working process |
| Node | A step of the graph. A module node (module) calls a module; the others are nodes of the platform |
| Node of the platform | A node without application code: event (event), variable (variable), constant (constant), write (write), condition (condition), choice (choice), switch (switch), merge (merge), take a field (take), the frames repeat and for_each, a question to the person (ask), wait (wait), signal (signal), «First time?» (first_time), «Send» (send), «Show» (show), stamp (stamp), pick (pick), a call of a process (process) and its result (result) |
| Primitive | A kind of node that cannot be built of the other kinds, or that needs an indivisibility a composite construction cannot give. Only such kinds are added to the platform; the rest is built as a subgraph (The program: graph and runs, section 3, rule 8) |
| Display node | The node «Show» (show): shows the person what came to its input — on the canvas and, when bound to the interface, in the interface — and passes the data on. A part of the program, not a tool of the workshop (The program: graph and runs, 24.3) |
| Notification | A call to the person: a title and a text, for a few seconds or until a click. Over the window — the workshop or the face of a program — when the person is in it, and when the window is closed, folded, or the person is in another program — in the corner of the screen. It is given by the node «Notify» (notify) or by the workshop itself — about a question and about a failed run; it is not kept (The program: graph and runs, 24.6; The workshop, 2.2) |
| Shorthand | A kind of node that brings no new meaning and is kept for the readability of the canvas: «Choice», «Switch», «Constant», a call of a process and its result (The program: graph and runs, section 4) |
| Condition | The node condition: sends data along the branch «yes» or «no» by the result of a test from a closed set |
| Choice | The node choice: sends data to one of many outputs by value, and, when nothing matches, to the output other |
| Switch | The node switch: a choice that tests not the data but a variable. It lets the person steer runs to the right branch with one value on the pulpit |
| Subject of the test | The value a condition and a choice test: by default the data, and if the node has a variable set, its value (The program: graph and runs, section 8) |
| Take a field | The node take: makes one field of the data that came the data (The program: graph and runs, section 21) |
| Stamp | The node stamp: the time the run began and a number of a record that does not repeat — a cold source, like a constant (The program: graph and runs, section 25) |
| Pick | The node pick: the records of a list that pass a test, and their number; adds what was found to the data (The program: graph and runs, section 26) |
| Time (node) | The node moment: a moment by the calendar — from a date in the data or the start of the run, after so many days, at such an hour; adds it to the data. Not a clock: when the run goes on, it is the same (The program: graph and runs, section 27) |
| Template | The node template: a text into which fields of the data are put — «{count} tasks not done»; it puts in, it does not count (The program: graph and runs, section 28) |
| Write by key | The ways put and remove of the node «Write»: replace, add or remove one record of a list by the value of its field key (The program: graph and runs, section 7) |
| Reset | The way reset of the node «Write»: the variable gets its initial value, as when the program is switched on, and what came is not read; so a variable is cleared (The program: graph and runs, section 7) |
| «First time?» | The node first_time: checks whether a value has been met before and remembers it, in one indivisible action (The program: graph and runs, section 20) |
| Wait | The node wait: holds its branch for a set time by the wall clock; the other branches go on working (The program: graph and runs, section 19) |
| Signal | An outside message for a waiting branch: the node signal waits for a signal with a given name and, if needed, a key; a signal is sent by a module — to its own program, by another program — with the node «Send», by the person — with the method process.signal.send (The program: graph and runs, section 22) |
| Message to a program | Data one program sends another — or itself — with the node «Send» (send) under a name: they start a run of each event of the receiver with source: "message" and this name, by its overlap rule. Unlike a call, the sender does not wait for the work of the receiver, and the receiver works as its own program (The program: graph and runs, section 23) |
| Send | The node send: passes data to another program as a message or a signal; the output sent — accepted, unsent — not accepted, with the reason (The program: graph and runs, section 23) |
| Call of a process | The node process: another process in the role of a node. Before the run it is unfolded into the graph of the called process; the result of the called process is set by its node «Result» (result) (The program: graph and runs, section 18) |
| Port | A named input or output of a node |
| Edge, link | A joining of an output of one node to an input of another |
| Point on a link | A place on the canvas a link is led through to go around; it adds no meaning, data go along the link as without it (The workshop, 5.1) |
| Note | A text the person writes on the canvas of the graph about their program; it does nothing and takes no part in a run. A shorthand kind note without ports (The workshop, 5.1) |
| Group | A named set of nodes that is started and stopped on its own. Not a kind of node but a layer over nodes (The program: graph and runs, section 17). A term of the documents and the format: on the screen of the workshop a group is called a built node, and where it is clear what is meant — a node (The workshop, 5.3) |
| Built node | The name of a group on the screen of the workshop: a node built of other nodes |
| Folded group | A group drawn as one node; its content is hidden. Groups nest in one another without a limit; in a run, folding changes nothing (The program: graph and runs, 17.1) |
| Face of a group | The ports and variables of a folded group the person marked on the nodes inside it. The face of a group is declared explicitly, not derived |
| Mark ahead | A mark with the eye on a row of a node or of a folded group of the top level — for the face of the group that will be built of them. The built group shows what was marked on its face |
| Nesting mark | A sign on the label of a node inside which something lies — groups and frames with a body (The program: graph and runs, section 17) |
| Name of a node | The words on the head of a node: its own, given by the person, or by default — the kind in words, for a module node the name of the module. It does not serve as the identifier of the node (The program: graph and runs, section 4) |
| Description of a node | The person's words about what a node or a group does and what it is for: plain text of several lines, the field description. It does not affect a run; it is written and read in the panel of the chosen thing, on the tab «General», and seen in the hint of the head (The program: graph and runs, section 4) |
| Packet | A portion of data passed along a link: JSON and references to result files. In code — packet; in the words for the person — data |
| Artifact | A file a module made during a run. In a packet it is passed as the reference artifact_handle, not as its content |
| Kind of data | What data are for the person: text, number, yes/no, list, picture, sound, video, file, anything. One list serves ports, variables, the pulpit and the canvas; a kind of its own is what is shown to the person in its own way (The program: graph and runs, 24.1) |
| Fan-out | A joining of one output to several inputs; all receivers get one and the same packet |
| Fan-in | Several sources meeting at one input. It is done only by an explicitly chosen merge rule |
| Shared object | An object of the graph the pulpit can reach: an event, a variable, the state of the work, a question to the person, switching the program on. The object belongs to the graph; the pulpit shows it, changes it and sets it going |
| Pulpit | The graphical interface of a working process, of elements attached to shared objects: sections, each with a sheet of elements. The document workspace.json |
| Graph of the interface | What the program gives its interface and what shows it, on a canvas of its own: reflections, graphic nodes and the structure of them — windows, tabs, groups, subgroups. A separate graph that refers to the working one by reflections only (The workshop, 6.8) |
| Graphic node | A node of the graph of the interface: an element — a button, a field, an indicator and others of the set of elements of the pulpit — or a container: a tab, a group, a subgroup, a window. An element has a row for each binding of its kind; a link is drawn from the point of a row to a row of a reflection (The workshop, 6.8) |
| Empty element | A graphic node without a kind: it is first bound to a row of a reflection, then it is chosen what element it is to be — of the kinds possible for that object (The workshop, 6.8) |
| Reflection | What the working graph gives the interface, on the graph of the interface: a node whose rows are shared objects — of a node as a whole, an input, an output, a parameter, a variable, the face of an assembled node. Only what is needed is taken into the interface, by the action «Into the interface» (The workshop, 6.4) |
| Element not placed | An element of the interface that has no place on the sheet: it is in the graph of the interface with all its bindings and its look, is not seen on the face of the program, and waits in the column of the step «View» (The workshop, 6.3) |
| Anchor | How an element holds on in a window bigger than the sheet as drawn: at the left, at the right, in the middle or stretched, at the top, at the bottom, in the middle or stretched; the row «When the window is bigger» in the panel of the element (The workshop, 6.3) |
| Steps of a program | The three steps of the graph window: «Graph» — the working graph, «Graph of the interface» — a canvas of its own with reflections and graphic nodes, «View» — the sheet of the interface; the sign of a step changes what the window shows, in its place (The workshop, 5.4) |
| Container | A node of the graph of the interface into which elements and other containers are put: one group at different levels. It shows what lies in it all at once — a group and a subgroup — or one at a time, with a switcher: the tabs of a window; a window is a container of the top level (The workshop, 6.8; File formats, section 7) |
| Piece of interface | A container of the graph of the interface with everything in it, kept in the library to put it into another program. It takes no links to the working graph of its program: in another they are drawn anew; once put, it is a part of that program of its own (The workshop, 6.8) |
| Working graph | The graph of a working process — what a run carries out. It is called so beside the graph of the interface |
| Element of the pulpit | A part of the pulpit from the closed set of the platform: a button, a field, an indicator and others. What an element shows, takes and sends is set by the set; the look of an element can be replaced. Elements are of four families: showing, input, action and decoration |
| Sheet of the pulpit | The field of a container laid out by hand, of a set width and height, on which an element has a place and a size; in the description of the pulpit — the sheet. The window shows the whole sheet, making it larger or smaller. A unit of the sheet is the measure of place and size on the sheet: one point of the window when the sheet is shown at full size. The step of the sheet is the number of units an element snaps to when laid out and by which the function of the pulpit looks for a place for it (The workshop, 6.3) |
| Look of an element | How an element of the pulpit is drawn: a built-in look of the set or one of your own — from the person's pictures for the states of the element. A look is a folder with the description look.json and pictures; data, not code (The workshop, 6.5; File formats, 7.2) |
| State of an element | What an element of the pulpit is in now, for which a look may have its own picture: a button is pressed, a switch is on, a run goes. The states of each kind of element are named by the set |
| Theme of the pulpit | The palette, the font, the size of letters and the roundings of one pulpit: a closed list of keys. A key the pulpit did not set is taken from the settings — the section «Default look of the pulpit». It does not mix with the look of the workshop (The workshop, 6.5) |
| Underlay | A colour or a picture under the sheet of a section of the pulpit |
| Decoration | An element of the pulpit that shows and takes nothing but dresses the sheet: a label, a frame, a picture. It is not attached to an object of the graph |
| Picture of the pulpit | An image file in the process folder, pulpit/images/: it is named by the underlay of a section and by the element «picture». The owner is the function of the pulpit (File formats, 7.2) |
| Face of a program | The pulpit of a working process over the whole window of the platform, without the frame of the workshop: so a program is used without opening the workshop. It is opened by a shortcut of the program or by an action of the workshop (The workshop, 6.6) |
| Environment of a process | One Python virtual environment (.venv) for all modules of a working process |
| Export of a process | The folder data/exports/<process_id>/ with the documents of a process and the files of its modules, holding everything needed to move the process to another instance |
| Generation of documents | The number of an agreed set of files of a process. After a failure only a whole generation is accepted |
3 Execution
Table 3 — Execution
| Term | Definition |
|---|---|
| Run | The work one event set going: from the event to the last step it led to, run_id. In the interface — «run» |
| Overlap rule | The rule that decides what is done when an event comes before its previous run has ended: putting it in a queue, replacing, or running in parallel |
| Attempt | A part of a run from a start or a resume to a stop. When a run goes on after a failure, run_id is kept and a new attempt_id is given |
| Execution | One call of a module, execution_id. A retry makes a new execution |
| Operation | A logical step of a node in a run, operation_id. When a step is retried, the operation is kept |
| Checkpoint | The saved state of a run: queues, steps done, results, the outcome |
| Retry | Carrying out again a step that ended in a refusal |
| Resume | Taking up a run from a checkpoint after a stop or a failure |
| Idempotent step | A step whose repetition does not change the result and makes no duplicates. Sending a letter, as a rule, is not idempotent |
| Unloading | Ending the OS process of a module that is not working at the moment: after a run, when the program is switched off, or when its resource, a video card for example, is needed by another module. A module that supports saving saves its intermediate state before it is unloaded |
| Clearing of runs | Deleting old runs by the setting graph.runs_keep. A run marked «Keep» is not deleted |
4 Modules
Table 4 — Modules
| Term | Definition |
|---|---|
| Module | A separate program with a manifest. It gets packets at its input and gives them at its output. The folder modules/<module_id>/ |
| Manifest | The description of a module in manifest.json: identifier, version, inputs, outputs, parameters of the node, whether a retry is allowed, the time limit |
Step module (step) |
A module whose OS process lives for one call |
Long module (long) |
A module whose OS process keeps its state between calls within a run |
Service module (service) |
A module whose OS process is started when the program is switched on and works until it is switched off. Each time it comes up it learns the nodes of its module with their parameters (configure). It can give packets by itself — for all its nodes or for a named one — and so serve as a source of events |
| Memory of a node | The folder state/<name>/ of a process into which the module of a node saves its intermediate state before unloading and from which it goes on after. It belongs to the node, not to the module: a node has its own memory, named by its identifier, or one shared with other nodes of the same module, named by the field memory of the node. It lives while at least one node names it |
| Shared memory | A memory several nodes of one module name in the field memory — the role «drawing», for example, spread over nodes of different frames. It is named explicitly and seen at every node that names it |
| Mark of the saved state | A document beside the folder of memory: the function of modules writes it when the module confirmed it saved its memory, and names in it the module, its version and its print. A node whose memory was brought up by a module of the same version and print goes on from the saved place |
| Print of a module | The sha256 checksum of the content of a module without its environment, caches and links. It shows that the files of a module changed |
| Neural network | A neural network or other big data modules of different programs use. It lies in one copy — a file or a folder in the subfolder of its kind in the folder of networks, or a link to them; a module takes a network by a parameter of type model, and which one, the node chooses (Modules, section 11) |
| Kind of neural network | A subfolder of the folder of networks, named by a module: checkpoints, loras, voices. A parameter of a module of type model takes a network of one kind, and the node chooses among the networks of that kind (Modules, section 11) |
| Folder of networks | The folder where neural networks lie, a subfolder per kind: by default models/ in the installation folder, or another named by the setting modules.models_dir (Modules, section 11) |
| OGAS SDK | A set of tools for the authors of modules and functions: the exchange by the protocol, reading a step, the answer, a refusal with a sign of retry, words for the person, the memory of a node, checking a module without the platform; the contract of a module is its manifest, the SDK carries it out and does not make it. It exists for Python — sdk/python — and for Rust — the package ogas-module in sdk/rust; functions use ogas-protocol. The guide — OGAS SDK |
| Light | A tuning of the behaviour of a text network: an addition to the outputs of its layers at every token, found from sample answers written by the person. The weights of the network do not change, and the conversation holds not a word about it; it is fitted to one network and lies as a file in the folder of networks |
5 The make-up
Table 5 — The make-up
| Term | Definition |
|---|---|
| Kernel | A long-living OS process in Rust: the lock of the instance, the socket, passing messages on, starting OS processes, writing documents, the kernel journals. It holds no knowledge of the subject area or of the other parts (Rules of development, 2.6) |
| Function of the platform, function | An OS process of the platform that does one task. The list of functions — The make-up of the platform, table 2 |
| Register of functions | The document data/functions.json, in which an instance sets for its functions where the program lies, whether it is on and the rights it is given |
| Description of a function | The document functions/<id>/function.json in the folder of the function itself: what the function needs, the contract by which it exchanges messages, its work together with the window and its restart. These are properties of the function, not a choice of the instance, so the description is kept with it (Rules of development, 2.10) |
| Optional dependency | A function from requires of the description of a function that is also named in optional: the function uses its contract while it is available, and without it works on and says what is missing. The start does not wait for it, its failure does not stop the function (The make-up of the platform, 3.4.1) |
| Check of the environment | A check of the machine a function declares in its description (the field checks), and ogas-core doctor carries out without knowing its meaning: whether a file is there, or a program with its exit code. The function tells the meaning of the outcome in its dictionary (File formats, section 3) |
| Handshake | The first message of a function to the kernel: its identifier, its capabilities and the rights it asks for. The term is kept as in the code |
| Capability | A permission of a function to use special methods of the kernel. The capability process — starting the OS processes of modules — belongs only to the function of modules |
| Command, query, event | A command changes the state, a query only reads, an event tells of what has already happened |
| Contract | A described way the parts talk: methods, events, formats of documents (Exchange with the kernel, File formats) |
| Constant of the contract | A value the parts must understand alike: the version of the protocol, the name of a format, an error code, the name of a method. It is not put into the settings; it is declared once, by name |
| Adjustable quantity | A value the person can change without editing code: a limit, a timeout, a size, a path, a colour. It is kept in the settings and described by a schema |
| Background work | Work of a function nobody waits an answer for: unloading modules after a run, clearing old runs, writing a checkpoint, a timer going off. A function tells of a failure of background work with the event function.work_failed |
| Problem | A grouped refusal that needs the person's attention. A repetition of the same refusal raises a counter rather than making a new record |
| Level of settings | The layer the value of a setting is taken from: from the default of the schema to the current session |
6 The workshop
Table 6 — The workshop
| Term | Definition |
|---|---|
| Frame of the workshop | The constant part of the workshop: the brand in the top left corner, the strip on top, the bars along the edges and the host |
| Bar | A panel on the edge of the workshop. It can be folded, unfolded, or with labels. In the words for the person — «panel» |
| Panel of programs | A bar of the right edge of the workshop: a category the person made and named themselves, with icons of the programs they put on it; a click on an icon opens the program. The platform puts nothing on a panel (The workshop, 5.6) |
| Library | A window of the workshop in the bar «Platform»: everything the person has — programs, modules, neural networks, pieces of interface — with making, accepting, handing over and deleting, and where each is seen: on which panels of programs, in the column of the graph. It is also the set of built nodes: a built node is a program of the library (The workshop, 5.6) |
| Source | A place on the network from which the library finds and downloads programs, modules and neural networks at the person's command: the O.G.A.S. showcase — by default ogas.space — Hugging Face or Civitai. A source is not a store of the platform: what is downloaded is accepted the same way as what is brought in a folder |
| Showcase | The catalogue of an O.G.A.S. source: the document ogas.catalog/1 listing programs, modules and neural networks with their files, sizes and checksums. Any site can hold a showcase; by default — ogas.space, whose showcase is signed by the site key |
| Bar of the canvas | A bar over the canvas of the graph window. There are two: the control bar by the left edge — the commands of the program, the tool bar by the right one — the tools of the graph and the highlighting (The workshop, 5.4) |
| Host | The central area of the workshop in which windows open |
| Window on the host | A window inside the workshop: process, graph, pulpit, settings, modules, journal. At the top of the window is a tab with its name and buttons |
| Column on the left | The left part of the body of a window on the host: the categories and subcategories of the window |
| Bottom bar | A row of capsules over the bottom edge of the host, for the windows folded with the «fold» button. A click on a capsule brings the window back to the host |
| Panel of the chosen | A panel over the lower part of the work area of a window, or where the person moved it: tabs about the chosen thing and a cross to «close». It appears when something is chosen; it is moved by its strip of tabs and stretched by its edge (The workshop, 5.1) |
| Capsule | The rounded shape common to bars and tabs of windows |
| Program journal | A window on the host: the runs of the chosen program — by which event begun, how ended, for a failure its reason — and the events of each run |
| Platform journal | A window on the host: the events of the platform itself — functions, modules, settings — and problems |
| Session view | The state of the workshop kept only until it is closed: the folding of bars and their labels |
7 The profile and the site
Table 7 — The profile and the site
| Term | Definition |
|---|---|
| Profile | The person on the platform's site ogas.space as the platform knows them: name, about, picture, links to their places on other networks. Everything the platform sends to the site is signed by the profile. A platform has one profile (Protection, section 8) |
| Main key | The secret of a profile. It is needed only to make the profile, to join or revoke a computer, to change or delete the profile. The platform does not keep it: it is written as the recovery code and the key file with the person |
| Recovery code | The main key written as 55 letters and digits in groups of five, to be copied onto paper. The same key as in the key file: a lost file — the code is typed in, and the profile is the same |
| Key file | The document ogas.key/1 with the recovery code, under a password if the person wishes. It is kept where the person decided, not in the data folder |
| Computer key | The key the platform signs parcels by. The main key vouched for it and named it in the card of the profile — without that the site does not take its signature; «Revoke all computers but this one» leaves one, and the profile stays |
| Letter key | The key the platform opens letters to the profile by. It is derived from the main key, so it is the same on every computer of the profile |
| Parcel | What the platform sends to ogas.space at the person's command: the document ogas.parcel/1, signed by the profile — a review, a request, «I'll do it», an offered thing, a bug report, an author's word on a bug, the author's answer to a review, a withdrawal of one's parcel, the card of the profile |
| Sendings | The parcels of the profile and what became of each on the site: waiting for a look, on the site, accepted, rejected |
| Letter | A sealed message the site keeps for one platform: an answer to a bug report, a bug in one's own thing whole, a new review of one's own thing. Only the letter key of its reader opens it |
| Site key | The key by which the author of the site signs everything the platform reads from ogas.space. Its public part is in the platform; a file whose signature does not hold is not taken |
| Counting task | A computation the platform does before sending a parcel: seconds for one parcel, costly for thousands. This guards the site from floods of parcels without registration |
| Request | A plea to build a program on the board of requests of ogas.space: what it must do, what goes in and what comes out. A request is taken with «I'll do it», and what was made is sent to the showcase with its number |
| The author's answer | The word of the author of a thing of the showcase under a review of it: only the author of that thing writes it, from their platform, and it stands under the review on the site once the author of the site has looked at it |
| Known bug | A bug of a thing of the showcase the author of the site put under the thing: what happens and in which version, with the word of the thing's author. A solved one shows the version where it was fixed |
| Incognito | A parcel on which the site shows no name of the profile. The author of the site sees whose profile it is |