@anonympins/fingerprint 0.2.0 → 0.2.2

package/problem-manager.js

@@ -0,0 +1,247 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { Optimization } from './library.js';
+
+/**
+ * @namespace ProblemInitializers
+ * @description Fonctions pour générer dynamiquement les données d'un problème.
+ */
+const ProblemInitializers = {
+    /**
+     * Génère un ensemble de points aléatoires pour un problème de TSP.
+     * @param {object} params - Les paramètres de génération.
+     * @param {number} params.count - Le nombre de points à générer.
+     * @param {{x: number, y: number}} [params.bounds={x: 1000, y: 1000}] - Les limites spatiales.
+     * @returns {Array<{x: number, y: number}>}
+     */
+    'generate:randomPoints': (params) => {
+        const { count, bounds = { x: 1000, y: 1000 } } = params;
+        if (isNaN(count)) return [];
+        return Array.from({ length: count }, () => ({ x: Math.random() * bounds.x, y: Math.random() * bounds.y }));
+    },
+
+    /**
+     * Génère un ensemble d'actifs financiers aléatoires pour un problème de portefeuille.
+     * @param {object} params - Les paramètres de génération.
+     * @param {number} params.count - Le nombre d'actifs à générer.
+     * @returns {Array<{expectedReturn: number, volatility: number}>}
+     */
+    'generate:randomAssets': (params) => {
+        const { count } = params;
+        if (isNaN(count)) return [];
+        return Array.from({ length: count }, () => ({
+            expectedReturn: Math.random() * 0.2,
+            volatility: 0.1 + Math.random() * 0.3
+        }));
+    },
+
+    /**
+     * Crée une fonction qui génère des arguments pour chaque worker de `runMultipleParallel`.
+     * Permet de faire varier les paramètres (ex: solution initiale) pour chaque cycle.
+     * @param {object} params - Les paramètres de configuration.
+     * @param {Array<any>} params.baseArgs - Les arguments de base, communs à tous les workers.
+     * @param {object} params.variations - Décrit comment faire varier un argument.
+     * @returns {function(number): Array<any>} La fonction `workerDataGenerator`.
+     */
+    'generate:parallelArgs': (params) => {
+        const { baseArgs, variations } = params;
+        return (cycleIndex) => {
+            const cycleArgs = [...baseArgs];
+            // Pour l'instant, on gère la variation de la solution initiale pour le TSP
+            if (variations?.initialSolution === 'random') {
+                cycleArgs[0] = cycleArgs[0].sort(() => Math.random() - 0.5);
+            }
+            return cycleArgs;
+        };
+    }
+};
+
+class ProblemManager {
+    constructor(configPath) {
+        this.configPath = configPath;
+        this.problems = this.loadProblems();
+        this.currentProblemIndex = 0;
+    }
+
+    loadProblems() {
+        try {
+            const data = readFileSync(this.configPath, 'utf-8');
+            const problems = JSON.parse(data);
+            // Initialisation dynamique des problèmes
+            for (const problem of problems) { // eslint-disable-line no-unused-vars
+                for (const key in problem.payload) {
+                    const value = problem.payload[key];
+                    // On cherche une instruction d'initialisation (ex: { "$init": "generate:randomPoints", ... })
+                    if (typeof value === 'object' && value !== null && value.$init) {
+                        const initializer = ProblemInitializers[value.$init];
+                        if (initializer) {
+                            // On remplace l'objet d'instruction par les données générées.
+                            problem.payload[key] = initializer(value.params || {});
+                        }
+                    }
+                }
+            }
+            return problems;
+        } catch (error) {
+            console.error(`[ProblemManager] Erreur lors du chargement du fichier de problèmes: ${error.message}`);
+            return []; // Retourne un tableau vide en cas d'erreur pour éviter un crash
+        }
+    }
+
+    saveProblems() {
+        // Note: Dans un vrai scénario, utilisez une base de données pour éviter les race conditions.
+        try {
+            writeFileSync(this.configPath, JSON.stringify(this.problems, null, 2));
+        } catch (error) {
+            console.error(`[ProblemManager] Erreur lors de la sauvegarde du fichier de problèmes: ${error.message}`);
+        }
+    }
+
+    /**
+     * Sélectionne un problème et génère une unité de travail.
+     * @param {number} suspicionFactor - Le facteur de suspicion pour ajuster la difficulté.
+     * @returns {{problemId: string, task: object}|null}
+     */
+    dispatchWork(suspicionFactor) {
+        if (this.problems.length === 0) return null;
+
+        const problem = this.problems[this.currentProblemIndex];
+        this.currentProblemIndex = (this.currentProblemIndex + 1) % this.problems.length;
+
+        const task = { type: problem.workUnit.type };
+        const { scalingFactor } = problem.workUnit;
+
+        switch (problem.workUnit.type) {
+            case 'simulated_annealing_iterations':
+                // Assurer une difficulté minimale pour que le challenge soit significatif
+                const baseIterations = Math.max(15000, problem.workUnit.baseIterations || 0);
+                task.iterations = scalingFactor
+                    ? Math.floor(baseIterations * Math.pow(scalingFactor, suspicionFactor))
+                    : Math.floor(baseIterations * (0.5 + suspicionFactor));
+                task.payload = problem.payload;
+                task.initialSolution = problem.state.bestSolution;
+                break;
+
+            case 'genetic_algorithm_generations':
+                // Assurer une difficulté minimale pour que le challenge soit significatif
+                const baseGenerations = Math.max(50, problem.workUnit.baseGenerations || 0);
+                task.generations = scalingFactor
+                    ? Math.floor(baseGenerations * Math.pow(scalingFactor, suspicionFactor))
+                    : Math.floor(baseGenerations * (0.5 + suspicionFactor));
+                task.payload = problem.payload;
+                task.initialPopulation = problem.state.population;
+                break;
+
+            case 'run_multiple_parallel':
+                task.solverName = problem.workUnit.solverName;
+                task.numCycles = problem.workUnit.numCycles;
+                // Les arguments et le générateur sont dans le payload pour plus de flexibilité
+                task.baseSolverArgs = problem.payload.baseSolverArgs;
+                task.workerDataGenerator = problem.payload.workerDataGenerator;
+                task.logProgress = problem.payload.logProgress || false;
+                task.concurrency = problem.payload.concurrency;
+                break;
+        }
+
+        return { problemId: problem.id, task };
+    }
+
+    /**
+     * Intègre la solution d'un client dans l'état du problème.
+     * @param {string} problemId - L'ID du problème.
+     * @param {object} solutionData - La solution renvoyée par le client.
+     */
+    integrateSolution(problemId, solutionData) {
+        const problem = this.problems.find(p => p.id === problemId);
+        if (!problem) return;
+
+        switch (problem.workUnit.type) {
+            case 'simulated_annealing_iterations':
+                if (solutionData.energy < (parseFloat(problem.state.bestEnergy) || Infinity)) {
+                    problem.state.bestSolution = solutionData.solution;
+                    problem.state.bestEnergy = solutionData.energy;
+                    console.log(`[ProblemManager] Nouvelle meilleure solution pour ${problemId}: ${solutionData.energy.toFixed(2)}`);
+                }
+                break;
+            case 'genetic_algorithm_generations':
+                problem.state.population = solutionData.population;
+                console.log(`[ProblemManager] Population mise à jour pour ${problemId}.`);
+                break;
+        }
+        this.saveProblems();
+    }
+
+    /**
+     * S'assure qu'un problème a une solution initiale. Si non, en génère une.
+     * @param {object} problem - L'objet problème.
+     * @private
+     */
+    _ensureInitialSolution(problem) {
+        if (problem.state.bestSolution) {
+            return; // Une solution existe déjà
+        }
+
+        console.log(`[ProblemManager] Génération d'une solution initiale pour le problème ${problem.id}...`);
+
+        // On se base sur le type de problème pour générer une solution de base.
+        // Pour l'instant, on gère le cas le plus commun (TSP/points)
+        // qui utilise le recuit simulé.
+        switch (problem.workUnit.type) {
+            case 'simulated_annealing_iterations': {
+                // Pour un TSP, une solution initiale est un ordre des points.
+                // On prend l'ordre initial des points du payload.
+                const initialSolution = problem.payload.points;
+                if (initialSolution && Array.isArray(initialSolution)) {
+                    // On calcule l'énergie (coût) de cette solution initiale.
+                    const energy = Optimization.tsp.calculateEnergy(initialSolution);
+                    problem.state.bestSolution = initialSolution;
+                    problem.state.bestEnergy = energy;
+                    problem.state.lastUpdate = new Date().toISOString();
+                    console.log(`[ProblemManager] Solution initiale pour ${problem.id} générée avec une énergie de ${energy.toFixed(2)}.`);
+                    this.saveProblems(); // On sauvegarde la nouvelle solution
+                }
+                break;
+            }
+            // D'autres types de problèmes (ex: algo génétique) pourraient être ajoutés ici.
+        }
+    }
+
+    /**
+     * Récupère la meilleure solution actuellement connue pour un ou plusieurs problèmes.
+     * @param {string} [problemId] - L'ID optionnel du problème à consulter.
+     * Si non fourni, retourne les meilleures solutions pour tous les problèmes.
+     * @returns {object|Array<object>|null}
+     * - Si un `problemId` est fourni, retourne un objet `{ id, solution, score }` ou `null` si non trouvé.
+     * - Si aucun `problemId` n'est fourni, retourne un tableau de ces objets.
+     */
+    getBestSolutions(problemId) {
+        const problemsToProcess = problemId
+            ? this.problems.filter(p => p.id === problemId)
+            : this.problems;
+
+        problemsToProcess.forEach(p => this._ensureInitialSolution(p));
+
+        const formatSolution = (p) => {
+            // Après _ensureInitialSolution, on peut supposer que p.state existe.
+            if (!p || !p.state) return null;
+            return {
+                id: p.id,
+                solution: p.state.bestSolution,
+                // Gère les deux types de scores : 'energy' (recuit simulé) et 'fitness' (algo génétique)
+                score: p.state.bestEnergy !== undefined ? p.state.bestEnergy : p.state.bestFitness,
+                lastUpdate: p.state.lastUpdate,
+            };
+        };
+
+        if (problemId) {
+            const problem = this.problems.find(p => p.id === problemId);
+            return problem ? formatSolution(problem) : null; // Le filtrage initial a déjà fait le travail
+        }
+
+        // Retourne un aperçu pour tous les problèmes
+        return this.problems.map(formatSolution).filter(s => s && s.solution);
+    }
+
+}
+
+export { ProblemManager }; // Export the class for testing
+export const problemManager = new ProblemManager('./problems.config.json');

