dynos-core
Pure-Python types for describing a planning domain. Predicates, transitions,
object types, and the world states they describe. dynos-core is the data
layer that every other DYNOS package shares.
This contains no planner, no executor, and no network code, it's just classes that define a domain. The DYNOS backend reads these structures to plan/execute/monitor/verify, clients read them to talk about goals, both share the same in-memory representation.
Most users do not install dynos-core directly, You get it transitively when
you pip install dynos-client (or any package above it). Install it on its own
if you are authoring a new domain (or extending a new one, like when making
custom actions) and want the lowest-level types without pulling in the HTTP
client.
Install
pip install dynos-core
Single dependency: varname. This is used to infer the names of objects being
created.
Concepts
DYNOS describes the world as a set of named facts (fluents) about typed objects. A goal is a state of those facts; a plan is a sequence of transitions that move from one state to another. Actions are specific code implementations of transitions.
Fluents and ground atoms
A fluent is a named, parameterised proposition. make_new_fluent creates one;
calling it on specific objects creates a GroundAtom. This is a fluent
applied to particular arguments.
from dynos_core import make_new_fluent, ObjectType, World
class Robot(ObjectType): ...
class Room(ObjectType): ...
at = make_new_fluent("at", robot=Robot, room=Room)
r = Robot("r1")
kitchen = Room("kitchen")
current = World({at(r, kitchen)})
print(at(r, kitchen) in current) # True
A World is a frozenset of GroundAtom describing what is currently true. In
the current implementation, anything not in the set is false (closed-world
assumption), but more principled approaches are being designed.
Object types and value fields
An ObjectType is a category of thing in the domain. For example, Robot, Room,
Zone, Coordinate. ValueField descriptors attach typed numeric/string fields:
from dynos_core import ObjectType, ValueField
class Zone(ObjectType):
altitude = ValueField(float)
vertices = ValueField(list)
The class is pure Python; instances live in a backend-managed numeric database
at runtime, accessible through the same descriptor syntax
(zone.altitude.get() / .set(70.0)). dynos-core only declares the schema.
Transitions
A Transition is an action schema: name, parameter type, preconditions,
effects. It says nothing about how the action runs.
from dynos_core import Transition, TransitionParams
class GotoParams(TransitionParams):
start: Room
end: Room
goto = Transition("goto", params_type=GotoParams).define(
preconditions=[at(GotoParams.start)],
adds=[at(GotoParams.end)],
removes=[at(GotoParams.start)],
)
The define() call stores the symbolic spec on the transition. The dynos
backend extends Transition with cost callbacks, applicability checks, and
execution hooks; this package's Transition is just data.
Extensions
extend_object_type and extend_transition_params add fields after the class
is declared. This supports the publish-stub pattern: a domain package
declares a small public schema; the backend extends it with private fields at
import time. The public release strips the extension calls so users see only
the public surface.
from dynos_core.extension import extend_object_type
extend_object_type(Zone, depth=ValueField(float)) # backend-only addition
See extension.py for the full rules (additive only, must run before any plan construction, etc.).
What dynos-core does NOT do
- No planner. The actual planning lives in the
dynosbackend (not on PyPI). - No
@Action/@Belief/@Scriptdecorators. Those run code; this package is data only. They live in the backend (and you import them fromdynos.databases.typed_actionwhen building a backend; or via the conditional-import pattern documented indynos-client's README when authoring client-only code). - No network or robot connectivity. That's
dynos-client.
Public API
| Symbol | Purpose |
|---|---|
GroundAtom |
A fluent applied to specific objects; the leaf of the symbolic state tree. |
World |
Frozenset of GroundAtom; one snapshot of the symbolic state. |
FluentBase |
Base class for fluents (rarely instantiated directly). |
make_new_fluent(name, **types) |
Factory: returns a callable that produces GroundAtom. |
make_new_object(type, name, **fields) |
Factory: registers an ObjectType instance with the numeric database. |
Transition |
Action schema (preconditions, effects, parameter type). |
TransitionParams |
Base class for typed parameter dataclasses. |
PrimitiveAction |
Frozen (action_name, parameters) pair; what flows over the wire. |
ObjectType |
Base class for typed domain entities. |
SymbolicObject |
An instance of an ObjectType. |
ValueField |
Descriptor for typed numeric/string attributes on ObjectType. |
Next
To talk to a running DYNOS backend, install dynos-client. To get the Sentry
survey vocabulary, install dynos-sentry-domain. The walkthrough at
user_guide.md ties them together end-to-end.
Metadata
Release files for dynos-core 0.2.5
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| dynos_core-0.2.5.tar.gz | 33.1 kB | Without provenance | Details for dynos_core-0.2.5.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| dynos_core-0.2.5-py3-none-any.whl | Python 3 | none | any | Details for dynos_core-0.2.5-py3-none-any.whl |
Total release size: 68.5 kB
Release files / dynos_core-0.2.5.tar.gz
| Download URL | dynos_core-0.2.5.tar.gz |
|---|---|
| Size | 33.1 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
41bad6c2c854844f0d490216e2275ecdaab659f600e65b0b5bcae2c308b453f0
|
|
BLAKE2b-256 checksum How to use checksums |
f4feda81584bd7a625c3748ac1fb146e6e1d0c9c507ba3b24a1dc1735b175ad5
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/6.1.0 CPython/3.8.10
|
Release files / dynos_core-0.2.5-py3-none-any.whl
| Download URL | dynos_core-0.2.5-py3-none-any.whl |
|---|---|
| Size | 35.4 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
02d51840656408d4b379b3155c7240f87a175146de21fdf22c6d938d9b3dc794
|
|
BLAKE2b-256 checksum How to use checksums |
cd37bd1c5443f971d6ed039fe782bdc7226236f32137d98865ad60fa63ccaae0
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/6.1.0 CPython/3.8.10
|
Security for dynos-core 0.2.5
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.