chore(deps): update machine-learning

machine-learning/Dockerfile

@@ -1,8 +1,8 @@
 ARG DEVICE=cpu
 
-FROM python:3.11-bookworm@sha256:970c99f886b839fc8829289040c1845dadaf2cae46b37acc7710333158ec29b4 AS builder-cpu
+FROM python:3.11-bookworm@sha256:121d86b6d08752968a7dddbc708849e5f3a839bbff47f32212b46d2a1d842bab AS builder-cpu
 
-FROM python:3.13-slim-trixie@sha256:d168b8d9eb761f4d3fe305ebd04aeb7e7f2de0297cec5fb2f8f6403244621664 AS builder-openvino
+FROM python:3.13-slim-trixie@sha256:b04b5d7233d2ad9c379e22ea8927cd1378cd15c60d4ef876c065b25ea8fb3bf3 AS builder-openvino
 
 FROM builder-cpu AS builder-cuda
 
@@ -39,12 +39,12 @@ RUN --mount=type=cache,target=/root/.cache/uv \
     --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
     uv sync --frozen --extra ${DEVICE} --no-dev --no-editable --no-install-project --compile-bytecode --no-progress --active --link-mode copy
 
-FROM python:3.11-slim-bookworm@sha256:9c6f90801e6b68e772b7c0ca74260cbf7af9f320acec894e26fccdaccfbe3b47 AS prod-cpu
+FROM python:3.11-slim-bookworm@sha256:8dca233de9f3d9bb410665f00a4da6dd06f331083137e0e98ccf227236fcc438 AS prod-cpu
 
 ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2 \
     MACHINE_LEARNING_MODEL_ARENA=false
 
-FROM python:3.13-slim-trixie@sha256:d168b8d9eb761f4d3fe305ebd04aeb7e7f2de0297cec5fb2f8f6403244621664 AS prod-openvino
+FROM python:3.13-slim-trixie@sha256:b04b5d7233d2ad9c379e22ea8927cd1378cd15c60d4ef876c065b25ea8fb3bf3 AS prod-openvino
 
 RUN apt-get update && \
     apt-get install --no-install-recommends -yqq ocl-icd-libopencl1 wget && \

server/src/dtos/search.dto.ts

@@ -3,14 +3,7 @@ import { Place } from 'src/database';
 import { HistoryBuilder } from 'src/decorators';
 import { AlbumResponseSchema } from 'src/dtos/album.dto';
 import { AssetResponseSchema } from 'src/dtos/asset-response.dto';
-import {
-  AssetOrder,
-  AssetOrderSchema,
-  AssetTypeSchema,
-  AssetVisibilitySchema,
-  SearchOrderField,
-  SearchOrderFieldSchema,
-} from 'src/enum';
+import { AssetOrder, AssetOrderSchema, AssetTypeSchema, AssetVisibilitySchema } from 'src/enum';
 import { emptyStringToNull, isoDatetimeToDate, stringToBool } from 'src/validation';
 import z from 'zod';
 
@@ -148,229 +141,6 @@ const SearchSuggestionRequestSchema = z
   })
   .meta({ id: 'SearchSuggestionRequestDto' });
 