package/redis-store.js

@@ -1,43 +1,43 @@
-/**
- * @file Creates a store adapter for ioredis.
- * This adapter handles the serialization and deserialization of complex objects,
- * including the conversion of Set objects to arrays for storage in Redis.
- */
-
-/**
- * Creates a store adapter for an ioredis client.
- * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createRedisStore(redisClient) {
-  return {
-    async get(key) {
-      const value = await redisClient.get(key);
-      if (!value) return null;
-      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
-      return JSON.parse(value, (k, v) => {
-        if (k === 'ips' && Array.isArray(v)) {
-          return new Set(v);
-        }
-        return v;
-      });
-    },
-    async set(key, value, ttl) {
-      // Use a replacer to convert Set objects into arrays before serialization.
-      const stringValue = JSON.stringify(value, (k, v) => {
-        if (v instanceof Set) {
-          return Array.from(v);
-        }
-        return v;
-      });
-
-      if (ttl && ttl > 0) {
-        await redisClient.set(key, stringValue, 'EX', ttl);
-      } else {
-        await redisClient.set(key, stringValue);
-      }
-    },
-    async has(key) { return (await redisClient.exists(key)) === 1; },
-    async delete(key) { await redisClient.del(key); },
-  };
+/**
+ * @file Creates a store adapter for ioredis.
+ * This adapter handles the serialization and deserialization of complex objects,
+ * including the conversion of Set objects to arrays for storage in Redis.
+ */
+
+/**
+ * Creates a store adapter for an ioredis client.
+ * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createRedisStore(redisClient) {
+  return {
+    async get(key) {
+      const value = await redisClient.get(key);
+      if (!value) return null;
+      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
+      return JSON.parse(value, (k, v) => {
+        if (k === 'ips' && Array.isArray(v)) {
+          return new Set(v);
+        }
+        return v;
+      });
+    },
+    async set(key, value, ttl) {
+      // Use a replacer to convert Set objects into arrays before serialization.
+      const stringValue = JSON.stringify(value, (k, v) => {
+        if (v instanceof Set) {
+          return Array.from(v);
+        }
+        return v;
+      });
+
+      if (ttl && ttl > 0) {
+        await redisClient.set(key, stringValue, 'EX', ttl);
+      } else {
+        await redisClient.set(key, stringValue);
+      }
+    },
+    async has(key) { return (await redisClient.exists(key)) === 1; },
+    async delete(key) { await redisClient.del(key); },
+  };
 }

package/sql-store.js

@@ -1,78 +1,78 @@
-/**
- * @file Creates a store adapter for Knex.js.
- * This adapter is compatible with various SQL databases like PostgreSQL, MySQL, and SQLite.
- * It handles serialization of complex objects and TTL for automatic data expiration.
- */
-
-/**
- * Creates a store adapter for a Knex.js client.
- *
- * **Note:** You must create the table yourself before using the store.
- * The table should have at least the following columns:
- * - `key` (string, primary key)
- * - `value` (text or json/jsonb)
- * - `expiresAt` (datetime or timestamp with time zone)
- *
- * Example schema for PostgreSQL:
- * ```sql
- * CREATE TABLE your_table_name (
- *   "key" VARCHAR(255) PRIMARY KEY,
- *   "value" TEXT NOT NULL,
- *   "expiresAt" TIMESTAMPTZ
- * );
- * ```
- *
- * @param {import('knex').Knex} knex - An instance of the Knex client.
- * @param {string} [tableName='fingerprint_store'] - The name of the table to use.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createSqlStore(knex, tableName = 'fingerprint_store') {
-  // Custom replacer/reviver to handle Set serialization, similar to the Redis store.
-  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
-  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
-
-  return {
-    async get(key) {
-      const row = await knex(tableName).where('key', key).first();
-      if (!row) return null;
-
-      // Manually check for expiration, as not all SQL databases have automatic TTL cleanup.
-      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
-        await this.delete(key); // Clean up expired key.
-        return null;
-      }
-
-      try {
-        return JSON.parse(row.value, reviver);
-      } catch (e) {
-        // In case of malformed JSON, treat it as a miss.
-        return null;
-      }
-    },
-
-    async set(key, value, ttl) {
-      const stringValue = JSON.stringify(value, replacer);
-      const expiresAt = ttl ? new Date(Date.now() + ttl * 1000) : null;
-
-      // Use native upsert capabilities of Knex for different SQL dialects.
-      await knex(tableName)
-        .insert({ key, value: stringValue, expiresAt })
-        .onConflict('key')
-        .merge();
-    },
-
-    async has(key) {
-      const row = await knex(tableName).where('key', key).first('key');
-      if (!row) return false;
-      // Also check for expiration here.
-      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
-        return false;
-      }
-      return true;
-    },
-
-    async delete(key) {
-      await knex(tableName).where('key', key).del();
-    },
-  };
+/**
+ * @file Creates a store adapter for Knex.js.
+ * This adapter is compatible with various SQL databases like PostgreSQL, MySQL, and SQLite.
+ * It handles serialization of complex objects and TTL for automatic data expiration.
+ */
+
+/**
+ * Creates a store adapter for a Knex.js client.
+ *
+ * **Note:** You must create the table yourself before using the store.
+ * The table should have at least the following columns:
+ * - `key` (string, primary key)
+ * - `value` (text or json/jsonb)
+ * - `expiresAt` (datetime or timestamp with time zone)
+ *
+ * Example schema for PostgreSQL:
+ * ```sql
+ * CREATE TABLE your_table_name (
+ *   "key" VARCHAR(255) PRIMARY KEY,
+ *   "value" TEXT NOT NULL,
+ *   "expiresAt" TIMESTAMPTZ
+ * );
+ * ```
+ *
+ * @param {import('knex').Knex} knex - An instance of the Knex client.
+ * @param {string} [tableName='fingerprint_store'] - The name of the table to use.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createSqlStore(knex, tableName = 'fingerprint_store') {
+  // Custom replacer/reviver to handle Set serialization, similar to the Redis store.
+  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
+  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
+
+  return {
+    async get(key) {
+      const row = await knex(tableName).where('key', key).first();
+      if (!row) return null;
+
+      // Manually check for expiration, as not all SQL databases have automatic TTL cleanup.
+      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
+        await this.delete(key); // Clean up expired key.
+        return null;
+      }
+
+      try {
+        return JSON.parse(row.value, reviver);
+      } catch (e) {
+        // In case of malformed JSON, treat it as a miss.
+        return null;
+      }
+    },
+
+    async set(key, value, ttl) {
+      const stringValue = JSON.stringify(value, replacer);
+      const expiresAt = ttl ? new Date(Date.now() + ttl * 1000) : null;
+
+      // Use native upsert capabilities of Knex for different SQL dialects.
+      await knex(tableName)
+        .insert({ key, value: stringValue, expiresAt })
+        .onConflict('key')
+        .merge();
+    },
+
+    async has(key) {
+      const row = await knex(tableName).where('key', key).first('key');
+      if (!row) return false;
+      // Also check for expiration here.
+      if (row.expiresAt && new Date(row.expiresAt) < new Date()) {
+        return false;
+      }
+      return true;
+    },
+
+    async delete(key) {
+      await knex(tableName).where('key', key).del();
+    },
+  };
 }