You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This doesnt happen on main - only nightly v0.3.0 which is the latest release.
Compiling darwin-v7 v0.3.0(/home/jayvdb/git-workspaces/github/franklin-ai/darwin-v7)
warning: the item `serde_yaml` is imported redundantly
--> src/config.rs:3:5
|
3 | use serde_yaml;
| ^^^^^^^^^^ the item `serde_yaml` is already defined by prelude
|
= note: `#[warn(unused_imports)]` on by default
warning: the item `Team` is imported redundantly
--> src/client.rs:244:9
|
243 | use super::*;
| -------- the item `Team` is already imported here
244 | use crate::team::Team;
| ^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_imports)]` on by default
warning: the item `serde_yaml` is imported redundantly
--> src/config.rs:3:5
|
3 | use serde_yaml;
| ^^^^^^^^^^ the item `serde_yaml` is already defined by prelude
warning: the item `Fake` is imported redundantly
--> src/datasets.rs:869:16
|
867 | use super::*;
| -------- the item `Fake` is already imported here
868 | use crate::client::V7Client;869 | use fake::{Fake,Faker};
| ^^^^
error: future cannot be sent between threads safely
--> src/comment.rs:79:40
|
79 | ) -> Result<CommentThreadResponse> {
| ________________________________________^
80 | | let response = client
81 | | .post(82 | | &format!("v2/teams/{}/items/{}/comment_threads", team_slug, self.id),
... |
86 | | expect_http_ok!(response, CommentThreadResponse)87 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/comment.rs:79:40:87:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/comment.rs:86:9
|
86 | expect_http_ok!(response, CommentThreadResponse)
| ------------------------------------------------ in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/comment.rs:79:40:87:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<CommentThreadResponse, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:486:68
|
486 | async fn archive_dataset(&self, client:&C) -> Result<Dataset>{
| ____________________________________________________________________^
487 | | let response = client
488 | | .put::<String>(&format!("datasets/{}/archive", &self.id),None)489 | | .await?;490 | |
491 | | expect_http_ok!(response, Dataset)492 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:486:68:492:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:491:9
|
491 | expect_http_ok!(response, Dataset)
| ---------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:486:68:492:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<datasets::Dataset, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:543:39
|
543 | ) -> Result<AddDataItemsResponse>{
| _______________________________________^
544 | | let api_payload = AddDataItemsPayload{545 | | items:data,546 | | storage_name:external_storage,
... |
559 | | expect_http_ok!(response, AddDataItemsResponse)560 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:543:39:560:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:559:9
|
559 | expect_http_ok!(response, AddDataItemsResponse)
| ----------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:543:39:560:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<AddDataItemsResponse, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:568:47
|
568 | ) -> Result<RegisterExistingItemResponse>{
| _______________________________________________^
569 | | let api_payload = RegisterExistingItemPayload{570 | | dataset_slug:self.slug.to_string(),571 | | storage_slug:external_storage_slug,
... |
582 | | expect_http_ok!(response, RegisterExistingItemResponse)583 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:568:47:583:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:582:9
|
582 | expect_http_ok!(response, RegisterExistingItemResponse)
| ------------------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:568:47:583:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<RegisterExistingItemResponse, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:616:21
|
616 | ) -> Result<()>{
| _____________________^
617 | | let endpoint = format!(618 | | "v2/teams/{}/datasets/{}/exports",
619 | | self.team_slug.as_ref().context("Missing team slug")?,
... |
641 | | Ok(())642 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:616:21:642:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/datasets.rs:637:33
|
635 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
636 | response.status(),637 | response.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:616:21:642:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<(), anyhow::Error>> + std::marker::Send>>`
error: future cannot be sent between threads safely
--> src/datasets.rs:644:69
|
644 | async fn list_exports(&self, client:&C) -> Result<Vec<Export>> {
| _____________________________________________________________________^
645 | | let endpoint = format!(646 | | "v2/teams/{}/datasets/{}/exports",
647 | | self.team_slug.as_ref().context("Missing team slug")?,
... |
653 | | expect_http_ok!(response, Vec<Export>)654 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:644:69:654:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:653:9
|
653 | expect_http_ok!(response, Vec<Export>)
| -------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:644:69:654:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<Export>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:662:64
|
662 | async fn list_datasets(client:&C) -> Result<Vec<Dataset>>{
| ________________________________________________________________^
663 | | let response = client.get("datasets").await?;664 | |
665 | | expect_http_ok!(response, Vec<Dataset>)666 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:662:64:666:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:665:9
|
665 | expect_http_ok!(response, Vec<Dataset>)
| --------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:662:64:666:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<datasets::Dataset>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:668:80
|
668 | async fn list_dataset_items(&self, client:&C) -> Result<Vec<DatasetItem>>{
| ________________________________________________________________________________^
669 | | let response = client.get(&format!("datasets/{}/items", self.id)).await?;670 | |
671 | | expect_http_ok!(response, Vec<DatasetItem>)672 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:668:80:672:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:671:9
|
671 | expect_http_ok!(response, Vec<DatasetItem>)
| ------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:668:80:672:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<DatasetItem>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:674:71
|
674 | async fn list_dataset_items_v2(&self, client:&C) -> Result<Item>{
| _______________________________________________________________________^
675 | | let response = client
676 | | .get(&format!(677 | | "v2/teams/{}/items?dataset_ids={}",
... |
683 | | expect_http_ok!(response, Item)684 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:674:71: 684:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),
8 | $x.text().await?
| ^^^^^ await occurs here, with `{}` maybe used later
|
::: src/datasets.rs:683:9
|
683 | expect_http_ok!(response, Item)
| ------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:674:71: 684:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<item::Item, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:686:68
|
686 | asyncfn show_dataset(client: &C, id: &u32) -> Result<Dataset> {
| ____________________________________________________________________^
687 | | let response = client.get(&format!("datasets/{}", id)).await?;
688 | |
689 | | expect_http_ok!(response, Dataset)690 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:686:68: 690:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),
8 | $x.text().await?
| ^^^^^ await occurs here, with `{}` maybe used later
|
::: src/datasets.rs:689:9
|
689 | expect_http_ok!(response, Dataset)
| ---------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:686:68: 690:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<datasets::Dataset, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:744:35
|
744 | ) -> Result<WorkflowTemplate> {
| ___________________________________^
745 | | let response = client
746 | | .post(747 | | &format!("datasets/{}/workflow_templates", self.id),
... |
752 | | expect_http_ok!(response, WorkflowTemplate)753 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:744:35:753:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:752:9
|
752 | expect_http_ok!(response, WorkflowTemplate)
| ------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:744:35:753:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<WorkflowTemplate, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:770:26
|
770 | ) -> Result<Dataset>{
| __________________________^
771 | | let workflow_id = workflow.id.as_ref().context("Workflow id not provided")?;772 | |
773 | | let endpoint = format!(
... |
780 | | expect_http_ok!(response, Dataset)781 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:770:26:781:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:780:9
|
780 | expect_http_ok!(response, Dataset)
| ---------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:770:26:781:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<datasets::Dataset, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/datasets.rs:807:35
|
807 | ) -> Result<SetStageResponse>{
| ___________________________________^
808 | | let filters = if filters.is_none(){809 | | SetStageFilter{810 | | dataset_ids:vec![self.id],
... |
826 | | expect_http_ok!(response, SetStageResponse)827 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:807:35:827:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/datasets.rs:826:9
|
826 | expect_http_ok!(response, SetStageResponse)
| ------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:807:35:827:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<SetStageResponse, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/team.rs:131:70
|
131 | async fn list_memberships(client:&C) -> Result<Vec<TeamMember>>{
| ______________________________________________________________________^
132 | | let response = client.get("memberships").await?;133 | |
134 | | expect_http_ok!(response, Vec<TeamMember>)135 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/team.rs:131:70:135:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/team.rs:134:9
|
134 | expect_http_ok!(response, Vec<TeamMember>)
| ------------------------------------------ in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/team.rs:131:70:135:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<TeamMember>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/team.rs:138:90
|
138 | async fn list_annotation_classes(&self, client:&C) -> Result<TeamAnnotationClasses>{
| __________________________________________________________________________________________^
139 | | // TODO: add query params140 | | let endpoint = format!("teams/{}/annotation_classes", self.slug);141 | | let response = client.get(&endpoint).await?;142 | |
143 | | expect_http_ok!(response, TeamAnnotationClasses)144 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/team.rs:138:90:144:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/team.rs:143:9
|
143 | expect_http_ok!(response, TeamAnnotationClasses)
| ------------------------------------------------ in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/team.rs:138:90:144:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<TeamAnnotationClasses, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/team.rs:165:5
|
165 | / {166 | | let endpoint = format!("teams/{}/annotation_classes", self.slug);167 | | let response = client.post(&endpoint, class).await?;168 | |
169 | | expect_http_ok!(response, AnnotationClass)170 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/team.rs:165:5:170:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
::: src/team.rs:169:9
|
169 | expect_http_ok!(response, AnnotationClass)
| ------------------------------------------ in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/team.rs:165:5:170:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<AnnotationClass, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/workflow.rs:303:5
|
303 | / {304 | | let response = ifletSome(filter) = contains_str {305 | | client
306 | | .get(&format!(
... |
317 | | expect_http_ok!(response, Vec<WorkflowV2>)318 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/workflow.rs:303:5: 318:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),
8 | $x.text().await?
| ^^^^^ await occurs here, with `{}` maybe used later
|
::: src/workflow.rs:317:9
|
317 | expect_http_ok!(response, Vec<WorkflowV2>)
| ------------------------------------------ in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/workflow.rs:303:5: 318:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<WorkflowV2>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/workflow.rs:320:95
|
320 | asyncfn assign_items(client: &C, data: &AssignItemPayload) -> Result<AssignItemResponse> {
| _______________________________________________________________________________________________^
321 | | let response = client
322 | | .post(&format!("v2/teams/{}/items/assign", client.team()), &data)323 | | .await?;
324 | | expect_http_ok!(response, AssignItemResponse)325 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/workflow.rs:320:95: 325:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),
8 | $x.text().await?
| ^^^^^ await occurs here, with `{}` maybe used later
|
::: src/workflow.rs:324:9
|
324 | expect_http_ok!(response, AssignItemResponse)
| --------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/workflow.rs:320:95: 325:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<AssignItemResponse, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/workflow.rs:327:67
|
327 | asyncfn get_workflows(client: &C) -> Result<Vec<WorkflowV2>> {
| ___________________________________________________________________^
328 | | let response = client
329 | | .get(&format!("v2/teams/{}/workflows", client.team()))330 | | .await?;
331 | | expect_http_ok!(response, Vec<WorkflowV2>)332 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/workflow.rs:327:67: 332:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),
8 | $x.text().await?
| ^^^^^ await occurs here, with `{}` maybe used later
|
::: src/workflow.rs:331:9
|
331 | expect_http_ok!(response, Vec<WorkflowV2>)
| ------------------------------------------ in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/workflow.rs:327:67: 332:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<WorkflowV2>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
error: future cannot be sent between threads safely
--> src/workflow.rs:338:29
|
338 | ) -> Result<WorkflowV2> {
| _____________________________^
339 | | let response = client
340 | | .put(341 | | &format!("v2/teams/{}/workflows/{}", client.team(), self.id),
... |
345 | | expect_http_ok!(response, WorkflowV2)346 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/workflow.rs:338:29:346:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
:::src/workflow.rs:345:9
|
345 | expect_http_ok!(response, WorkflowV2)
| ------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/workflow.rs:338:29:346:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<WorkflowV2, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
warning: `darwin-v7` (lib) generated 1 warning
error: could not compile `darwin-v7` (lib) due to 20 previous errors;1 warning emitted
warning: build failed, waiting for other jobs to finish...
error: future cannot be sent between threads safely
--> src/datasets.rs:668:80
|
668 | async fn list_dataset_items(&self, client:&C) -> Result<Vec<DatasetItem>>{
| ________________________________________________________________________________^
669 | | let response = client.get(&format!("datasets/{}/items", self.id)).await?;670 | |
671 | | expect_http_ok!(response, Vec<DatasetItem>)672 | | }
| |_____^ future created by async block is not `Send`
|
= help: the trait `Sync` is not implemented for `core::fmt::rt::Opaque`, which is required by `{async block@src/datasets.rs:668:80:672:6}: std::marker::Send`
note: future is not `Send` as this value is used across an await
--> src/utils.rs:8:27
|
6 | "Invalid status code {} {}",
| -- has type `core::fmt::rt::Argument<'_>` which is not `Send`
7 | $x.status(),8 | $x.text().await?
| ^^^^^ await occurs here,with `{}` maybe used later
|
:::src/datasets.rs:671:9
|
671 | expect_http_ok!(response, Vec<DatasetItem>)
| ------------------------------------------- in this macro invocation
= note: required for the cast from `Pin<Box<{async block@src/datasets.rs:668:80:672:6}>>` to `Pin<Box<dyn futures::Future<Output = Result<Vec<item::DatasetItem>, anyhow::Error>> + std::marker::Send>>`
= note: this error originates in the macro `expect_http_ok` (in Nightly builds, run with -Z macro-backtrace for more info)
warning: `darwin-v7` (lib test) generated 3 warnings
error: could not compile `darwin-v7` (lib test) due to 20 previous errors;3 warnings emitted
The text was updated successfully, but these errors were encountered:
This doesnt happen on
main- only nightly v0.3.0 which is the latest release.The text was updated successfully, but these errors were encountered: