pythonlib 1.0.2 → 2.0.1

package/dist/chunk-RRSOZXZE.js

@@ -0,0 +1,155 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/copy.ts
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy,
+  deepcopy: () => deepcopy
+});
+function copy(x) {
+  if (x === null || x === void 0) {
+    return x;
+  }
+  const type = typeof x;
+  if (type === "number" || type === "string" || type === "boolean" || type === "bigint" || type === "symbol") {
+    return x;
+  }
+  if (x instanceof Date) {
+    return new Date(x.getTime());
+  }
+  if (x instanceof RegExp) {
+    return new RegExp(x.source, x.flags);
+  }
+  if (Array.isArray(x)) {
+    return [...x];
+  }
+  if (x instanceof Map) {
+    return new Map(x);
+  }
+  if (x instanceof Set) {
+    return new Set(x);
+  }
+  if (ArrayBuffer.isView(x) && !(x instanceof DataView)) {
+    const TypedArrayConstructor = x.constructor;
+    const typedArray = x;
+    return new TypedArrayConstructor(typedArray.buffer.slice(0));
+  }
+  if (x instanceof DataView) {
+    return new DataView(x.buffer.slice(0), x.byteOffset, x.byteLength);
+  }
+  if (x instanceof ArrayBuffer) {
+    return x.slice(0);
+  }
+  if (type === "object") {
+    const proto = Object.getPrototypeOf(x);
+    if (proto === Object.prototype || proto === null) {
+      return { ...x };
+    }
+    const result = Object.create(proto);
+    Object.assign(result, x);
+    return result;
+  }
+  return x;
+}
+function deepcopy(x, memo) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(x);
+    } catch {
+    }
+  }
+  if (x === null || x === void 0) {
+    return x;
+  }
+  const type = typeof x;
+  if (type === "number" || type === "string" || type === "boolean" || type === "bigint" || type === "symbol") {
+    return x;
+  }
+  memo ??= /* @__PURE__ */ new Map();
+  if (memo.has(x)) {
+    return memo.get(x);
+  }
+  if (x instanceof Date) {
+    const result = new Date(x.getTime());
+    memo.set(x, result);
+    return result;
+  }
+  if (x instanceof RegExp) {
+    const result = new RegExp(x.source, x.flags);
+    memo.set(x, result);
+    return result;
+  }
+  if (Array.isArray(x)) {
+    const result = [];
+    memo.set(x, result);
+    for (const item of x) {
+      result.push(deepcopy(item, memo));
+    }
+    return result;
+  }
+  if (x instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    memo.set(x, result);
+    for (const [key, value] of x) {
+      result.set(deepcopy(key, memo), deepcopy(value, memo));
+    }
+    return result;
+  }
+  if (x instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    memo.set(x, result);
+    for (const item of x) {
+      result.add(deepcopy(item, memo));
+    }
+    return result;
+  }
+  if (ArrayBuffer.isView(x) && !(x instanceof DataView)) {
+    const TypedArrayConstructor = x.constructor;
+    const typedArray = x;
+    const result = new TypedArrayConstructor(typedArray.buffer.slice(0));
+    memo.set(x, result);
+    return result;
+  }
+  if (x instanceof DataView) {
+    const result = new DataView(x.buffer.slice(0), x.byteOffset, x.byteLength);
+    memo.set(x, result);
+    return result;
+  }
+  if (x instanceof ArrayBuffer) {
+    const result = x.slice(0);
+    memo.set(x, result);
+    return result;
+  }
+  if (type === "function") {
+    return x;
+  }
+  if (type === "object") {
+    const proto = Object.getPrototypeOf(x);
+    const result = Object.create(proto);
+    memo.set(x, result);
+    for (const key of Object.keys(x)) {
+      result[key] = deepcopy(x[key], memo);
+    }
+    for (const sym of Object.getOwnPropertySymbols(x)) {
+      const descriptor = Object.getOwnPropertyDescriptor(x, sym);
+      if (descriptor?.enumerable) {
+        ;
+        result[sym] = deepcopy(
+          x[sym],
+          memo
+        );
+      }
+    }
+    return result;
+  }
+  return x;
+}
+
+export {
+  copy,
+  deepcopy,
+  copy_exports
+};
+/* v8 ignore start -- fallback for environments without structuredClone @preserve */

