18554766227

Committed 16 Oct 2025 08:12AM UTC coverage: 88.843% (+0.3%) from 88.543%

Build # 18554766227

Build Type

push

github

Committed by

web-flow

Commit Message

build: update dependencies (#1081)

* update sqlfluff

* clippy autofix

* manual clippy fixes

* removal of unused code

* update deps

* upgrade packages

* enable cargo lints

* make sqlfluff happy

* fix chrono parsin error

* clippy

* byte_size

* fix image cmp with tiffs

* remove debug

Run Details

177 of 205 new or added lines in 38 files covered. (86.34%)

41 existing lines in 20 files now uncovered.

106415 of 119779 relevant lines covered (88.84%)

84190.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.19

/services/src/machine_learning/postgres.rs

use crate::{
    contexts::PostgresDb,
    machine_learning::{
        MlModel, MlModelDb, MlModelId, MlModelIdAndName, MlModelListOptions,
        error::{
            MachineLearningError,
            error::{Bb8MachineLearningError, PostgresMachineLearningError},
        },
    },
    permissions::Permission,
    util::postgres::PostgresErrorExt,
};
use async_trait::async_trait;
use geoengine_datatypes::{machine_learning::MlModelName, util::Identifier};
use snafu::ResultExt;
use tokio_postgres::{
    Socket,
    tls::{MakeTlsConnect, TlsConnect},
};

#[async_trait]
impl<Tls> MlModelDb for PostgresDb<Tls>
where
    Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static + std::fmt::Debug,
    <Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
    <Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
    <<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,
{
    async fn list_models(
        &self,
        options: &MlModelListOptions,
    ) -> Result<Vec<MlModel>, MachineLearningError> {
        let conn = self
            .conn_pool
            .get()
            .await
            .context(Bb8MachineLearningError)?;

        let rows = conn
            .query(
                "
                SELECT
                    m.id,
                    m.name,
                    m.display_name,
                    m.description,
                    m.upload,
                    m.metadata,
                    m.file_name
                FROM 
                    user_permitted_ml_models u JOIN ml_models m ON (u.ml_model_id = m.id)
                WHERE 
                    u.user_id = $1
                ORDER BY
                    name
                OFFSET
                    $2
                LIMIT 
                    $3",
                &[
                    &self.session.user.id,
                    &i64::from(options.offset),
                    &i64::from(options.limit),
                ],
            )
            .await
            .context(PostgresMachineLearningError)?;

        let models = rows
            .into_iter()
            .map(|row| MlModel {
                name: row.get(1),
                display_name: row.get(2),
                description: row.get(3),
                upload: row.get(4),
                metadata: row.get(5),
                file_name: row.get(6),
            })
            .collect();

        Ok(models)
    }

    async fn load_model(&self, name: &MlModelName) -> Result<MlModel, MachineLearningError> {
        let conn = self
            .conn_pool
            .get()
            .await
            .context(Bb8MachineLearningError)?;

        let Some(row) = conn
            .query_opt(
                "SELECT
                    m.id,
                    m.name,
                    m.display_name,
                    m.description,
                    m.upload,
                    m.metadata,
                    m.file_name
                FROM 
                    user_permitted_ml_models u JOIN ml_models m ON (u.ml_model_id = m.id)
                WHERE 
                    u.user_id = $1 AND m.name = $2::\"MlModelName\"",
                &[&self.session.user.id, name],
            )
            .await
            .context(PostgresMachineLearningError)?
        else {
            return Err(MachineLearningError::ModelNotFound { name: name.clone() });
        };

        Ok(MlModel {
            name: row.get(1),
            display_name: row.get(2),
            description: row.get(3),
            upload: row.get(4),
            metadata: row.get(5),
            file_name: row.get(6),
        })
    }

    async fn add_model(&self, model: MlModel) -> Result<MlModelIdAndName, MachineLearningError> {
        self.check_ml_model_namespace(&model.name)?;

        let mut conn = self
            .conn_pool
            .get()
            .await
            .context(Bb8MachineLearningError)?;

        let tx = conn
            .build_transaction()
            .start()
            .await
            .context(PostgresMachineLearningError)?;

        let id = MlModelId::new();

        tx.query_one(
            "INSERT INTO ml_models (
                    id,
                    name, 
                    display_name, 
                    description,
                    upload,
                    metadata,
                    file_name
                ) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING id;",
            &[
                &id,
                &model.name,
                &model.display_name,
                &model.description,
                &model.upload,
                &model.metadata,
                &model.file_name,
            ],
        )
        .await
        .map_unique_violation("ml_models", "name", || {
            MachineLearningError::DuplicateMlModelName {
                name: model.name.clone(),
            }
        })?;

        let stmt = tx
            .prepare(
                "INSERT INTO permissions (role_id, permission, ml_model_id) VALUES ($1, $2, $3);",
            )
            .await
            .context(PostgresMachineLearningError)?;

        tx.execute(&stmt, &[&self.session.user.id, &Permission::Owner, &id])
            .await
            .context(PostgresMachineLearningError)?;

        tx.commit().await.context(PostgresMachineLearningError)?;

        Ok(MlModelIdAndName {
            id,
            name: model.name,
        })
    }

    async fn resolve_model_name_to_id(
        &self,
        model_name: &MlModelName,
    ) -> Result<Option<MlModelId>, MachineLearningError> {
        let conn = self
            .conn_pool
            .get()
            .await
            .context(Bb8MachineLearningError)?;

        let stmt = conn
            .prepare(
                "SELECT id
        FROM ml_models
        WHERE name = $1::\"MlModelName\"",
            )
            .await?;

        let row_option = conn.query_opt(&stmt, &[&model_name]).await?;

        Ok(row_option.map(|row| row.get(0)))
    }
}

