pythonlib 1.0.1 → 2.0.0

package/dist/shutil.browser.d.ts

@@ -0,0 +1 @@
+export { c as copy, a as copy2, g as copyFile, h as copyFileObj, e as copyMode, f as copyStat, b as copytree, d as diskUsage, i as getTerminalSize, j as makeArchive, m as move, r as rmtree, u as unpackArchive, w as which } from './shutil.browser-Ck5oWhnP.js';

package/dist/shutil.browser.js

@@ -0,0 +1,33 @@
+import {
+  copy,
+  copy2,
+  copyFile,
+  copyFileObj,
+  copyMode,
+  copyStat,
+  copytree,
+  diskUsage,
+  getTerminalSize,
+  makeArchive,
+  move,
+  rmtree,
+  unpackArchive,
+  which
+} from "./chunk-WTZSAITC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  copy,
+  copy2,
+  copyFile,
+  copyFileObj,
+  copyMode,
+  copyStat,
+  copytree,
+  diskUsage,
+  getTerminalSize,
+  makeArchive,
+  move,
+  rmtree,
+  unpackArchive,
+  which
+};

package/dist/shutil.node-C9kwvhAf.d.ts

@@ -0,0 +1,160 @@
+import { ReadStream, WriteStream } from 'node:fs';
+
+/**
+ * Python shutil module for TypeScript
+ *
+ * Provides high-level file operations with async API.
+ *
+ * @see {@link https://docs.python.org/3/library/shutil.html | Python shutil documentation}
+ * @module
+ */
+
+/**
+ * Copy the file src to the file or directory dst.
+ *
+ * @param src - Source file path
+ * @param dst - Destination file or directory path
+ * @returns The path to the newly created file
+ */
+declare function copy(src: string, dst: string): Promise<string>;
+/**
+ * Copy the file src to the file or directory dst, preserving metadata.
+ *
+ * @param src - Source file path
+ * @param dst - Destination file or directory path
+ * @returns The path to the newly created file
+ */
+declare function copy2(src: string, dst: string): Promise<string>;
+/**
+ * Recursively copy an entire directory tree.
+ *
+ * @param src - Source directory path
+ * @param dst - Destination directory path
+ * @param options - Options object
+ * @returns The destination directory path
+ */
+declare function copytree(src: string, dst: string, options?: {
+    symlinkss?: boolean;
+    ignore?: (dir: string, names: string[]) => string[];
+    copyFunction?: (src: string, dst: string) => Promise<void>;
+    dirsExistOk?: boolean;
+}): Promise<string>;
+/**
+ * Recursively move a file or directory to another location.
+ *
+ * @param src - Source path
+ * @param dst - Destination path
+ * @returns The destination path
+ */
+declare function move(src: string, dst: string): Promise<string>;
+/**
+ * Recursively delete a directory tree.
+ *
+ * @param path - Directory path to delete
+ * @param options - Options object
+ */
+declare function rmtree(path: string, options?: {
+    ignoreErrors?: boolean;
+}): Promise<void>;
+/**
+ * Return the path to an executable which would be run if the given cmd was called.
+ *
+ * @param cmd - Command name to find
+ * @param path - Optional PATH string to search (defaults to process.env.PATH)
+ * @returns Path to the executable, or null if not found
+ */
+declare function which(cmd: string, path?: string): Promise<string | null>;
+/**
+ * Disk usage statistics.
+ */
+interface DiskUsage {
+    total: number;
+    used: number;
+    free: number;
+}
+/**
+ * Return disk usage statistics for the given path.
+ *
+ * @param path - Path to check
+ * @returns Object with total, used, and free bytes
+ */
+declare function diskUsage(path: string): Promise<DiskUsage>;
+/**
+ * Return the size of the terminal window.
+ *
+ * @returns Object with columns and lines
+ */
+declare function getTerminalSize(): {
+    columns: number;
+    lines: number;
+};
+/**
+ * Copy file mode bits from src to dst.
+ *
+ * @param src - Source path
+ * @param dst - Destination path
+ */
+declare function copymode(src: string, dst: string): Promise<void>;
+/**
+ * Copy all stat info (mode bits, atime, mtime, flags) from src to dst.
+ *
+ * @param src - Source path
+ * @param dst - Destination path
+ */
+declare function copystat(src: string, dst: string): Promise<void>;
+/**
+ * Copy a file's content (but not metadata) to another file.
+ *
+ * @param src - Source file path
+ * @param dst - Destination file path
+ */
+declare function copyfile(src: string, dst: string): Promise<void>;
+/**
+ * Copy data from a file-like object to another file-like object.
+ *
+ * @param fsrc - Source readable stream
+ * @param fdst - Destination writable stream
+ * @param length - Number of bytes to copy (optional, copies all if not specified)
+ */
+declare function copyfileobj(fsrc: ReadStream | NodeJS.ReadableStream, fdst: WriteStream | NodeJS.WritableStream, length?: number): void;
+/**
+ * Create an archive file from a directory.
+ *
+ * Not implemented - requires external tools (tar, zip).
+ *
+ * @param baseName - Name of the archive file (without extension)
+ * @param format - Archive format ('zip', 'tar', 'gztar', 'bztar', 'xztar')
+ * @param rootDir - Directory to archive
+ * @returns Path to the created archive
+ */
+declare function makeArchive(_baseName: string, _format: string, _rootDir: string): string;
+/**
+ * Unpack an archive file.
+ *
+ * Not implemented - requires external tools (tar, unzip).
+ *
+ * @param filename - Path to the archive
+ * @param extractDir - Directory to extract to (optional)
+ */
+declare function unpackArchive(_filename: string, _extractDir?: string): void;
+
+type shutilModule_DiskUsage = DiskUsage;
+declare const shutilModule_copy: typeof copy;
+declare const shutilModule_copy2: typeof copy2;
+declare const shutilModule_copyfile: typeof copyfile;
+declare const shutilModule_copyfileobj: typeof copyfileobj;
+declare const shutilModule_copymode: typeof copymode;
+declare const shutilModule_copystat: typeof copystat;
+declare const shutilModule_copytree: typeof copytree;
+declare const shutilModule_diskUsage: typeof diskUsage;
+declare const shutilModule_getTerminalSize: typeof getTerminalSize;
+declare const shutilModule_makeArchive: typeof makeArchive;
+declare const shutilModule_move: typeof move;
+declare const shutilModule_rmtree: typeof rmtree;
+declare const shutilModule_unpackArchive: typeof unpackArchive;
+declare const shutilModule_which: typeof which;
+declare namespace shutilModule {
+  export { type shutilModule_DiskUsage as DiskUsage, shutilModule_copy as copy, shutilModule_copy2 as copy2, shutilModule_copyfile as copyfile, shutilModule_copyfileobj as copyfileobj, shutilModule_copymode as copymode, shutilModule_copystat as copystat, shutilModule_copytree as copytree, shutilModule_diskUsage as diskUsage, shutilModule_getTerminalSize as getTerminalSize, shutilModule_makeArchive as makeArchive, shutilModule_move as move, shutilModule_rmtree as rmtree, shutilModule_unpackArchive as unpackArchive, shutilModule_which as which };
+}
+
+export { type DiskUsage as D, copy2 as a, copytree as b, copy as c, diskUsage as d, copymode as e, copystat as f, getTerminalSize as g, copyfile as h, copyfileobj as i, makeArchive as j, move as m, rmtree as r, shutilModule as s, unpackArchive as u, which as w };

