From 40011a62dae9da8deda71e9f8daf39665a8b7958 Mon Sep 17 00:00:00 2001 From: DebaucheryLibrarian Date: Tue, 22 Oct 2024 03:09:17 +0200 Subject: [PATCH] Added actors module to repo. --- actors.mjs | 297 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 297 insertions(+) create mode 100644 actors.mjs diff --git a/actors.mjs b/actors.mjs new file mode 100644 index 0000000..b291d22 --- /dev/null +++ b/actors.mjs @@ -0,0 +1,297 @@ +function getMostFrequent(items, { slugify }) { + const { mostFrequent } = items.reduce((acc, item) => { + if (item === undefined || item === null) { + return acc; + } + + const slug = slugify(item); + + acc.counts[slug] = (acc.counts[slug] || 0) + 1; + + if (!acc.mostFrequent || acc.counts[slug] > acc.counts[slugify(acc.mostFrequent)]) { + acc.mostFrequent = item; + } + + return acc; + }, { + counts: {}, + mostFrequent: null, + }); + + return mostFrequent; +} + +function getMostFrequentDate(dates, context) { + const year = getMostFrequent(dates.map((dateX) => dateX.getFullYear()), context); + const month = getMostFrequent(dates.map((dateX) => dateX.getMonth()), context); + const date = getMostFrequent(dates.map((dateX) => dateX.getDate()), context); + + if (year === null || month === null || date === null) { + return null; + } + + return context.moment({ year, month, date }).toDate(); +} + +function getHighest(items) { + return items.reduce((prevItem, item) => (item > prevItem ? item : prevItem), null); +} + +function getLongest(items) { + return items.sort((itemA, itemB) => itemB.length - itemA.length)[0] || null; +} + +function getAverage(items) { + return Math.round(items.reduce((acc, item) => acc + item, 0) / items.length) || null; +} + +function curateProfileEntry(profile) { + if (!profile.id) { + return null; + } + + const curatedProfileEntry = { + ...(profile.update !== false && { id: profile.update }), + actor_id: profile.id, + entity_id: profile.entity?.id || null, + date_of_birth: profile.dateOfBirth, + date_of_death: profile.dateOfDeath, + age: profile.age, + url: profile.url, + gender: profile.gender, + orientation: profile.orientation, + ethnicity: profile.ethnicity, + description: profile.description, + description_hash: profile.descriptionHash, + birth_city: profile.placeOfBirth?.city || null, + birth_state: profile.placeOfBirth?.state || null, + birth_country_alpha2: profile.placeOfBirth?.country || null, + residence_city: profile.placeOfResidence?.city || null, + residence_state: profile.placeOfResidence?.state || null, + residence_country_alpha2: profile.placeOfResidence?.country || null, + cup: profile.cup, + bust: profile.bust, + waist: profile.waist, + leg: profile.leg, + thigh: profile.thigh, + foot: profile.foot, + hip: profile.hip, + penis_length: profile.penisLength, + penis_girth: profile.penisGirth, + circumcised: profile.circumcised, + natural_boobs: profile.naturalBoobs, + boobs_volume: profile.boobsVolume, + boobs_implant: profile.boobsImplant, + boobs_placement: profile.boobsPlacement, + boobs_surgeon: profile.boobsSurgeon, + natural_butt: profile.naturalButt, + butt_volume: profile.buttVolume, + butt_implant: profile.buttImplant, + natural_lips: profile.naturalLips, + lips_volume: profile.lipsVolume, + height: profile.height, + weight: profile.weight, + shoe_size: profile.shoeSize, + hair_color: profile.hairColor, + hair_type: profile.hairType, + eyes: profile.eyes, + has_tattoos: profile.hasTattoos, + has_piercings: profile.hasPiercings, + piercings: profile.piercings, + tattoos: profile.tattoos, + blood_type: profile.bloodType, + avatar_media_id: profile.avatarMediaId || null, + }; + + return curatedProfileEntry; +} + +async function fetchProfiles(actorIdsOrNames, { knex }) { + return knex('actors_profiles') + .select(knex.raw('actors_profiles.*, actors.name, row_to_json(media) as avatar')) + .leftJoin('actors', 'actors.id', 'actors_profiles.actor_id') + .modify((query) => { + if (actorIdsOrNames) { + query + .whereIn('actor_id', actorIdsOrNames.filter((idOrName) => typeof idOrName === 'number')) + .orWhere((builder) => { + builder + .whereIn('actors.name', actorIdsOrNames.filter((idOrName) => typeof idOrName === 'string')) + .whereNull('actors.entity_id'); + }); + } + }) + .leftJoin('media', 'actors_profiles.avatar_media_id', 'media.id'); +} + +function mergeMainProfile(profile, mainProfile) { + const preservedKeys = ['id']; + + const mergedProfile = Object.fromEntries(Object.entries(profile).map(([key, value]) => [key, mainProfile[key] === null || preservedKeys.includes(key) + ? value + : mainProfile[key]])); + + return mergedProfile; +} + +export async function interpolateProfiles(actorIdsOrNames, context) { + const profiles = await fetchProfiles(actorIdsOrNames, context); + + const profilesByActorId = profiles.reduce((acc, profile) => ({ + ...acc, + [profile.actor_id]: [ + ...(acc[profile.actor_id] || []), + profile, + ], + }), {}); + + context.logger.info(`Interpolating ${profiles.length} profiles from ${Object.keys(profilesByActorId).length} actors`); + + const interpolatedProfiles = Object.entries(profilesByActorId).map(([actorId, actorProfiles]) => { + // group values from each profile + const valuesByProperty = actorProfiles + .filter((profile) => profile.entity_id !== null) // main profile is interpolated separately at the end + .reduce((acc, profile) => Object + .entries(profile) + .reduce((profileAcc, [property, value]) => ({ + ...profileAcc, + [property]: [ + ...(acc[property] || []), + ...(value === null ? [] : Array.from({ length: profile.priority }, () => value)), // multiply by priority, increasing the odds of being the most frequent value + ], + }), { + // bundle location values so they can be assessed together, to ensure the most frequent city is in the most frequent state is in most frequent country + origin: [...acc.origin || [], { + ...(profile.birth_country_alpha2 && { country: profile.birth_country_alpha2 }), + ...(profile.birth_state && { state: profile.birth_state }), + ...(profile.birth_city && { city: profile.birth_city }), + }].filter((location) => Object.keys(location).length > 0), + residence: [...acc.residence || [], { + ...(profile.residence_country_alpha2 && { country: profile.residence_country_alpha2 }), + ...(profile.residence_state && { state: profile.residence_state }), + ...(profile.residence_city && { city: profile.residence_city }), + }].filter((location) => Object.keys(location).length > 0), + }), {}); + + const mostFrequentValues = [ + 'gender', + 'orientation', + 'ethnicity', + 'cup', + 'bust', + 'waist', + 'hip', + 'leg', + 'thigh', + 'foot', + 'shoe_size', + 'penis_length', + 'penis_girth', + 'circumcised', + 'natural_boobs', + 'boobs_volume', + 'boobs_implant', + 'boobs_placement', + 'boobs_surgeon', + 'natural_butt', + 'butt_volume', + 'butt_implant', + 'natural_lips', + 'lips_volume', + 'hair_color', + 'eyes', + 'has_tattoos', + 'has_piercings', + 'blood_type', + ].reduce((acc, property) => ({ + ...acc, + [property]: getMostFrequent(valuesByProperty[property], context), + }), {}); + + const profile = { + id: actorId, + ...mostFrequentValues, + }; + + profile.height = getMostFrequent(valuesByProperty.height.filter((height) => height > 50 && height < 300), context); // remove unlikely values + + profile.date_of_birth = getMostFrequentDate(valuesByProperty.date_of_birth, context); + profile.date_of_death = getMostFrequentDate(valuesByProperty.date_of_death, context); + profile.age = getHighest(valuesByProperty.age); + + // profile.natural_boobs = profile.gender === 'male' ? null : getMostFrequent(valuesByProperty.natural_boobs, context); + + // ensure most frequent country, city and state match up + profile.birth_country_alpha2 = getMostFrequent(valuesByProperty.origin.map((location) => location.country), context); + const remainingOriginCountries = valuesByProperty.origin.filter((location) => location.country === profile.birth_country_alpha2); + + profile.birth_state = getMostFrequent(remainingOriginCountries.map((location) => location.state), context); + const remainingOriginStates = remainingOriginCountries.filter((location) => !profile.birth_state || location.state === profile.birth_state); + + profile.birth_city = getMostFrequent(remainingOriginStates.map((location) => location.city), context); + + profile.residence_country_alpha2 = getMostFrequent(valuesByProperty.residence.map((location) => location.country), context); + const remainingResidenceCountries = valuesByProperty.residence.filter((location) => location.country === profile.residence_country_alpha2); + + profile.residence_state = getMostFrequent(remainingResidenceCountries.map((location) => location.state), context); + const remainingResidenceStates = remainingResidenceCountries.filter((location) => !profile.residence_state || location.state === profile.residence_state); + + profile.residence_city = getMostFrequent(remainingResidenceStates.map((location) => location.city), context); + + profile.weight = getAverage(valuesByProperty.weight); + + profile.tattoos = getLongest(valuesByProperty.tattoos); + profile.piercings = getLongest(valuesByProperty.piercings); + + profile.avatar_media_id = actorProfiles + .map((actorProfile) => actorProfile.avatar) + .filter((avatar) => avatar && (avatar.entropy === null || avatar.entropy > 5.5)) + .sort((avatarA, avatarB) => avatarB.height - avatarA.height)[0]?.id || null; + + if (!profile.avatar_media_id) { + // try to settle for low quality avatar + profile.avatar_media_id = actorProfiles + .map((actorProfile) => actorProfile.avatar) + .filter((avatar) => avatar) + .sort((avatarA, avatarB) => avatarB.height - avatarA.height)[0]?.id || null; + } + + const mainProfile = actorProfiles.find((actorProfile) => actorProfile.entity_id === null); + + return mergeMainProfile(profile, mainProfile); + }); + + const transaction = await context.knex.transaction(); + + // clear existing interpolated data + const emptyProfile = Object + .keys(context.omit(curateProfileEntry({ id: 1 }), ['id', 'actor_id', 'entity_id', 'url', 'description_hash'])) + .reduce((acc, key) => ({ ...acc, [key]: null }), {}); + + await context.knex('actors') + .modify((modifyBuilder) => { + if (actorIdsOrNames) { + modifyBuilder + .whereIn('id', actorIdsOrNames.filter((idOrName) => typeof idOrName === 'number')) + .orWhere((whereBuilder) => { + whereBuilder + .whereIn('name', actorIdsOrNames.filter((idOrName) => typeof idOrName === 'string')) + .whereNull('entity_id'); + }); + } + }) + .update(emptyProfile) + .transacting(transaction); + + // insert new interpolated data + const queries = interpolatedProfiles.map(async (profile) => context.knex('actors') + .where('id', profile.id) + .update(profile) + .transacting(transaction)); + + await Promise.all(queries) + .then(transaction.commit) + .catch(transaction.rollback); + + await context.knex.schema.refreshMaterializedView('actors_meta'); +}