Class PythonWorkerPool

src/python/workerPool.ts:11–144

}

export class PythonWorkerPool {
  private workers: PythonWorker[] = [];
  private queue: QueuedRequest[] = [];
  private isInitialized: boolean = false;

  constructor(
    private scriptPath: string,
    private functionName: string,
    private workerCount: number = 1,
    private pythonPath?: string,
    private timeout?: number,
  ) {}

  async initialize(): Promise<void> {
    if (this.isInitialized) {
      return;
    }

    // Validate worker count
    if (this.workerCount < 1) {
      throw new Error(`Invalid worker count: ${this.workerCount}. Must be at least 1.`);
    }

    // Warn on excessive workers
    if (this.workerCount > 8) {
      logger.warn(
        `Spawning ${this.workerCount} Python workers for ${this.scriptPath}. ` +
          `This may use significant memory if your script has heavy imports.`,
      );
    }

    logger.debug(
      `Initializing Python worker pool with ${this.workerCount} workers for ${this.scriptPath}`,
    );

    // Start all workers in parallel
    const initPromises = [];
    for (let i = 0; i < this.workerCount; i++) {
      const worker = new PythonWorker(
        this.scriptPath,
        this.functionName,
        this.pythonPath,
        this.timeout,
        () => this.processQueue(), // Resume queue processing when worker becomes ready
      );
      initPromises.push(worker.initialize());
      this.workers.push(worker);
    }

    await Promise.all(initPromises);
    this.isInitialized = true;
    logger.debug(`Python worker pool initialized with ${this.workerCount} workers`);
  }

  // biome-ignore lint/suspicious/noExplicitAny: FIXME
  async execute(functionName: string, args: unknown[]): Promise<any> {
    if (!this.isInitialized) {
      throw new Error('Worker pool not initialized');