package/dist/shutil.node.d.ts

@@ -0,0 +1,2 @@
+import 'node:fs';
+export { D as DiskUsage, c as copy, a as copy2, h as copyfile, i as copyfileobj, e as copymode, f as copystat, b as copytree, d as diskUsage, g as getTerminalSize, j as makeArchive, m as move, r as rmtree, u as unpackArchive, w as which } from './shutil.node-C9kwvhAf.js';

package/dist/shutil.node.js

@@ -0,0 +1,33 @@
+import {
+  copy,
+  copy2,
+  copyfile,
+  copyfileobj,
+  copymode,
+  copystat,
+  copytree,
+  diskUsage,
+  getTerminalSize,
+  makeArchive,
+  move,
+  rmtree,
+  unpackArchive,
+  which
+} from "./chunk-B5AUEOAH.js";
+import "./chunk-MLKGABMK.js";
+export {
+  copy,
+  copy2,
+  copyfile,
+  copyfileobj,
+  copymode,
+  copystat,
+  copytree,
+  diskUsage,
+  getTerminalSize,
+  makeArchive,
+  move,
+  rmtree,
+  unpackArchive,
+  which
+};

package/dist/string.d.ts

@@ -1,9 +1,11 @@
 /**
  * Python string module for TypeScript
  *
- * Provides string constants and utility classes matching Python's string module.
+ * Provides string constants and utility classes matching Python's string module,
+ * including ascii_letters, digits, punctuation, and the Template class.
  *
  * @see {@link https://docs.python.org/3/library/string.html | Python string documentation}
+ * @module
  */
 /** The lowercase letters 'abcdefghijklmnopqrstuvwxyz' */
 declare const asciiLowercase = "abcdefghijklmnopqrstuvwxyz";

package/dist/string.js

