@dbx-tools/projen 0.9.51 → 0.9.58

package/shims/python-node/host.ts

@@ -1,341 +0,0 @@
-interface PythonBridge {
-  eval(source: string): unknown;
-}
-
-interface PythonCompletedProcess {
-  returncode: number;
-  stdout: string | null;
-  stderr: string | null;
-}
-
-interface PythonHttpResponse {
-  status_code: number;
-  headers: Record<string, string>;
-  content: Iterable<number>;
-}
-
-export interface PythonFileHost {
-  appendBytes(path: string, content: number[]): Promise<void>;
-  chmod(path: string, mode: number): Promise<void>;
-  copy(source: string, destination: string): Promise<void>;
-  exists(path: string): boolean;
-  mkdir(path: string, recursive: boolean): Promise<boolean>;
-  mkdtemp(prefix: string): Promise<string>;
-  readBytes(path: string): Promise<number[]>;
-  readDirectory(path: string): Promise<{ name: string; directory: boolean; file: boolean }[]>;
-  readTextSync(path: string): string;
-  readDirectorySync(path: string): { name: string; directory: boolean; file: boolean }[];
-  readLinkSync(path: string): string;
-  realpath(path: string): Promise<string>;
-  realpathSync(path: string): string;
-  remove(path: string, recursive: boolean, force: boolean): Promise<void>;
-  rename(source: string, destination: string): Promise<void>;
-  stat(path: string): Promise<{
-    directory: boolean;
-    file: boolean;
-    mode: number;
-    mtimeMs: number;
-    size: number;
-  }>;
-  statSync(path: string): {
-    directory: boolean;
-    file: boolean;
-    mode: number;
-    mtimeMs: number;
-    size: number;
-  };
-  touch(path: string, atimeMs: number, mtimeMs: number): Promise<void>;
-  writeBytes(path: string, content: number[], mode?: number): Promise<void>;
-}
-
-export interface PythonPathHost {
-  basename(path: string): string;
-  dirname(path: string): string;
-  fileUrlToPath(url: string): string;
-  isAbsolute(path: string): boolean;
-  join(parts: string[]): string;
-  relative(from: string, to: string): string;
-  resolve(parts: string[]): string;
-}
-
-export interface PythonProcessResult {
-  exitCode: number;
-  stdout?: string;
-  stderr?: string;
-}
-
-/** A started subprocess: await {@link wait} for its result, or {@link kill} it. */
-export interface PythonProcessHandle {
-  /** Terminate the child (SIGKILL). No-op once it has already exited. */
-  kill(): void;
-  /** Resolve with the child's result once it exits (runs off the main thread). */
-  wait(): Promise<PythonProcessResult>;
-}
-
-export interface PythonRuntimeHost {
-  crypto: {
-    digest(algorithm: string, content: number[], encoding?: "hex" | "base64"): string | number[];
-    hashes(): string[];
-    randomBytes(length: number): number[];
-  };
-  file: PythonFileHost;
-  os: {
-    homedir(): string;
-    tmpdir(): string;
-  };
-  path: PythonPathHost;
-  http: {
-    fetch(
-      url: string,
-      method?: string,
-      headers?: Record<string, string>,
-      body?: string,
-      timeoutMs?: number,
-    ): Promise<{ status: number; headers: Record<string, string>; body: number[] }>;
-  };
-  process: {
-    start(
-      command: string,
-      args: string[],
-      environment: Record<string, string> | undefined,
-      input: string | undefined,
-    ): PythonProcessHandle;
-  };
-}
-
-type PythonFunction = (...args: any[]) => any;
-
-const python = (globalThis as typeof globalThis & { python?: PythonBridge }).python;
-if (!python) throw new Error("PythonMonkey globalThis.python is unavailable");
-
-function evaluate<T extends PythonFunction>(source: string): T {
-  return python!.eval(source) as T;
-}
-
-const toThread = evaluate<PythonFunction>("__import__('asyncio').to_thread");
-const osPath = {
-  basename: evaluate<PythonFunction>("__import__('os').path.basename"),
-  dirname: evaluate<PythonFunction>("__import__('os').path.dirname"),
-  exists: evaluate<PythonFunction>("__import__('os').path.exists"),
-  isAbsolute: evaluate<PythonFunction>("__import__('os').path.isabs"),
-  join: evaluate<PythonFunction>("lambda parts: __import__('os').path.join(*list(parts))"),
-  realpath: evaluate<PythonFunction>("__import__('os').path.realpath"),
-  relative: evaluate<PythonFunction>("__import__('os').path.relpath"),
-  resolve: evaluate<PythonFunction>(
-    "lambda parts: __import__('os').path.abspath(__import__('os').path.join(*list(parts))) if list(parts) else __import__('os').getcwd()",
-  ),
-};
-const readBytes = evaluate<PythonFunction>("lambda path: list(open(path, 'rb').read())");
-const readText = evaluate<PythonFunction>("lambda path: open(path, encoding='utf-8').read()");
-const writeBytes = evaluate<PythonFunction>(
-  "lambda path, content: open(path, 'wb').write(bytes(int(value) for value in content))",
-);
-const appendBytes = evaluate<PythonFunction>(
-  "lambda path, content: open(path, 'ab').write(bytes(int(value) for value in content))",
-);
-const mkdir = evaluate<PythonFunction>(
-  "lambda path, recursive: __import__('os').makedirs(path, exist_ok=recursive) if recursive else __import__('os').mkdir(path)",
-);
-const listDirectory = evaluate<PythonFunction>(
-  "lambda path: [{'name': entry.name, 'directory': entry.is_dir(), 'file': entry.is_file()} for entry in __import__('pathlib').Path(path).iterdir()]",
-);
-const readLink = evaluate<PythonFunction>("__import__('os').readlink");
-const statPath = evaluate<PythonFunction>(
-  "lambda path: {'directory': __import__('os').path.isdir(path), 'file': __import__('os').path.isfile(path), 'mode': __import__('os').stat(path).st_mode, 'mtimeMs': __import__('os').stat(path).st_mtime * 1000, 'size': __import__('os').stat(path).st_size}",
-);
-const popen = evaluate<PythonFunction>(
-  "lambda command, args, environment, input_text: __import__('subprocess').Popen([command, *list(args)], env=dict(environment) if environment is not None else None, stdin=(__import__('subprocess').PIPE if input_text is not None else None), stdout=__import__('subprocess').PIPE, stderr=__import__('subprocess').PIPE, text=True)",
-);
-const communicate = evaluate<PythonFunction>(
-  "lambda proc, input_text: (lambda out: {'returncode': proc.returncode, 'stdout': out[0], 'stderr': out[1]})(proc.communicate(input=input_text))",
-);
-const killProcess = evaluate<PythonFunction>("lambda proc: proc.kill()");
-const requestHttp = evaluate<PythonFunction>(
-  "lambda url, method, headers, body, timeout: __import__('httpx').request(method or 'GET', url, headers=dict(headers) if headers is not None else None, content=body, timeout=(timeout / 1000) if timeout is not None else 30, follow_redirects=True)",
-);
-const chmod = evaluate<PythonFunction>(
-  "lambda path, mode: __import__('os').chmod(path, int(mode))",
-);
-const isDir = evaluate<PythonFunction>("__import__('os').path.isdir");
-const rmtree = evaluate<PythonFunction>("__import__('shutil').rmtree");
-const rmdir = evaluate<PythonFunction>("__import__('os').rmdir");
-const unlink = evaluate<PythonFunction>("__import__('os').unlink");
-
-const host: PythonRuntimeHost = {
-  crypto: {
-    digest: evaluate<PythonFunction>(
-      "lambda algorithm, content, encoding: (lambda value: value.hexdigest() if encoding == 'hex' else __import__('base64').b64encode(value.digest()).decode('ascii') if encoding == 'base64' else list(value.digest()))(__import__('hashlib').new(algorithm, bytes(int(item) for item in content)))",
-    ),
-    hashes: evaluate<PythonFunction>("lambda: sorted(__import__('hashlib').algorithms_available)"),
-    randomBytes: evaluate<PythonFunction>(
-      "lambda length: list(__import__('os').urandom(int(length)))",
-    ),
-  },
-  file: {
-    async appendBytes(path, content) {
-      await toThread(appendBytes, path, content);
-    },
-    async chmod(path, mode) {
-      await toThread(chmod, path, mode);
-    },
-    async copy(source, destination) {
-      await toThread(
-        evaluate<PythonFunction>("__import__('shutil').copyfile"),
-        source,
-        destination,
-      );
-    },
-    exists: (path) => Boolean(osPath.exists(path)),
-    async mkdir(path, recursive) {
-      if (await toThread(osPath.exists, path)) return false;
-      await toThread(mkdir, path, recursive);
-      return true;
-    },
-    async mkdtemp(prefix) {
-      return toThread(
-        evaluate<PythonFunction>("__import__('tempfile').mkdtemp"),
-        undefined,
-        prefix,
-      );
-    },
-    async readBytes(path) {
-      return toThread(readBytes, path);
-    },
-    async readDirectory(path) {
-      return toThread(listDirectory, path);
-    },
-    readDirectorySync: (path) => listDirectory(path),
-    readLinkSync: (path) => String(readLink(path)),
-    readTextSync: (path) => String(readText(path)),
-    async realpath(path) {
-      return String(await toThread(osPath.realpath, path));
-    },
-    realpathSync: (path) => String(osPath.realpath(path)),
-    async remove(path, recursive, force) {
-      if (!(await toThread(osPath.exists, path))) {
-        if (!force) throw Object.assign(new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-        return;
-      }
-      const isDirectory = await toThread(isDir, path);
-      const operation = isDirectory ? (recursive ? rmtree : rmdir) : unlink;
-      await toThread(operation, path);
-    },
-    async rename(source, destination) {
-      await toThread(evaluate<PythonFunction>("__import__('os').replace"), source, destination);
-    },
-    async stat(path) {
-      return toThread(statPath, path);
-    },
-    statSync: (path) => statPath(path),
-    async touch(path, atimeMs, mtimeMs) {
-      await toThread(
-        evaluate<PythonFunction>(
-          "lambda path, atime, mtime: __import__('os').utime(path, (atime / 1000, mtime / 1000))",
-        ),
-        path,
-        atimeMs,
-        mtimeMs,
-      );
-    },
-    async writeBytes(path, content, mode) {
-      await toThread(writeBytes, path, content);
-      if (mode !== undefined) await toThread(chmod, path, mode);
-    },
-  },
-  http: {
-    async fetch(url, method, headers, body, timeoutMs) {
-      const response = (await toThread(
-        requestHttp,
-        url,
-        method,
-        headers,
-        body,
-        timeoutMs,
-      )) as PythonHttpResponse;
-      return {
-        status: response.status_code,
-        headers: Object.fromEntries(Object.entries(response.headers)),
-        body: Array.from(response.content),
-      };
-    },
-  },
-  os: {
-    homedir: evaluate<PythonFunction>("lambda: __import__('pathlib').Path.home().as_posix()"),
-    tmpdir: evaluate<PythonFunction>("__import__('tempfile').gettempdir"),
-  },
-  path: {
-    basename: (path) => String(osPath.basename(path)),
-    dirname: (path) => String(osPath.dirname(path)),
-    fileUrlToPath: evaluate<PythonFunction>(
-      "lambda url: __import__('urllib.parse', fromlist=['urlparse']).unquote(__import__('urllib.parse', fromlist=['urlparse']).urlparse(url).path)",
-    ),
-    isAbsolute: (path) => Boolean(osPath.isAbsolute(path)),
-    join: (parts) => String(osPath.join(parts)),
-    relative: (from, to) => String(osPath.relative(to, from)),
-    resolve: (parts) => String(osPath.resolve(parts)),
-  },
-  process: {
-    start(command, args, environment, input) {
-      // Popen (not subprocess.run) so the child is killable: an aborted caller
-      // can terminate it instead of leaking a background process. There is no
-      // imposed timeout - the child runs to completion (an interactive login may
-      // legitimately take minutes); the caller owns cancellation.
-      const proc = popen(command, args, environment, input);
-      let killed = false;
-      return {
-        kill() {
-          if (killed) return;
-          killed = true;
-          try {
-            killProcess(proc);
-          } catch {
-            // The child already exited; there is nothing to signal.
-          }
-        },
-        async wait() {
-          // communicate() blocks until exit, so run it off the main thread.
-          const result = (await toThread(communicate, proc, input)) as PythonCompletedProcess;
-          return {
-            exitCode: result.returncode,
-            ...(result.stdout?.trim() ? { stdout: result.stdout.trim() } : {}),
-            ...(result.stderr?.trim() ? { stderr: result.stderr.trim() } : {}),
-          };
-        },
-      };
-    },
-  },
-};
-
-export function installPythonGlobals(): void {
-  const globals = globalThis as typeof globalThis & {
-    global?: typeof globalThis;
-    self?: typeof globalThis;
-    window?: typeof globalThis;
-    process?: Record<string, unknown>;
-  };
-  globals.global = globalThis;
-  globals.self = globalThis;
-  globals.window = globalThis;
-  globals.process ??= {
-    arch: String(evaluate<PythonFunction>("__import__('platform').machine")())
-      .replace("aarch64", "arm64")
-      .replace("x86_64", "x64"),
-    argv: [],
-    browser: true,
-    cwd: evaluate<PythonFunction>("__import__('os').getcwd"),
-    env: evaluate<PythonFunction>("lambda: dict(__import__('os').environ)")(),
-    nextTick: (callback: (...args: unknown[]) => void, ...args: unknown[]) =>
-      Promise.resolve().then(() => callback(...args)),
-    platform: { Darwin: "darwin", Linux: "linux", Windows: "win32" }[
-      String(evaluate<PythonFunction>("__import__('platform').system")())
-    ],
-    version: "v22.0.0",
-    versions: {},
-  };
-}
-
-installPythonGlobals();
-
-export function pythonHost(): PythonRuntimeHost {
-  return host;
-}

package/shims/python-node/os.ts

@@ -1,20 +0,0 @@
-import { pythonHost } from "./host.ts";
-
-export const constants = {
-  errno: {
-    EEXIST: 17,
-    ENOTDIR: 20,
-    EISDIR: 21,
-    EINVAL: 22,
-  },
-} as const;
-
-export function homedir(): string {
-  return pythonHost().os.homedir();
-}
-
-export function tmpdir(): string {
-  return pythonHost().os.tmpdir();
-}
-
-export default { constants, homedir, tmpdir };

package/shims/python-node/process.ts

@@ -1,13 +0,0 @@
-import { installPythonGlobals } from "./host.ts";
-
-installPythonGlobals();
-
-export default process;
-export const arch = process.arch;
-export const argv = process.argv;
-export const cwd = process.cwd;
-export const env = process.env;
-export const nextTick = process.nextTick;
-export const platform = process.platform;
-export const version = process.version;
-export const versions = process.versions;

package/shims/python-node/readline.ts

@@ -1,37 +0,0 @@
-/**
- * Async line reader used by subprocess output capture in PythonMonkey bundles.
- *
- * @module
- */
-
-interface ReadLineOptions {
-  readonly input: AsyncIterable<unknown>;
-}
-
-class PythonReadLine implements AsyncIterable<string> {
-  private closed = false;
-
-  constructor(private readonly input: AsyncIterable<unknown>) {}
-
-  async *[Symbol.asyncIterator](): AsyncIterator<string> {
-    let buffered = "";
-    for await (const chunk of this.input) {
-      if (this.closed) break;
-      buffered += String(chunk);
-      const lines = buffered.split(/\r?\n/);
-      buffered = lines.pop() ?? "";
-      for (const line of lines) yield line;
-    }
-    if (!this.closed && buffered) yield buffered.replace(/\r$/, "");
-  }
-
-  close(): void {
-    this.closed = true;
-  }
-}
-
-export function createInterface(options: ReadLineOptions): PythonReadLine {
-  return new PythonReadLine(options.input);
-}
-
-export default { createInterface };

package/shims/python-node/tsconfig.json

@@ -1,24 +0,0 @@
-// ~~ Generated by projen. To modify, edit .projenrc.js and run "bunx projen".
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": [
-      "ES2022",
-      "DOM"
-    ],
-    "types": [
-      "node"
-    ],
-    "noEmit": true,
-    "skipLibCheck": true,
-    "strict": false
-  },
-  "include": [
-    "*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}

package/src/python-node-bundle.ts

@@ -1,67 +0,0 @@
-/**
- * Projen task wiring for pyproject-driven PythonMonkey runtime generation.
- *
- * Type extraction and bundle emission remain in the executable generator; this
- * component owns only typed configuration and generate/check task registration.
- */
-import { Component, type Project, type Task } from "projen";
-import { taskCommand } from "./project-js.ts";
-
-/** One function replaced only in a generated PythonMonkey bundle. */
-export interface PythonNodeFunctionOverride {
-  /** Module specifier imported by the ordinary Node source. */
-  readonly module: string;
-  /** Named export to replace. */
-  readonly export: string;
-  /** Repository-relative TypeScript file containing the replacement. */
-  readonly handler: string;
-  /** Named export in {@link handler}. Defaults to {@link export}. */
-  readonly handlerExport?: string;
-}
-
-/** Node package embedded into one Python distribution through PythonMonkey. */
-export interface PythonNodeBindingsOptions {
-  /** Public Node package specifier, such as `@dbx-tools/auth`. */
-  readonly package: string;
-  /** Optional portable package subpath to bind. Defaults to {@link package}. */
-  readonly entrypoint?: string;
-  /** Automatically generated root namespace modules to bind independently. */
-  readonly modules?: readonly string[];
-  /** Functions replaced only while generating the Python runtime. */
-  readonly functionOverrides?: readonly PythonNodeFunctionOverride[];
-}
-
-/** Options for pyproject-driven PythonMonkey generation tasks. */
-export interface PythonNodeBundleOptions {
-  /** Stable task-name prefix, such as `auth`. */
-  readonly name: string;
-  /** Repository-relative Python project containing `pyproject.toml`. */
-  readonly projectDirectory: string;
-  /** Add the freshness check to the project's test task. Defaults to true. */
-  readonly test?: boolean;
-}
-
-/** Owns paired generation and freshness-check tasks for one Python package. */
-export class PythonNodeBundle extends Component {
-  readonly buildTask: Task;
-  readonly checkTask: Task;
-  readonly watchTask: Task;
-
-  constructor(project: Project, options: PythonNodeBundleOptions) {
-    super(project);
-    const command = taskCommand("python-node-bindings.ts", "--project", options.projectDirectory);
-    this.buildTask = project.addTask(`${options.name}:python-runtime`, {
-      description: `Generate Node bindings for Python package ${options.name}`,
-      execArgs: command,
-    });
-    this.checkTask = project.addTask(`${options.name}:python-runtime:check`, {
-      description: `Verify generated Node bindings for Python package ${options.name}`,
-      execArgs: [...command, "--check"],
-    });
-    this.watchTask = project.addTask(`${options.name}:python-runtime:watch`, {
-      description: `Watch and regenerate Node bindings for Python package ${options.name}`,
-      execArgs: taskCommand("python-node-bindings-watch.ts", "--project", options.projectDirectory),
-    });
-    if (options.test ?? true) project.testTask.spawn(this.checkTask);
-  }
-}