admin/momentry_core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update: pipeline, search, clip, embedding fixes

Browse Source
This commit is contained in:
Accusys
2026-05-17 19:46:35 +08:00
parent eec2eea880
commit 3164a65554
36 changed files with 4313 additions and 4061 deletions
Download Patch File Download Diff File Expand all files Collapse all files

434
src/core/tmdb/probe.rs
View File

@@ -1,6 +1,5 @@
use anyhow::{Context, Result};
use serde::Deserialize;
use std::collections::HashMap;
use tracing::{info, warn};
use crate::core::config;
@@ -8,11 +7,11 @@ use crate::core::db::PostgresDb;
#[derive(Debug, Deserialize)]
struct TmdbSearchResult {
results: Vec<TmdbMovie>,
results: Vec<TmdbApiMovie>,
}
#[derive(Debug, Deserialize)]
struct TmdbMovie {
struct TmdbApiMovie {
id: u64,
title: String,
release_date: Option<String>,
@@ -22,11 +21,11 @@ struct TmdbMovie {
#[derive(Debug, Deserialize)]
struct TmdbCredits {
cast: Vec<TmdbCastMember>,
cast: Vec<TmdbApiCastMember>,
}
#[derive(Debug, Deserialize)]
struct TmdbCastMember {
struct TmdbApiCastMember {
id: u64,
name: String,
character: String,
@@ -54,6 +53,271 @@ fn extract_movie_name(filename: &str) -> Option<String> {
Some(cleaned)
}
pub async fn probe_from_cache(
db: &PostgresDb,
file_uuid: &str,
) -> Result<TmdbProbeResult> {
let cache = crate::core::tmdb::cache::read_tmdb_cache(file_uuid)?;
if cache.identities.is_empty() && !cache.cast.is_empty() {
return create_identities_from_data(db, file_uuid, &cache.movie, &cache.cast).await;
}
upsert_identities_from_disk(db, &cache, file_uuid).await
}
async fn upsert_identities_from_disk(
db: &PostgresDb,
cache: &crate::core::tmdb::cache::TmdbCache,
file_uuid: &str,
) -> Result<TmdbProbeResult> {
info!(
"[TMDB] Upserting identities from disk for: {} (TMDB id={})",
cache.movie.title, cache.movie.tmdb_id
);
let mut identities_created = 0usize;
for entry in &cache.identities {
let path = crate::core::identity::storage::identity_file_path(&entry.identity_uuid);
if !path.exists() {
warn!("[TMDB] Identity file not found on disk: {}", path.display());
continue;
}
match std::fs::read_to_string(&path) {
Ok(content) => {
match serde_json::from_str::<crate::core::identity::storage::IdentityFile>(&content) {
Ok(identity_file) => {
let identities_table = crate::core::db::schema::table_name("identities");
let result = sqlx::query(&format!(
"INSERT INTO {} (uuid, name, identity_type, source, status, tmdb_id, tmdb_profile, metadata) \
VALUES ($1::uuid, $2, 'people', 'tmdb', 'confirmed', $3, $4, $5::jsonb) \
ON CONFLICT (name) DO UPDATE SET \
uuid = COALESCE({}.uuid, $1::uuid), \
tmdb_id = COALESCE(EXCLUDED.tmdb_id, {}.tmdb_id), \
tmdb_profile = COALESCE(EXCLUDED.tmdb_profile, {}.tmdb_profile), \
metadata = {}.metadata || $5::jsonb",
identities_table, identities_table, identities_table, identities_table, identities_table
))
.bind(&identity_file.identity_uuid)
.bind(&identity_file.name)
.bind(identity_file.tmdb_id)
.bind(&identity_file.tmdb_profile)
.bind(&identity_file.metadata)
.execute(db.pool())
.await;
match result {
Ok(_) => {
info!("[TMDB] Upserted identity: {} (uuid={})", identity_file.name, identity_file.identity_uuid);
identities_created += 1;
}
Err(e) => {
warn!("[TMDB] Failed to upsert identity '{}': {}", identity_file.name, e);
}
}
}
Err(e) => {
warn!("[TMDB] Failed to parse identity file {}: {}", path.display(), e);
}
}
}
Err(e) => {
warn!("[TMDB] Failed to read identity file {}: {}", path.display(), e);
}
}
}
drop_identities_cache(db, file_uuid, &cache.movie, identities_created).await;
Ok(TmdbProbeResult {
tmdb_id: cache.movie.tmdb_id,
title: cache.movie.title.clone(),
cast_count: cache.cast_count,
identities_created,
})
}
async fn drop_identities_cache(
db: &PostgresDb,
file_uuid: &str,
movie: &crate::core::tmdb::cache::TmdbMovie,
identities_created: usize,
) {
let videos_table = crate::core::db::schema::table_name("videos");
let tmdb_label = "tmdb";
let _ = sqlx::query(&format!(
"UPDATE {} SET birth_registration = \
jsonb_set(COALESCE(birth_registration, '{{}}'::jsonb), '{{{}}}'::text[], $1::jsonb) \
WHERE file_uuid = $2",
videos_table, tmdb_label
))
.bind(serde_json::json!({
"movie_id": movie.tmdb_id,
"movie_title": movie.title,
"release_date": movie.release_date,
"poster": movie.poster_path,
"cast_count": movie.tmdb_id,
"identities_created": identities_created,
}))
.bind(file_uuid)
.execute(db.pool())
.await
.ok();
}
pub async fn create_identities_from_data(
db: &PostgresDb,
file_uuid: &str,
movie: &crate::core::tmdb::cache::TmdbMovie,
cast: &[crate::core::tmdb::cache::TmdbCastMember],
) -> Result<TmdbProbeResult> {
info!(
"[TMDB] Creating identities for: {} (TMDB id={})",
movie.title, movie.tmdb_id
);
let identities_table = crate::core::db::schema::table_name("identities");
let mut identities_created = 0usize;
for member in cast.iter() {
if member.name.trim().is_empty() {
continue;
}
let profile_url = member.profile_path.as_ref()
.map(|p| format!("https://image.tmdb.org/t/p/w185{}", p));
let metadata = serde_json::json!({
"tmdb_character": member.character,
"tmdb_cast_order": member.order,
"tmdb_movie_id": movie.tmdb_id,
"tmdb_movie_title": movie.title,
"tmdb_biography": member.biography,
"tmdb_birthday": member.birthday,
"tmdb_place_of_birth": member.place_of_birth,
"tmdb_aliases": member.also_known_as,
"tmdb_imdb_id": member.imdb_id,
"tmdb_department": member.known_for_department,
"tmdb_popularity": member.popularity,
"tmdb_deathday": member.deathday,
"tmdb_gender": member.gender,
"tmdb_homepage": member.homepage,
});
let result = sqlx::query_as::<_, (uuid::Uuid,)>(&format!(
"INSERT INTO {} (name, identity_type, source, status, tmdb_id, tmdb_profile, metadata) \
VALUES ($1, 'people', 'tmdb', 'confirmed', $2, $3, $4::jsonb) \
ON CONFLICT (name) DO UPDATE SET \
tmdb_id = COALESCE(EXCLUDED.tmdb_id, {}.tmdb_id), \
tmdb_profile = COALESCE(EXCLUDED.tmdb_profile, {}.tmdb_profile), \
metadata = {}.metadata || $4::jsonb \
RETURNING uuid",
identities_table, identities_table, identities_table, identities_table
))
.bind(&member.name)
.bind(member.id as i64)
.bind(&profile_url)
.bind(&metadata)
.fetch_optional(db.pool())
.await;
match result {
Ok(Some((identity_uuid,))) => {
let uuid_str = identity_uuid.to_string().replace('-', "");
info!(
"[TMDB] Created/updated identity: {} as {} (uuid={})",
member.name, member.character, uuid_str
);
identities_created += 1;
if let Err(e) = crate::core::identity::storage::save_identity_file(db, &uuid_str).await {
warn!("[TMDB] Failed to save identity file for {}: {}", member.name, e);
}
// Download and save TMDb profile image locally
if let Some(url) = &profile_url {
let dir = crate::core::identity::storage::identity_dir(&uuid_str);
std::fs::create_dir_all(&dir).ok();
let img_path = dir.join("profile.jpg");
if !img_path.exists() {
if let Ok(resp) = reqwest::get(url).await {
if let Ok(bytes) = resp.bytes().await {
std::fs::write(&img_path, &bytes).ok();
}
}
}
}
}
Ok(None) => {
warn!("[TMDB] INSERT returned no uuid for: {}", member.name);
}
Err(e) => {
warn!("[TMDB] Failed to create identity '{}': {}", member.name, e);
}
}
}
// Step 4: Trigger background embedding extraction
if identities_created > 0 {
let scripts_dir = std::env::var("MOMENTRY_SCRIPTS_DIR")
.unwrap_or_else(|_| "/Users/accusys/momentry_core_0.1/scripts".to_string());
let python_path = std::env::var("MOMENTRY_PYTHON_PATH")
.unwrap_or_else(|_| "/opt/homebrew/bin/python3.11".to_string());
let schema = crate::core::config::DATABASE_SCHEMA.clone();
tokio::spawn(async move {
let output = tokio::process::Command::new(&python_path)
.arg(&format!("{}/tmdb_embed_extractor.py", scripts_dir))
.arg("--schema")
.arg(&schema)
.output()
.await;
match output {
Ok(o) => {
if !o.status.success() {
let stderr = String::from_utf8_lossy(&o.stderr);
warn!("[TMDB] Embed extraction script failed: {}", stderr);
} else {
info!("[TMDB] Background face embedding extraction complete");
}
}
Err(e) => warn!("[TMDB] Failed to run embed extraction script: {}", e),
}
});
}
// Step 5: Store tmdb_id on the video record for later use
let videos_table = crate::core::db::schema::table_name("videos");
let tmdb_label = "tmdb";
let _ = sqlx::query(&format!(
"UPDATE {} SET birth_registration = \
jsonb_set(COALESCE(birth_registration, '{{}}'::jsonb), '{{{}}}'::text[], $1::jsonb) \
WHERE file_uuid = $2",
videos_table, tmdb_label
))
.bind(serde_json::json!({
"movie_id": movie.tmdb_id,
"movie_title": movie.title,
"release_date": movie.release_date,
"poster": movie.poster_path,
"cast_count": cast.len(),
"identities_created": identities_created,
}))
.bind(file_uuid)
.execute(db.pool())
.await
.ok();
info!(
"[TMDB] Probe complete: {} cast members, {} identities created/updated",
cast.len(),
identities_created
);
Ok(TmdbProbeResult {
tmdb_id: movie.tmdb_id,
title: movie.title.clone(),
cast_count: cast.len(),
identities_created,
})
}
pub async fn probe_movie(
db: &PostgresDb,
filename: &str,
@@ -120,119 +384,57 @@ pub async fn probe_movie(
.await
.context("Failed to parse TMDb credits response")?;
// Step 3: Create identities for top cast
let identities_table = crate::core::db::schema::table_name("identities");
let mut identities_created = 0usize;
for member in credits.cast.iter().take(20) {
if member.name.trim().is_empty() {
continue;
}
let profile_url = member
.profile_path
.as_ref()
.map(|p| format!("https://image.tmdb.org/t/p/w185{}", p));
let result = sqlx::query(&format!(
"INSERT INTO {} (name, identity_type, source, status, tmdb_id, tmdb_profile, metadata) \
VALUES ($1, 'people', 'tmdb', 'confirmed', $2, $3, \
jsonb_build_object('tmdb_character', $4, 'tmdb_cast_order', $5, 'tmdb_movie_id', $6, 'tmdb_movie_title', $7)) \
ON CONFLICT (name) DO UPDATE SET \
tmdb_id = COALESCE(EXCLUDED.tmdb_id, {}.tmdb_id), \
tmdb_profile = COALESCE(EXCLUDED.tmdb_profile, {}.tmdb_profile), \
metadata = {}.metadata || jsonb_build_object('tmdb_movie_id', $6, 'tmdb_movie_title', $7) \
RETURNING id",
identities_table, identities_table, identities_table, identities_table
))
.bind(&member.name)
.bind(member.id as i64)
.bind(&profile_url)
.bind(&member.character)
.bind(member.order as i32)
.bind(movie.id as i64)
.bind(&movie.title)
.execute(db.pool())
.await;
match result {
Ok(_) => {
info!(
"[TMDB] Created/updated identity: {} as {}",
member.name, member.character
);
identities_created += 1;
}
Err(e) => {
warn!("[TMDB] Failed to create identity '{}': {}", member.name, e);
}
}
}
// Step 4: Trigger background embedding extraction
if identities_created > 0 {
let scripts_dir = std::env::var("MOMENTRY_SCRIPTS_DIR")
.unwrap_or_else(|_| "/Users/accusys/momentry_core_0.1/scripts".to_string());
let python_path = std::env::var("MOMENTRY_PYTHON_PATH")
.unwrap_or_else(|_| "/opt/homebrew/bin/python3.11".to_string());
let schema = crate::core::config::DATABASE_SCHEMA.clone();
tokio::spawn(async move {
let output = tokio::process::Command::new(&python_path)
.arg(&format!("{}/tmdb_embed_extractor.py", scripts_dir))
.arg("--schema")
.arg(&schema)
.output()
.await;
match output {
Ok(o) => {
if !o.status.success() {
let stderr = String::from_utf8_lossy(&o.stderr);
warn!("[TMDB] Embed extraction script failed: {}", stderr);
} else {
info!("[TMDB] Background face embedding extraction complete");
}
}
Err(e) => warn!("[TMDB] Failed to run embed extraction script: {}", e),
}
});
}
// Step 5: Store tmdb_id on the video record for later use
let videos_table = crate::core::db::schema::table_name("videos");
let tmdb_label = "tmdb";
let _ = sqlx::query(&format!(
"UPDATE {} SET birth_registration = \
jsonb_set(COALESCE(birth_registration, '{{}}'::jsonb), '{{{}}}', $1::jsonb) \
WHERE file_uuid = $2",
videos_table, tmdb_label
))
.bind(serde_json::json!({
"movie_id": movie.id,
"movie_title": movie.title,
"release_date": movie.release_date,
"poster": movie.poster_path,
"cast_count": credits.cast.len(),
"identities_created": identities_created,
}))
.bind(file_uuid)
.execute(db.pool())
.await
.ok();
info!(
"[TMDB] Probe complete: {} cast members, {} identities created/updated",
credits.cast.len(),
identities_created
);
Ok(Some(TmdbProbeResult {
// Step 3: Convert API types to cache types and use shared logic
use crate::core::tmdb::cache;
let cache_movie = cache::TmdbMovie {
tmdb_id: movie.id,
title: movie.title,
title: movie.title.clone(),
release_date: movie.release_date.clone(),
overview: movie.overview.clone(),
poster_path: movie.poster_path.clone(),
};
let cache_cast: Vec<cache::TmdbCastMember> = credits.cast.iter().map(|m| {
cache::TmdbCastMember {
id: m.id,
name: m.name.clone(),
character: m.character.clone(),
profile_path: m.profile_path.clone(),
order: m.order,
biography: None,
birthday: None,
place_of_birth: None,
also_known_as: vec![],
imdb_id: None,
known_for_department: None,
popularity: None,
deathday: None,
gender: None,
homepage: None,
}
}).collect();
// Write TMDb cache so probe_from_cache can be used next time
let cache_obj = cache::TmdbCache {
file_uuid: file_uuid.to_string(),
fetched_at: chrono::Utc::now().to_rfc3339(),
source: "probe_movie".to_string(),
movie: cache_movie.clone(),
cast: cache_cast.clone(),
cast_count: credits.cast.len(),
identities_created,
}))
identities_created: 0,
identities: vec![],
};
cache::write_tmdb_cache(&cache_obj).ok();
let result = create_identities_from_data(db, file_uuid, &cache_movie, &cache_cast).await?;
// Update cache with actual identities_created count
if let Ok(mut cache_obj) = cache::read_tmdb_cache(file_uuid) {
cache_obj.identities_created = result.identities_created;
cache::write_tmdb_cache(&cache_obj).ok();
}
Ok(Some(result))
}
fn urlencoding(s: &str) -> String {