-// v3 SearchFilter DTOs — new shape introduced alongside the legacy flat DTOs above.
-
-const atLeastOneKey = <T extends z.ZodObject>(schema: T, allowed: (keyof T['shape'] & string)[]) =>
-  schema.refine((value) => Object.values(value).some((v) => v !== undefined), {
-    message: `At least one of the following keys is required: ${allowed.join(', ')}`,
-  });
-
-const IdFilterSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.uuidv4().optional(),
-    ne: z.uuidv4().optional(),
-  }),
-  ['eq', 'ne'],
-).meta({ id: 'IdFilter' });
-
-const IdFilterNullableSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.uuidv4().nullable().optional(),
-    ne: z.uuidv4().nullable().optional(),
-  }),
-  ['eq', 'ne'],
-).meta({ id: 'IdFilterNullable' });
-
-const IdsFilterSchema = atLeastOneKey(
-  z.strictObject({
-    any: z.array(z.uuidv4()).min(1).optional(),
-    all: z.array(z.uuidv4()).min(1).optional(),
-    none: z.array(z.uuidv4()).min(1).optional(),
-  }),
-  ['any', 'all', 'none'],
-).meta({ id: 'IdsFilter' });
-
-const StringFilterSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.string().optional(),
-    ne: z.string().optional(),
-    in: z.array(z.string()).min(1).optional(),
-    notIn: z.array(z.string()).min(1).optional(),
-  }),
-  ['eq', 'ne', 'in', 'notIn'],
-).meta({ id: 'StringFilter' });
-
-const StringFilterNullableSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.string().nullable().optional(),
-    ne: z.string().nullable().optional(),
-    in: z.array(z.string()).min(1).optional(),
-    notIn: z.array(z.string()).min(1).optional(),
-  }),
-  ['eq', 'ne', 'in', 'notIn'],
-).meta({ id: 'StringFilterNullable' });
-
-const StringPatternFilterSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.string().nullable().optional(),
-    ne: z.string().nullable().optional(),
-    in: z.array(z.string()).min(1).optional(),
-    notIn: z.array(z.string()).min(1).optional(),
-    like: z.string().min(1).optional(),
-    notLike: z.string().min(1).optional(),
-    startsWith: z.string().min(1).optional(),
-    endsWith: z.string().min(1).optional(),
-  }),
-  ['eq', 'ne', 'in', 'notIn', 'like', 'notLike', 'startsWith', 'endsWith'],
-).meta({ id: 'StringPatternFilter' });
-
-const NumberFilterSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.number().optional(),
-    lt: z.number().optional(),
-    lte: z.number().optional(),
-    gt: z.number().optional(),
-    gte: z.number().optional(),
-    in: z.array(z.number()).min(1).optional(),
-    notIn: z.array(z.number()).min(1).optional(),
-  }),
-  ['eq', 'lt', 'lte', 'gt', 'gte', 'in', 'notIn'],
-).meta({ id: 'NumberFilter' });
-
-const NumberFilterNullableSchema = atLeastOneKey(
-  z.strictObject({
-    eq: z.number().nullable().optional(),
-    ne: z.number().nullable().optional(),
-    lt: z.number().optional(),
-    lte: z.number().optional(),
-    gt: z.number().optional(),
-    gte: z.number().optional(),
-    in: z.array(z.number()).min(1).optional(),
-    notIn: z.array(z.number()).min(1).optional(),
-  }),
-  ['eq', 'ne', 'lt', 'lte', 'gt', 'gte', 'in', 'notIn'],
-).meta({ id: 'NumberFilterNullable' });
-
-const DateFilterSchema = atLeastOneKey(
-  z.strictObject({
-    eq: isoDatetimeToDate.optional(),
-    ne: isoDatetimeToDate.optional(),
-    gt: isoDatetimeToDate.optional(),
-    gte: isoDatetimeToDate.optional(),
-    lt: isoDatetimeToDate.optional(),
-    lte: isoDatetimeToDate.optional(),
-  }),
-  ['eq', 'ne', 'gt', 'gte', 'lt', 'lte'],
-).meta({ id: 'DateFilter' });
-
-const DateFilterNullableSchema = atLeastOneKey(
-  z.strictObject({
-    eq: isoDatetimeToDate.nullable().optional(),
-    ne: isoDatetimeToDate.nullable().optional(),
-    gt: isoDatetimeToDate.optional(),
-    gte: isoDatetimeToDate.optional(),
-    lt: isoDatetimeToDate.optional(),
-    lte: isoDatetimeToDate.optional(),
-  }),
-  ['eq', 'ne', 'gt', 'gte', 'lt', 'lte'],
-).meta({ id: 'DateFilterNullable' });
-
-const BoolFilterSchema = z.strictObject({ eq: z.boolean() }).meta({ id: 'BoolFilter' });
-
-const enumFilterSchema = <T extends z.core.util.EnumLike>(values: z.ZodEnum<T>, id: string) =>
-  atLeastOneKey(
-    z.strictObject({
-      eq: values.optional(),
-      ne: values.optional(),
-      in: z.array(values).min(1).optional(),
-      notIn: z.array(values).min(1).optional(),
-    }),
-    ['eq', 'ne', 'in', 'notIn'],
-  ).meta({ id });
-
-const EnumFilterAssetTypeSchema = enumFilterSchema(AssetTypeSchema, 'EnumFilterAssetType');
-const EnumFilterAssetVisibilitySchema = enumFilterSchema(AssetVisibilitySchema, 'EnumFilterAssetVisibility');
-
-const StringSimilarityFilterSchema = z
-  .strictObject({
-    matches: z.string().min(1),
-  })
-  .meta({ id: 'StringSimilarityFilter' });
-
-const SearchOrderSchema = z
-  .strictObject({
-    field: SearchOrderFieldSchema.default(SearchOrderField.FileCreatedAt),
-    direction: AssetOrderSchema.default(AssetOrder.Desc),
-  })
-  .meta({ id: 'SearchOrder' });
-
-const SearchFilterBranchSchema = z
-  .strictObject({
-    id: IdFilterSchema.optional(),
-    libraryId: IdFilterNullableSchema.optional(),
-    type: EnumFilterAssetTypeSchema.optional(),
-    visibility: EnumFilterAssetVisibilitySchema.optional(),
-    isFavorite: BoolFilterSchema.optional(),
-    isMotion: BoolFilterSchema.optional(),
-    isOffline: BoolFilterSchema.optional(),
-    isEncoded: BoolFilterSchema.optional(),
-    hasAlbums: BoolFilterSchema.optional(),
-    hasPeople: BoolFilterSchema.optional(),
-    hasTags: BoolFilterSchema.optional(),
-    city: StringFilterNullableSchema.optional(),
-    state: StringFilterNullableSchema.optional(),
-    country: StringFilterNullableSchema.optional(),
-    make: StringFilterNullableSchema.optional(),
-    model: StringFilterNullableSchema.optional(),
-    lensModel: StringFilterNullableSchema.optional(),
-    description: StringPatternFilterSchema.optional(),
-    originalFileName: StringPatternFilterSchema.optional(),
-    originalPath: StringPatternFilterSchema.optional(),
-    ocr: StringSimilarityFilterSchema.optional(),
-    rating: NumberFilterNullableSchema.optional(),
-    fileSizeInBytes: NumberFilterSchema.optional(),
-    takenAt: DateFilterSchema.optional(),
-    createdAt: DateFilterSchema.optional(),
-    updatedAt: DateFilterSchema.optional(),
-    trashedAt: DateFilterNullableSchema.optional(),
-    personIds: IdsFilterSchema.optional(),
-    tagIds: IdsFilterSchema.optional(),
-    albumIds: IdsFilterSchema.optional(),
-    checksum: StringFilterSchema.optional(),
-    encodedVideoPath: StringFilterSchema.optional(),
-  })
-  .meta({ id: 'SearchFilterBranch' });
-
-const SearchFilterSchema = SearchFilterBranchSchema.extend({
-  or: z.array(SearchFilterBranchSchema).min(1).optional(),
-}).meta({ id: 'SearchFilter' });
-
-export {
-  BoolFilterSchema,
-  DateFilterNullableSchema,
-  DateFilterSchema,
-  EnumFilterAssetTypeSchema,
-  EnumFilterAssetVisibilitySchema,
-  IdFilterNullableSchema,
-  IdFilterSchema,
-  IdsFilterSchema,
-  NumberFilterNullableSchema,
-  NumberFilterSchema,
-  SearchFilterBranchSchema,
-  SearchFilterSchema,
-  SearchOrderSchema,
-  StringFilterNullableSchema,
-  StringFilterSchema,
-  StringPatternFilterSchema,
-  StringSimilarityFilterSchema,
-};
-
-export type IdFilter = z.infer<typeof IdFilterSchema>;
-export type IdFilterNullable = z.infer<typeof IdFilterNullableSchema>;
-export type IdsFilter = z.infer<typeof IdsFilterSchema>;
-export type StringFilter = z.infer<typeof StringFilterSchema>;
-export type StringFilterNullable = z.infer<typeof StringFilterNullableSchema>;
-export type StringPatternFilter = z.infer<typeof StringPatternFilterSchema>;
-export type NumberFilter = z.infer<typeof NumberFilterSchema>;
-export type NumberFilterNullable = z.infer<typeof NumberFilterNullableSchema>;
-export type DateFilter = z.infer<typeof DateFilterSchema>;
-export type DateFilterNullable = z.infer<typeof DateFilterNullableSchema>;
-export type BoolFilter = z.infer<typeof BoolFilterSchema>;
-export type StringSimilarityFilter = z.infer<typeof StringSimilarityFilterSchema>;
-export type SearchOrder = z.infer<typeof SearchOrderSchema>;
-export type SearchFilter = z.infer<typeof SearchFilterSchema>;
-export type SearchFilterBranch = z.infer<typeof SearchFilterBranchSchema>;
-
 export class RandomSearchDto extends createZodDto(RandomSearchSchema) {}
 export class LargeAssetSearchDto extends createZodDto(LargeAssetSearchSchema) {}
 export class MetadataSearchDto extends createZodDto(MetadataSearchSchema) {}

server/src/enum.ts

@@ -1180,12 +1180,3 @@ export enum WorkflowType {
 }
 
 export const WorkflowTypeSchema = z.enum(WorkflowType).describe('Workflow type').meta({ id: 'WorkflowType' });
-
-export enum SearchOrderField {
-  FileCreatedAt = 'fileCreatedAt',
-  LocalDateTime = 'localDateTime',
-  FileSizeInBytes = 'fileSizeInBytes',
-  Rating = 'rating',
-}
-
-export const SearchOrderFieldSchema = z.enum(SearchOrderField).meta({ id: 'SearchOrderField' });