dora-rs
/
dora
Not watched
1
0
Fork 0
Code
Releases 124 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
3461 Commits
57 Branches
16 MB
7694 Download
Tree: 51ed0194c7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '51ed0194c7'
${ noResults }
dora/apis/python/node/Cargo.toml

Cargo.toml 1.1 kB
Raw Normal View History

init `dora-node-api-python`
3 years ago
Release dora-rs version 0.1.3
3 years ago
init `dora-node-api-python`
3 years ago
chore: use workspace edition
1 year ago
add documentation and description to all crates test rc 2 version fix version typo Test crates.io new dora tag release
2 years ago
​
Add missing licenses and centralise license definition test new crates version release
2 years ago
Set `repository` metadata for all our crates
1 year ago
init `dora-node-api-python`
3 years ago
​
​
Remove code duplicate for tracing subscriber and use env variable to manage log level. The intent of this commit is to remove the quantity of log that is being pushed to user. This commit removes the redeclaration of a set up tracing methods to centralise the tokio-tracing subscriber within the extension crate. It also add the feature to filter information based on Environment variable. This makes it possible to define the log level for tokio tracing like this: ``` RUST_LOG=debug dora-daemon --run-dataflow dataflow.yml ``` I have also unified the feature flag to make it easier to manage tracing features among the workspace. I did not change the default behaviour of tracing in our crates and therefore by using the command above you should get the same tracing log as before. fix merge conflict generated
2 years ago
Adding `recv_async` dora method to retrieve data in python async
10 months ago
Remove code duplicate for tracing subscriber and use env variable to manage log level. The intent of this commit is to remove the quantity of log that is being pushed to user. This commit removes the redeclaration of a set up tracing methods to centralise the tokio-tracing subscriber within the extension crate. It also add the feature to filter information based on Environment variable. This makes it possible to define the log level for tokio tracing like this: ``` RUST_LOG=debug dora-daemon --run-dataflow dataflow.yml ``` I have also unified the feature flag to make it easier to manage tracing features among the workspace. I did not change the default behaviour of tracing in our crates and therefore by using the command above you should get the same tracing log as before. fix merge conflict generated
2 years ago
Adding metrics for node api
10 months ago
Adding `recv_async` dora method to retrieve data in python async
10 months ago
Enable python to use opentelemetry by default ( if env variable is configured for it)
2 years ago
Remove code duplicate for tracing subscriber and use env variable to manage log level. The intent of this commit is to remove the quantity of log that is being pushed to user. This commit removes the redeclaration of a set up tracing methods to centralise the tokio-tracing subscriber within the extension crate. It also add the feature to filter information based on Environment variable. This makes it possible to define the log level for tokio tracing like this: ``` RUST_LOG=debug dora-daemon --run-dataflow dataflow.yml ``` I have also unified the feature flag to make it easier to manage tracing features among the workspace. I did not change the default behaviour of tracing in our crates and therefore by using the command above you should get the same tracing log as before. fix merge conflict generated
2 years ago
init `dora-node-api-python`
3 years ago
Remove static path from workspace dependency Removing those path make it easier to move package, reduce path management reduce complexity and make it easier to export crates to `crates.io`
2 years ago
​
Rename and use multiple_pymethods trait
1 year ago
Adding `next`, `send_output` for Python node API Adding `next` and `send_output` requires an async threadpool as the communication Layer defined by the Middleware Layer returns an async Future stream. I solve this issue by adding a tokio runtime on a separater thread that is connected with two channels. One for sending data and one for receiving data. Those channel are then exposed synchronously to Python. This should not be cause for concern as channel are really fast. Looking at Zenoh Python client, they are heavily using `pyo3-asyncio` implementation of futures to pass Rust futures into Python. This can be a solution as well, but, from previous experiment, I'm concerned about performance on such solution. I have experienced that putting futures from Rust into the `asyncio` queue to be slow. I'm concerned also by mixing `async` and `sync` code in Python, as it might be blocking. This might requires 2 threadpool in Python. This might seem as heavy overhead for some operations.
3 years ago
​
Update python node API to work with synchronous Rust node API
3 years ago
Simplyfing the metrics functionality by using meter provider instead of the global meter.
2 years ago
Rework and refactor for two-step build
7 months ago
Adding run comand within python API
10 months ago
Update `arrow` and `pyo3` dependencies to latest versions
2 years ago
​
Update `pyo3` and `arrow` version to use latest version
2 years ago
Import ros2_bridge as experimental submodule of python node API
2 years ago
Bump arrow version to latest version
10 months ago
Adding run comand within python API
10 months ago
Adding `next`, `send_output` for Python node API Adding `next` and `send_output` requires an async threadpool as the communication Layer defined by the Middleware Layer returns an async Future stream. I solve this issue by adding a tokio runtime on a separater thread that is connected with two channels. One for sending data and one for receiving data. Those channel are then exposed synchronously to Python. This should not be cause for concern as channel are really fast. Looking at Zenoh Python client, they are heavily using `pyo3-asyncio` implementation of futures to pass Rust futures into Python. This can be a solution as well, but, from previous experiment, I'm concerned about performance on such solution. I have experienced that putting futures from Rust into the `asyncio` queue to be slow. I'm concerned also by mixing `async` and `sync` code in Python, as it might be blocking. This might requires 2 threadpool in Python. This might seem as heavy overhead for some operations.
3 years ago
​
​
Fix CD errors and try to release new version
2 years ago
 1234567891011121314151617181920212223242526272829303132333435363738 
  1. [package]

  2. version.workspace = true

  3. name = "dora-node-api-python"

  4. edition.workspace = true

  5. documentation.workspace = true

  6. description.workspace = true

  7. license.workspace = true

  8. repository.workspace = true

  9. 

  10. # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

  11. 

  12. [features]

  13. default = ["tracing", "metrics", "telemetry", "async"]

  14. tracing = ["dora-node-api/tracing"]

  15. metrics = ["dora-node-api/metrics"]

  16. async = ["pyo3/experimental-async"]

  17. telemetry = ["dora-runtime/telemetry"]

  18. 

  19. [dependencies]

  20. dora-node-api = { workspace = true }

  21. dora-operator-api-python = { workspace = true }

  22. pyo3.workspace = true

  23. eyre = "0.6"

  24. serde_yaml = "0.8.23"

  25. flume = "0.10.14"

  26. dora-runtime = { workspace = true, features = ["tracing", "metrics", "python"] }

  27. dora-cli = { workspace = true }

  28. dora-download = { workspace = true }

  29. arrow = { workspace = true, features = ["pyarrow"] }

  30. pythonize = { workspace = true }

  31. futures = "0.3.28"

  32. dora-ros2-bridge-python = { workspace = true }

  33. # pyo3_special_method_derive = "0.4.2"

  34. tokio = { version = "1.24.2", features = ["rt"] }

  35. 

  36. [lib]

  37. name = "dora"

  38. crate-type = ["cdylib"]

DORA (Dataflow-Oriented Robotic Architecture) is middleware designed to streamline and simplify the creation of AI-based robotic applications. It offers low latency, composable, and distributed datafl