package/dist/chunk-THMJVAK6.js

@@ -0,0 +1,282 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/subprocess.ts
+var subprocess_exports = {};
+__export(subprocess_exports, {
+  CalledProcessError: () => CalledProcessError,
+  DEVNULL: () => DEVNULL,
+  PIPE: () => PIPE,
+  Popen: () => Popen,
+  STDOUT: () => STDOUT,
+  TimeoutExpired: () => TimeoutExpired,
+  call: () => call,
+  checkCall: () => checkCall,
+  checkOutput: () => checkOutput,
+  getoutput: () => getoutput,
+  getstatusoutput: () => getstatusoutput,
+  run: () => run
+});
+import * as childProcess from "child_process";
+var PIPE = "pipe";
+var STDOUT = "stdout";
+var DEVNULL = "devnull";
+var CalledProcessError = class extends Error {
+  returncode;
+  cmd;
+  stdout;
+  stderr;
+  constructor(returncode, cmd, stdout = null, stderr = null) {
+    super(`Command '${cmd.join(" ")}' returned non-zero exit status ${String(returncode)}`);
+    this.name = "CalledProcessError";
+    this.returncode = returncode;
+    this.cmd = cmd;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+var TimeoutExpired = class extends Error {
+  cmd;
+  timeout;
+  stdout;
+  stderr;
+  constructor(cmd, timeout, stdout = null, stderr = null) {
+    super(`Command '${cmd.join(" ")}' timed out after ${String(timeout)} milliseconds`);
+    this.name = "TimeoutExpired";
+    this.cmd = cmd;
+    this.timeout = timeout;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+function run(args, options) {
+  const encoding = options?.encoding ?? "utf-8";
+  const text = options?.text ?? true;
+  let command;
+  let cmdArgs;
+  if (typeof args === "string") {
+    command = args;
+    cmdArgs = [args];
+  } else {
+    command = args[0] ?? "";
+    cmdArgs = args.slice(1);
+  }
+  const spawnOptions = {
+    cwd: options?.cwd,
+    env: options?.env ? { ...process.env, ...options.env } : void 0,
+    input: options?.input,
+    timeout: options?.timeout,
+    shell: options?.shell,
+    encoding: text ? encoding : "buffer",
+    stdio: [
+      options?.input !== void 0 ? "pipe" : "inherit",
+      options?.stdout === PIPE ? "pipe" : options?.stdout === DEVNULL ? "ignore" : "inherit",
+      options?.stderr === PIPE ? "pipe" : options?.stderr === STDOUT ? "pipe" : options?.stderr === DEVNULL ? "ignore" : "inherit"
+    ]
+  };
+  let result;
+  if (typeof args === "string" || options?.shell) {
+    result = childProcess.spawnSync(typeof args === "string" ? args : args.join(" "), [], {
+      ...spawnOptions,
+      shell: true
+    });
+  } else {
+    result = childProcess.spawnSync(command, cmdArgs, spawnOptions);
+  }
+  if (result.error && result.error.code === "ETIMEDOUT") {
+    throw new TimeoutExpired(
+      typeof args === "string" ? [args] : args,
+      options?.timeout ?? 0,
+      result.stdout ? result.stdout.toString() : null,
+      result.stderr ? result.stderr.toString() : null
+    );
+  }
+  const stdout = result.stdout ? text ? result.stdout.toString() : result.stdout.toString() : null;
+  const stderr = result.stderr ? text ? result.stderr.toString() : result.stderr.toString() : null;
+  const returncode = result.status ?? -1;
+  if (options?.check && returncode !== 0) {
+    throw new CalledProcessError(
+      returncode,
+      typeof args === "string" ? [args] : args,
+      stdout,
+      stderr
+    );
+  }
+  return {
+    args: typeof args === "string" ? [args] : args,
+    returncode,
+    stdout,
+    stderr
+  };
+}
+function call(args, options) {
+  const result = run(args, options);
+  return result.returncode;
+}
+function checkCall(args, options) {
+  const result = run(args, { ...options, check: true });
+  return result.returncode;
+}
+function checkOutput(args, options) {
+  const result = run(args, { ...options, stdout: PIPE, check: true });
+  return result.stdout ?? "";
+}
+function getoutput(cmd) {
+  try {
+    const result = run(cmd, { shell: true, stdout: PIPE, stderr: DEVNULL });
+    return result.stdout?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+function getstatusoutput(cmd) {
+  const result = run(cmd, { shell: true, stdout: PIPE, stderr: STDOUT });
+  return [result.returncode, result.stdout?.trim() ?? ""];
+}
+var Popen = class {
+  args;
+  process;
+  _returncode = null;
+  _stdout = null;
+  _stderr = null;
+  constructor(args, options) {
+    this.args = typeof args === "string" ? [args] : args;
+    const command = typeof args === "string" ? args : args[0] ?? "";
+    const cmdArgs = typeof args === "string" ? [] : args.slice(1);
+    const spawnOptions = {
+      cwd: options?.cwd,
+      env: options?.env ? { ...process.env, ...options.env } : void 0,
+      shell: options?.shell,
+      stdio: [
+        options?.input !== void 0 ? "pipe" : "inherit",
+        options?.stdout === PIPE ? "pipe" : options?.stdout === DEVNULL ? "ignore" : "inherit",
+        options?.stderr === PIPE ? "pipe" : options?.stderr === STDOUT ? "pipe" : options?.stderr === DEVNULL ? "ignore" : "inherit"
+      ]
+    };
+    if (typeof args === "string" || options?.shell) {
+      this.process = childProcess.spawn(typeof args === "string" ? args : args.join(" "), [], {
+        ...spawnOptions,
+        shell: true
+      });
+    } else {
+      this.process = childProcess.spawn(command, cmdArgs, spawnOptions);
+    }
+    if (options?.input !== void 0 && this.process.stdin) {
+      this.process.stdin.write(options.input);
+      this.process.stdin.end();
+    }
+    if (this.process.stdout) {
+      let data = "";
+      this.process.stdout.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      this.process.stdout.on("end", () => {
+        this._stdout = data;
+      });
+    }
+    if (this.process.stderr) {
+      let data = "";
+      this.process.stderr.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      this.process.stderr.on("end", () => {
+        this._stderr = data;
+      });
+    }
+    this.process.on("exit", (code) => {
+      this._returncode = code ?? -1;
+    });
+  }
+  /**
+   * Wait for the process to complete.
+   */
+  wait() {
+    return new Promise((resolve) => {
+      if (this._returncode !== null) {
+        resolve(this._returncode);
+      } else {
+        this.process.on("exit", (code) => {
+          resolve(code ?? -1);
+        });
+      }
+    });
+  }
+  /**
+   * Get the exit code (or null if still running).
+   */
+  poll() {
+    return this._returncode;
+  }
+  /**
+   * Communicate with the process and return stdout/stderr.
+   */
+  async communicate(input) {
+    if (input !== void 0 && this.process.stdin) {
+      this.process.stdin.write(input);
+      this.process.stdin.end();
+    }
+    await this.wait();
+    return [this._stdout, this._stderr];
+  }
+  /* v8 ignore start -- process control methods are hard to test reliably @preserve */
+  /**
+   * Send a signal to the process.
+   */
+  send_signal(signal) {
+    return this.process.kill(signal);
+  }
+  /**
+   * Terminate the process.
+   */
+  terminate() {
+    return this.process.kill("SIGTERM");
+  }
+  /**
+   * Kill the process.
+   */
+  kill() {
+    return this.process.kill("SIGKILL");
+  }
+  /* v8 ignore stop */
+  /**
+   * The process ID.
+   */
+  get pid() {
+    return this.process.pid;
+  }
+  /**
+   * The exit code (or null if still running).
+   */
+  get returncode() {
+    return this._returncode;
+  }
+  /**
+   * The captured stdout.
+   */
+  get stdout() {
+    return this._stdout;
+  }
+  /**
+   * The captured stderr.
+   */
+  get stderr() {
+    return this._stderr;
+  }
+};
+
+export {
+  PIPE,
+  STDOUT,
+  DEVNULL,
+  CalledProcessError,
+  TimeoutExpired,
+  run,
+  call,
+  checkCall,
+  checkOutput,
+  getoutput,
+  getstatusoutput,
+  Popen,
+  subprocess_exports
+};

package/dist/chunk-UGZ5OY5Z.js

@@ -0,0 +1,165 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tempfile.node.ts
+var tempfile_node_exports = {};
+__export(tempfile_node_exports, {
+  NamedTemporaryFile: () => NamedTemporaryFile,
+  TemporaryDirectory: () => TemporaryDirectory,
+  gettempdir: () => gettempdir,
+  gettempprefix: () => gettempprefix,
+  mkdtemp: () => mkdtemp,
+  mkstemp: () => mkstemp,
+  mktemp: () => mktemp,
+  namedTemporaryFile: () => namedTemporaryFile,
+  temporaryDirectory: () => temporaryDirectory
+});
+import { mkdir, open, rm, unlink } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+function gettempdir() {
+  return tmpdir();
+}
+function mktemp(suffix = "", prefix = "tmp", dir) {
+  const tempDir = dir ?? gettempdir();
+  const randomPart = randomBytes(8).toString("hex");
+  return join(tempDir, `${prefix}${randomPart}${suffix}`);
+}
+async function mkstemp(suffix = "", prefix = "tmp", dir, _text = false) {
+  const tempDir = dir ?? gettempdir();
+  const randomPart = randomBytes(8).toString("hex");
+  const path = join(tempDir, `${prefix}${randomPart}${suffix}`);
+  const handle = await open(path, "w+", 384);
+  return [handle, path];
+}
+async function mkdtemp(suffix = "", prefix = "tmp", dir) {
+  const tempDir = dir ?? gettempdir();
+  const randomPart = randomBytes(8).toString("hex");
+  const path = join(tempDir, `${prefix}${randomPart}${suffix}`);
+  await mkdir(path, { mode: 448 });
+  return path;
+}
+var NamedTemporaryFile = class _NamedTemporaryFile {
+  /** The file handle */
+  handle;
+  /** The file path */
+  name;
+  /** Whether to delete the file on close */
+  deleteOnClose;
+  _closed = false;
+  constructor(handle, name, deleteOnClose) {
+    this.handle = handle;
+    this.name = name;
+    this.deleteOnClose = deleteOnClose;
+  }
+  /**
+   * Create a new NamedTemporaryFile.
+   */
+  static async create(options) {
+    const suffix = options?.suffix ?? "";
+    const prefix = options?.prefix ?? "tmp";
+    const dir = options?.dir;
+    const deleteOnClose = options?.delete ?? true;
+    const [handle, path] = await mkstemp(suffix, prefix, dir);
+    return new _NamedTemporaryFile(handle, path, deleteOnClose);
+  }
+  /**
+   * Write data to the file.
+   */
+  async write(data) {
+    const result = await this.handle.write(typeof data === "string" ? Buffer.from(data) : data);
+    return result.bytesWritten;
+  }
+  /**
+   * Read data from the file.
+   */
+  async read(size) {
+    const fileSize = size ?? (await this.handle.stat()).size;
+    const buffer = Buffer.alloc(fileSize);
+    await this.handle.read(buffer, 0, buffer.length, 0);
+    return buffer;
+  }
+  /**
+   * Seek to a position in the file.
+   */
+  seek(_offset, _whence = 0) {
+  }
+  /**
+   * Flush the file buffer.
+   */
+  async flush() {
+    await this.handle.sync();
+  }
+  /**
+   * Close the file.
+   */
+  async close() {
+    if (!this._closed) {
+      await this.handle.close();
+      if (this.deleteOnClose) {
+        try {
+          await unlink(this.name);
+        } catch {
+        }
+      }
+      this._closed = true;
+    }
+  }
+  /**
+   * Check if the file is closed.
+   */
+  get closed() {
+    return this._closed;
+  }
+};
+var TemporaryDirectory = class _TemporaryDirectory {
+  /** The directory path */
+  name;
+  _cleaned = false;
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Create a new TemporaryDirectory.
+   */
+  static async create(options) {
+    const name = await mkdtemp(options?.suffix, options?.prefix, options?.dir);
+    return new _TemporaryDirectory(name);
+  }
+  /**
+   * Remove the temporary directory and its contents.
+   */
+  async cleanup() {
+    if (!this._cleaned) {
+      try {
+        await rm(this.name, { recursive: true, force: true });
+      } catch {
+      }
+      this._cleaned = true;
+    }
+  }
+};
+async function namedTemporaryFile(options) {
+  return NamedTemporaryFile.create(options);
+}
+async function temporaryDirectory(options) {
+  return TemporaryDirectory.create(options);
+}
+function gettempprefix() {
+  return "tmp";
+}
+
+export {
+  gettempdir,
+  mktemp,
+  mkstemp,
+  mkdtemp,
+  NamedTemporaryFile,
+  TemporaryDirectory,
+  namedTemporaryFile,
+  temporaryDirectory,
+  gettempprefix,
+  tempfile_node_exports
+};

package/dist/chunk-WTZSAITC.js

@@ -0,0 +1,82 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/shutil.browser.ts
+var shutil_browser_exports = {};
+__export(shutil_browser_exports, {
+  copy: () => copy,
+  copy2: () => copy2,
+  copyFile: () => copyFile,
+  copyFileObj: () => copyFileObj,
+  copyMode: () => copyMode,
+  copyStat: () => copyStat,
+  copytree: () => copytree,
+  diskUsage: () => diskUsage,
+  getTerminalSize: () => getTerminalSize,
+  makeArchive: () => makeArchive,
+  move: () => move,
+  rmtree: () => rmtree,
+  unpackArchive: () => unpackArchive,
+  which: () => which
+});
+async function copy(_src, _dst) {
+  throw new Error("shutil.copy is not supported in browser environment");
+}
+async function copy2(_src, _dst) {
+  throw new Error("shutil.copy2 is not supported in browser environment");
+}
+async function copytree(_src, _dst, _options) {
+  throw new Error("shutil.copytree is not supported in browser environment");
+}
+async function move(_src, _dst) {
+  throw new Error("shutil.move is not supported in browser environment");
+}
+async function rmtree(_path, _ignoreErrors = false) {
+  throw new Error("shutil.rmtree is not supported in browser environment");
+}
+async function which(_cmd, _mode, _path) {
+  return null;
+}
+async function diskUsage(_path) {
+  throw new Error("shutil.diskUsage is not supported in browser environment");
+}
+async function copyMode(_src, _dst) {
+}
+async function copyStat(_src, _dst) {
+}
+async function copyFile(_src, _dst) {
+  throw new Error("shutil.copyFile is not supported in browser environment");
+}
+async function copyFileObj(_fsrc, _fdst, _length) {
+  throw new Error("shutil.copyFileObj is not supported in browser environment");
+}
+function getTerminalSize(fallback) {
+  const [columns, lines] = fallback ?? [80, 24];
+  return { columns, lines };
+}
+function makeArchive(_baseName, _format, _rootDir) {
+  throw new Error("makeArchive is not supported in browser environment");
+}
+function unpackArchive(_filename, _extractDir) {
+  throw new Error("unpackArchive is not supported in browser environment");
+}
+
+export {
+  copy,
+  copy2,
+  copytree,
+  move,
+  rmtree,
+  which,
+  diskUsage,
+  copyMode,
+  copyStat,
+  copyFile,
+  copyFileObj,
+  getTerminalSize,
+  makeArchive,
+  unpackArchive,
+  shutil_browser_exports
+};
+/* v8 ignore start -- browser stubs @preserve */