@@ -11,8 +11,8 @@ import {
   punctuation,
   string,
   whitespace
-} from "./chunk-4QG3772L.js";
-import "./chunk-PZ5AY32C.js";
+} from "./chunk-LWYBTWBZ.js";
+import "./chunk-MLKGABMK.js";
 export {
   Template,
   asciiLetters,
@@ -27,4 +27,3 @@ export {
   string,
   whitespace
 };
-//# sourceMappingURL=string.js.map

package/dist/subprocess-CZVYzQ3V.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Python subprocess module for TypeScript
+ *
+ * Provides functions to spawn new processes and connect to their I/O.
+ *
+ * @see {@link https://docs.python.org/3/library/subprocess.html | Python subprocess documentation}
+ * @module
+ */
+/**
+ * Special constant to indicate that a pipe should be created.
+ */
+declare const PIPE: "pipe";
+/**
+ * Special constant to indicate that the subprocess's stderr should be redirected to stdout.
+ */
+declare const STDOUT: "stdout";
+/**
+ * Special constant to indicate that output should be discarded.
+ */
+declare const DEVNULL: "devnull";
+/**
+ * Result of a completed process.
+ */
+interface CompletedProcess {
+    /** The arguments used to launch the process */
+    args: string[];
+    /** Exit status of the process */
+    returncode: number;
+    /** Captured stdout (if PIPE was used) */
+    stdout: string | null;
+    /** Captured stderr (if PIPE was used) */
+    stderr: string | null;
+}
+/**
+ * Options for subprocess functions.
+ */
+interface SubprocessOptions {
+    /** Working directory for the command */
+    cwd?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Input to send to stdin */
+    input?: string | Uint8Array;
+    /** How to handle stdout */
+    stdout?: typeof PIPE | typeof DEVNULL | null;
+    /** How to handle stderr */
+    stderr?: typeof PIPE | typeof STDOUT | typeof DEVNULL | null;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Shell to use (if true, uses default shell) */
+    shell?: boolean | string;
+    /** Encoding for text mode (default: utf-8) */
+    encoding?: BufferEncoding;
+    /** Whether to capture output as text (default: true) */
+    text?: boolean;
+    /** Whether to raise CalledProcessError on non-zero exit */
+    check?: boolean;
+}
+/**
+ * Error thrown when a subprocess returns a non-zero exit code.
+ */
+declare class CalledProcessError extends Error {
+    readonly returncode: number;
+    readonly cmd: string[];
+    readonly stdout: string | null;
+    readonly stderr: string | null;
+    constructor(returncode: number, cmd: string[], stdout?: string | null, stderr?: string | null);
+}
+/**
+ * Error thrown when a subprocess times out.
+ */
+declare class TimeoutExpired extends Error {
+    readonly cmd: string[];
+    readonly timeout: number;
+    readonly stdout: string | null;
+    readonly stderr: string | null;
+    constructor(cmd: string[], timeout: number, stdout?: string | null, stderr?: string | null);
+}
+/**
+ * Run a command and wait for it to complete.
+ *
+ * @param args - Command and arguments (or a single string if shell=true)
+ * @param options - Subprocess options
+ * @returns CompletedProcess with exit code and captured output
+ *
+ * @example
+ * ```typescript
+ * // Run a simple command
+ * const result = run(["ls", "-la"])
+ *
+ * // Run with shell
+ * const result = run("echo hello && echo world", { shell: true })
+ *
+ * // Capture output
+ * const result = run(["git", "status"], { stdout: PIPE })
+ * console.log(result.stdout)
+ *
+ * // Check for errors
+ * const result = run(["false"], { check: true }) // Throws CalledProcessError
+ * ```
+ */
+declare function run(args: string[] | string, options?: SubprocessOptions): CompletedProcess;
+/**
+ * Run a command and return its exit code.
+ *
+ * @param args - Command and arguments
+ * @param options - Subprocess options
+ * @returns Exit code
+ */
+declare function call(args: string[] | string, options?: SubprocessOptions): number;
+/**
+ * Run a command and raise CalledProcessError if it returns non-zero.
+ *
+ * @param args - Command and arguments
+ * @param options - Subprocess options
+ * @returns Exit code (always 0 if no exception)
+ */
+declare function checkCall(args: string[] | string, options?: SubprocessOptions): number;
+/**
+ * Run a command and return its output, raising CalledProcessError if it returns non-zero.
+ *
+ * @param args - Command and arguments
+ * @param options - Subprocess options
+ * @returns Captured stdout
+ */
+declare function checkOutput(args: string[] | string, options?: SubprocessOptions): string;
+/**
+ * Get the output of a shell command (convenience function).
+ *
+ * @param cmd - Shell command to run
+ * @returns Command output as string
+ */
+declare function getoutput(cmd: string): string;
+/**
+ * Get the exit status and output of a shell command.
+ *
+ * @param cmd - Shell command to run
+ * @returns Tuple of [exit_status, output]
+ */
+declare function getstatusoutput(cmd: string): [number, string];
+/**
+ * A subprocess.Popen-like class for more control over process execution.
+ */
+declare class Popen {
+    readonly args: string[];
+    private readonly process;
+    private _returncode;
+    private _stdout;
+    private _stderr;
+    constructor(args: string[] | string, options?: SubprocessOptions);
+    /**
+     * Wait for the process to complete.
+     */
+    wait(): Promise<number>;
+    /**
+     * Get the exit code (or null if still running).
+     */
+    poll(): number | null;
+    /**
+     * Communicate with the process and return stdout/stderr.
+     */
+    communicate(input?: string | Uint8Array): Promise<[string | null, string | null]>;
+    /**
+     * Send a signal to the process.
+     */
+    send_signal(signal: number | NodeJS.Signals): boolean;
+    /**
+     * Terminate the process.
+     */
+    terminate(): boolean;
+    /**
+     * Kill the process.
+     */
+    kill(): boolean;
+    /**
+     * The process ID.
+     */
+    get pid(): number | undefined;
+    /**
+     * The exit code (or null if still running).
+     */
+    get returncode(): number | null;
+    /**
+     * The captured stdout.
+     */
+    get stdout(): string | null;
+    /**
+     * The captured stderr.
+     */
+    get stderr(): string | null;
+}
+
+type subprocessModule_CalledProcessError = CalledProcessError;
+declare const subprocessModule_CalledProcessError: typeof CalledProcessError;
+type subprocessModule_CompletedProcess = CompletedProcess;
+declare const subprocessModule_DEVNULL: typeof DEVNULL;
+declare const subprocessModule_PIPE: typeof PIPE;
+type subprocessModule_Popen = Popen;
+declare const subprocessModule_Popen: typeof Popen;
+declare const subprocessModule_STDOUT: typeof STDOUT;
+type subprocessModule_SubprocessOptions = SubprocessOptions;
+type subprocessModule_TimeoutExpired = TimeoutExpired;
+declare const subprocessModule_TimeoutExpired: typeof TimeoutExpired;
+declare const subprocessModule_call: typeof call;
+declare const subprocessModule_checkCall: typeof checkCall;
+declare const subprocessModule_checkOutput: typeof checkOutput;
+declare const subprocessModule_getoutput: typeof getoutput;
+declare const subprocessModule_getstatusoutput: typeof getstatusoutput;
+declare const subprocessModule_run: typeof run;
+declare namespace subprocessModule {
+  export { subprocessModule_CalledProcessError as CalledProcessError, type subprocessModule_CompletedProcess as CompletedProcess, subprocessModule_DEVNULL as DEVNULL, subprocessModule_PIPE as PIPE, subprocessModule_Popen as Popen, subprocessModule_STDOUT as STDOUT, type subprocessModule_SubprocessOptions as SubprocessOptions, subprocessModule_TimeoutExpired as TimeoutExpired, subprocessModule_call as call, subprocessModule_checkCall as checkCall, subprocessModule_checkOutput as checkOutput, subprocessModule_getoutput as getoutput, subprocessModule_getstatusoutput as getstatusoutput, subprocessModule_run as run };
+}
+
+export { type CompletedProcess as C, DEVNULL as D, PIPE as P, STDOUT as S, TimeoutExpired as T, type SubprocessOptions as a, CalledProcessError as b, call as c, checkCall as d, checkOutput as e, getstatusoutput as f, getoutput as g, Popen as h, run as r, subprocessModule as s };

package/dist/subprocess.d.ts

@@ -0,0 +1 @@
+export { b as CalledProcessError, C as CompletedProcess, D as DEVNULL, P as PIPE, h as Popen, S as STDOUT, a as SubprocessOptions, T as TimeoutExpired, c as call, d as checkCall, e as checkOutput, g as getoutput, f as getstatusoutput, r as run } from './subprocess-CZVYzQ3V.js';

package/dist/subprocess.js

@@ -0,0 +1,29 @@
+import {
+  CalledProcessError,
+  DEVNULL,
+  PIPE,
+  Popen,
+  STDOUT,
+  TimeoutExpired,
+  call,
+  checkCall,
+  checkOutput,
+  getoutput,
+  getstatusoutput,
+  run
+} from "./chunk-LLZFLQS6.js";
+import "./chunk-MLKGABMK.js";
+export {
+  CalledProcessError,
+  DEVNULL,
+  PIPE,
+  Popen,
+  STDOUT,
+  TimeoutExpired,
+  call,
+  checkCall,
+  checkOutput,
+  getoutput,
+  getstatusoutput,
+  run
+};