1	use crate::{
2	contexts::PostgresDb,
3	machine_learning::{
4	MlModel, MlModelDb, MlModelId, MlModelIdAndName, MlModelListOptions,
5	error::{
6	MachineLearningError,
7	error::{Bb8MachineLearningError, PostgresMachineLearningError},
8	},
9	},
10	permissions::Permission,
11	util::postgres::PostgresErrorExt,
12	};
13	use async_trait::async_trait;
14	use geoengine_datatypes::{machine_learning::MlModelName, util::Identifier};
15	use snafu::ResultExt;
16	use tokio_postgres::{
17	Socket,
18	tls::{MakeTlsConnect, TlsConnect},
19	};
20
21	#[async_trait]
22	impl<Tls> MlModelDb for PostgresDb<Tls>
23	where
24	Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static + std::fmt::Debug,
25	<Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
26	<Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
27	<<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,
28	{
29	async fn list_models(
30	&self,
31	options: &MlModelListOptions,
32	) -> Result<Vec<MlModel>, MachineLearningError> {	1✔
33	let conn = self
34	.conn_pool
35	.get()
36	.await
37	.context(Bb8MachineLearningError)?;
38
39	let rows = conn
40	.query(
41	"
42	SELECT
43	m.id,
44	m.name,
45	m.display_name,
46	m.description,
47	m.upload,
48	m.metadata,
49	m.file_name
50	FROM
51	user_permitted_ml_models u JOIN ml_models m ON (u.ml_model_id = m.id)
52	WHERE
53	u.user_id = $1
54	ORDER BY
55	name
56	OFFSET
57	$2
58	LIMIT
59	$3",
60	&[
61	&self.session.user.id,
62	&i64::from(options.offset),
63	&i64::from(options.limit),
64	],
65	)
66	.await
67	.context(PostgresMachineLearningError)?;
68
69	let models = rows
70	.into_iter()
71	.map(\|row\| MlModel {
72	name: row.get(1),	1✔
73	display_name: row.get(2),	1✔
74	description: row.get(3),	1✔
75	upload: row.get(4),	1✔
76	metadata: row.get(5),	1✔
77	file_name: row.get(6),	1✔
78	})	1✔
79	.collect();
80
81	Ok(models)
82	}	1✔
83
84	async fn load_model(&self, name: &MlModelName) -> Result<MlModel, MachineLearningError> {	1✔
85	let conn = self
86	.conn_pool
87	.get()
88	.await
89	.context(Bb8MachineLearningError)?;
90
91	let Some(row) = conn
92	.query_opt(
93	"SELECT
94	m.id,
95	m.name,
96	m.display_name,
97	m.description,
98	m.upload,
99	m.metadata,
100	m.file_name
101	FROM
102	user_permitted_ml_models u JOIN ml_models m ON (u.ml_model_id = m.id)
103	WHERE
104	u.user_id = $1 AND m.name = $2::\"MlModelName\"",
105	&[&self.session.user.id, name],
106	)
107	.await
108	.context(PostgresMachineLearningError)?
109	else {
110	return Err(MachineLearningError::ModelNotFound { name: name.clone() });
111	};
112
113	Ok(MlModel {
114	name: row.get(1),
115	display_name: row.get(2),
116	description: row.get(3),
117	upload: row.get(4),
118	metadata: row.get(5),
119	file_name: row.get(6),
120	})
121	}	1✔
122
123	async fn add_model(&self, model: MlModel) -> Result<MlModelIdAndName, MachineLearningError> {	3✔
124	self.check_ml_model_namespace(&model.name)?;
125
126	let mut conn = self
127	.conn_pool
128	.get()
129	.await
130	.context(Bb8MachineLearningError)?;
131
132	let tx = conn
133	.build_transaction()
134	.start()
135	.await
136	.context(PostgresMachineLearningError)?;
137
138	let id = MlModelId::new();
139
140	tx.query_one(
141	"INSERT INTO ml_models (
142	id,
143	name,
144	display_name,
145	description,
146	upload,
147	metadata,
148	file_name
149	) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING id;",
150	&[
151	&id,
152	&model.name,
153	&model.display_name,
154	&model.description,
155	&model.upload,
156	&model.metadata,
157	&model.file_name,
158	],
159	)
160	.await
UNCOV 161	.map_unique_violation("ml_models", "name", \|\| {	×
162	MachineLearningError::DuplicateMlModelName {	×
163	name: model.name.clone(),	×
164	}	×
165	})?;	×
166
167	let stmt = tx
168	.prepare(
169	"INSERT INTO permissions (role_id, permission, ml_model_id) VALUES ($1, $2, $3);",
170	)
171	.await
172	.context(PostgresMachineLearningError)?;
173
174	tx.execute(&stmt, &[&self.session.user.id, &Permission::Owner, &id])
175	.await
176	.context(PostgresMachineLearningError)?;
177
178	tx.commit().await.context(PostgresMachineLearningError)?;
179
180	Ok(MlModelIdAndName {
181	id,
182	name: model.name,
183	})
184	}	3✔
185
186	async fn resolve_model_name_to_id(
187	&self,
188	model_name: &MlModelName,
189	) -> Result<Option<MlModelId>, MachineLearningError> {	2✔
190	let conn = self
191	.conn_pool
192	.get()
193	.await
194	.context(Bb8MachineLearningError)?;
195
196	let stmt = conn
197	.prepare(
198	"SELECT id
199	FROM ml_models
200	WHERE name = $1::\"MlModelName\"",
201	)
202	.await?;
203
204	let row_option = conn.query_opt(&stmt, &[&model_name]).await?;
205
206	Ok(row_option.map(\|row\| row.get(0)))	2✔
207	}	2✔
208	}

geo-engine / geoengine / 18554766227

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous