pythonlib 1.0.1 → 2.0.0

package/dist/index.d.ts

@@ -1,438 +1,55 @@
-import { i as itertoolsModule } from './itertools-Sjl1LB_0.js';
-import { f as functoolsModule } from './functools-NrsZAqJk.js';
-import { c as collectionsModule } from './collections-CJur5Wg-.js';
-import { m as mathModule } from './math-DwEGjjQ-.js';
-import { r as randomModule } from './random-BJv_rSpL.js';
-import { j as jsonModule } from './json-DAlvCadU.js';
-import { o as osModule } from './os-C6Nt7Ijx.js';
-import { d as datetimeModule } from './datetime-Bpce8gG2.js';
-import { r as reModule } from './re-B1CHCgyr.js';
+import { i as itertoolsModule } from './itertools-T0rwOk2j.js';
+import { f as functoolsModule } from './functools-uIa5g75p.js';
+import { c as collectionsModule } from './collections-BthXtkEp.js';
+import { m as mathModule } from './math-D2NPMc-x.js';
+import { r as randomModule } from './random-DcS5jtEs.js';
+import { j as jsonModule } from './json-DoWhX04T.js';
+import { o as osModule } from './os.node-CQjch8Ht.js';
+import { d as datetimeModule } from './datetime-BM_IjhTq.js';
+import { r as reModule } from './re-Bo-IOqov.js';
 import { capWords, Template } from './string.js';
+import { s as sysModule } from './sys-IL8LgI_W.js';
+import { t as timeModule } from './time-CcYhdiSu.js';
+import { c as copyModule } from './copy-6ZaZ__ge.js';
+import { b as base64Module } from './base64-C_am75Sv.js';
+import { u as uuidModule } from './uuid-C0ypmn56.js';
+import { h as hashlibModule } from './hashlib-vKP511NY.js';
+import { p as pathlibModule } from './pathlib.node-CY3yUFdT.js';
+import { g as globModule } from './glob.node-wn5ehtyM.js';
+import { s as shutilModule } from './shutil.node-C9kwvhAf.js';
+import { t as tempfileModule } from './tempfile.node-bVMY60Cu.js';
+import { s as subprocessModule } from './subprocess-CZVYzQ3V.js';
+import { u as urllibModule } from './urllib-DJtkj-0f.js';
+import { l as loggingModule } from './logging.node-CH75bVdE.js';
+import { l as list$1, d as dict$1, s as set$1, f as floorDiv$1, m as mod$1, a as divMod$1, b as sprintf$1, c as strFormat$1, e as slice$1, g as at$1, h as contains$1, i as is$1, r as range$1, j as enumerate$1, z as zip$1, k as iter$1, n as reversed$1, o as sorted$1, p as map$1, q as filter$1, t as tuple$1, u as len$1, v as abs$1, w as min$1, x as max$1, y as sum$1, A as all$1, B as any$1, C as round$1, D as ord$1, E as chr$1, F as hex$1, G as oct$1, H as bin$1, I as int$1, J as float$1, K as str$1, L as repr$1, M as bool$1, N as ascii$1, O as isinstance$1, P as type$1, Q as input$1, R as format$1, S as getattr$1, T as hasattr$1, U as setattr$1 } from './set-JQbLAq8B.js';
+export { W as pow, V as repeatValue } from './set-JQbLAq8B.js';
+import './os.shared-C3x70nhO.js';
+import 'node:fs';
+import 'node:fs/promises';
 
 /**
- * Core Python operations for TypeScript
- * Arithmetic operations with Python semantics, slicing, etc.
- */
-/**
- * Floor division (Python //)
- * Always rounds towards negative infinity, unlike Math.floor for negatives
- */
-declare function floorDiv$1(a: number, b: number): number;
-/**
- * Power operator (Python **)
- */
-declare function pow(base: number, exp: number): number;
-/**
- * Modulo (Python %)
- * Python's % always returns a result with the same sign as the divisor
- */
-declare function mod$1(a: number, b: number): number;
-/**
- * Python divMod()
- */
-declare function divMod$1(a: number, b: number): [number, number];
-/**
- * Python %-style string formatting
- * Handles %s, %d, %i, %f, %r, %x, %o, etc.
- */
-declare function sprintf$1(template: string, args: unknown): string;
-/**
- * Python str.format() style string formatting
- * Handles {} positional and {name} named placeholders
- */
-declare function strFormat$1(template: string, ...args: unknown[]): string;
-/**
- * Python-style slice operation
- * Supports negative indices and step
- */
-declare function slice$1<T>(obj: string | T[], start?: number, stop?: number, step?: number): string | T[];
-/**
- * Python-style index access with support for negative indices
- */
-declare function at$1<T>(obj: string | T[], index: number): T | string;
-/**
- * Python-style string/array repetition
- */
-declare function repeat<T>(obj: string | T[], count: number): string | T[];
-/**
- * Python 'in' operator
- */
-declare function contains$1<T>(item: T, container: Iterable<T> | string | Map<T, unknown> | Set<T>): boolean;
-/**
- * Python 'is' operator (identity comparison)
- */
-declare function is$1(a: unknown, b: unknown): boolean;
-
-/**
- * Python built-in functions for TypeScript
- *
- * Provides core Python built-in functions like len, range, enumerate, sorted, min, max, etc.
- *
- * @see {@link https://docs.python.org/3/library/functions.html | Python built-in functions documentation}
- */
-/**
- * Python range() function
- */
-declare function range$1(startOrStop: number, stop?: number, step?: number): Iterable<number>;
-/**
- * Python enumerate() function
- */
-declare function enumerate$1<T>(iterable: Iterable<T>, start?: number): Iterable<[number, T]>;
-/**
- * Python zip() function
- */
-declare function zip$1<T extends unknown[][]>(...iterables: {
-    [K in keyof T]: Iterable<T[K]>;
-}): Iterable<T>;
-/**
- * Safe iteration helper for for-in loops
- */
-declare function iter$1<T>(obj: Iterable<T> | Record<string, unknown> | null | undefined): Iterable<T> | string[];
-/**
- * Python reversed() function
- */
-declare function reversed$1<T>(iterable: Iterable<T>): Iterable<T>;
-/**
- * Python sorted() function
- */
-declare function sorted$1<T>(iterable: Iterable<T>, options?: {
-    key?: (x: T) => unknown;
-    reverse?: boolean;
-}): T[];
-/**
- * Python map() function
- */
-declare function map$1<T, U>(fn: (x: T) => U, iterable: Iterable<T>): Iterable<U>;
-/**
- * Python filter() function
- */
-declare function filter$1<T>(fn: ((x: T) => boolean) | null, iterable: Iterable<T>): Iterable<T>;
-/**
- * Create a tuple (readonly array)
- */
-declare function tuple$1<T extends unknown[]>(...items: T): Readonly<T>;
-/**
- * Python len() function
- */
-declare function len$1(obj: string | unknown[] | Map<unknown, unknown> | Set<unknown> | {
-    length: number;
-}): number;
-/**
- * Python abs() function
- */
-declare function abs$1(x: number): number;
-/**
- * Python min() function
- */
-declare function min$1<T>(...args: T[] | [Iterable<T>]): T;
-/**
- * Python max() function
- */
-declare function max$1<T>(...args: T[] | [Iterable<T>]): T;
-/**
- * Python sum() function
- */
-declare function sum$1(iterable: Iterable<number>, start?: number): number;
-/**
- * Python all() function
- */
-declare function all$1(iterable: Iterable<unknown>): boolean;
-/**
- * Python any() function
- */
-declare function any$1(iterable: Iterable<unknown>): boolean;
-/**
- * Python round() function
- */
-declare function round$1(number: number, ndigits?: number): number;
-/**
- * Python ord()
- */
-declare function ord$1(char: string): number;
-/**
- * Python chr()
- */
-declare function chr$1(code: number): string;
-/**
- * Python hex()
- */
-declare function hex$1(x: number): string;
-/**
- * Python oct()
- */
-declare function oct$1(x: number): string;
-/**
- * Python bin()
- */
-declare function bin$1(x: number): string;
-/**
- * Python int() function
- */
-declare function int$1(x: string | number | boolean, base?: number): number;
-/**
- * Python float() function
- */
-declare function float$1(x: string | number): number;
-/**
- * Python str() function
- */
-declare function str$1(x: unknown): string;
-/**
- * Python repr() function
- */
-declare function repr$1(x: unknown): string;
-/**
- * Python bool() function
- */
-declare function bool$1(x: unknown): boolean;
-/**
- * Python ascii() - returns ASCII representation
- */
-declare function ascii$1(x: unknown): string;
-/**
- * Python isinstance() - simplified version
- */
-declare function isinstance$1(obj: unknown, classInfo: unknown): boolean;
-/**
- * Python type() - simplified version
- */
-declare function type$1(obj: unknown): string;
-/**
- * Python input() - for Node.js
- */
-declare function input$1(prompt?: string): string;
-/**
- * Python format() - formats a value according to format spec
- */
-declare function format$1(value: unknown, spec: string): string;
-/**
- * Python getattr() function - get an attribute from an object
+ * Python Built-in Functions for TypeScript
  *
- * @param obj - The object to get the attribute from
- * @param name - The name of the attribute
- * @param defaultValue - Optional default value if attribute doesn't exist
- * @returns The attribute value or default value
- */
-declare function getattr$1<T>(obj: unknown, name: string, defaultValue?: T): T | undefined;
-/**
- * Python hasattr() function - check if an object has an attribute
- *
- * @param obj - The object to check
- * @param name - The name of the attribute
- * @returns True if the attribute exists, false otherwise
- */
-declare function hasattr$1(obj: unknown, name: string): boolean;
-/**
- * Python setattr() function - set an attribute on an object
- *
- * @param obj - The object to set the attribute on
- * @param name - The name of the attribute
- * @param value - The value to set
- */
-declare function setattr$1(obj: unknown, name: string, value: unknown): void;
-
-/**
- * Python list methods for TypeScript
- * Usage: py.list.remove(), py.list.sort(), etc.
- */
-declare const list$1: {
-    /**
-     * Python list.append() - modifies array in place
-     */
-    append<T>(arr: T[], item: T): void;
-    /**
-     * Python list.extend() - modifies array in place
-     */
-    extend<T>(arr: T[], items: Iterable<T>): void;
-    /**
-     * Python list.insert() - modifies array in place
-     */
-    insert<T>(arr: T[], index: number, item: T): void;
-    /**
-     * Python list.remove() - removes first occurrence, modifies in place
-     */
-    remove<T>(arr: T[], value: T): void;
-    /**
-     * Python list.pop() - removes and returns item at index
-     */
-    pop<T>(arr: T[], index?: number): T;
-    /**
-     * Python list.clear() - removes all items
-     */
-    clear(arr: unknown[]): void;
-    /**
-     * Python list.index() - finds first occurrence
-     */
-    index<T>(arr: T[], value: T, start?: number, end?: number): number;
-    /**
-     * Python list.count() - counts occurrences
-     */
-    count<T>(arr: T[], value: T): number;
-    /**
-     * Python list.sort() with key function - modifies in place
-     */
-    sort<T>(arr: T[], options?: {
-        key?: (x: T) => unknown;
-        reverse?: boolean;
-    }): void;
-    /**
-     * Python list.reverse() - reverses in place
-     */
-    reverse(arr: unknown[]): void;
-    /**
-     * Python list.copy() - shallow copy
-     */
-    copy<T>(arr: T[]): T[];
-    /**
-     * Python slice assignment: arr[start:end:step] = values
-     * Replaces a slice of the array with new values, modifying in place
-     */
-    sliceAssign<T>(arr: T[], start: number | undefined, end: number | undefined, step: number | undefined, values: T[]): void;
-};
-
-/**
- * Python dict methods for TypeScript
- * Usage: py.dict.get(), py.dict.keys(), etc.
- */
-declare const dict$1: {
-    /**
-     * Python dict.get() - get value with optional default
-     */
-    get<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, defaultValue?: V): V | undefined;
-    /**
-     * Python dict.setDefault() - get value or set default
-     */
-    setDefault<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, defaultValue: V): V;
-    /**
-     * Python dict.pop() - remove and return value
-     */
-    pop<K extends string | number | symbol, V>(obj: Record<K, V>, key: K, defaultValue?: V): V | undefined;
-    /**
-     * Python dict.popItem() - remove and return last item
-     */
-    popItem<K extends string | number | symbol, V>(obj: Record<K, V>): [K, V];
-    /**
-     * Python dict.update() - update with another dict
-     */
-    update<K extends string | number | symbol, V>(obj: Record<K, V>, other: Record<K, V> | Iterable<[K, V]>): void;
-    /**
-     * Python dict.clear() - remove all items
-     */
-    clear<K extends string | number | symbol, V>(obj: Record<K, V>): void;
-    /**
-     * Python dict.copy() - shallow copy
-     */
-    copy<K extends string | number | symbol, V>(obj: Record<K, V>): Record<K, V>;
-    /**
-     * Python dict.keys() - returns iterable of keys
-     */
-    keys<K extends string | number | symbol, V>(obj: Record<K, V>): K[];
-    /**
-     * Python dict.values() - returns iterable of values
-     */
-    values<K extends string | number | symbol, V>(obj: Record<K, V>): V[];
-    /**
-     * Python dict.items() - returns iterable of [key, value] pairs
-     */
-    items<K extends string | number | symbol, V>(obj: Record<K, V>): [K, V][];
-    /**
-     * Python dict.fromKeys() - create dict from keys
-     */
-    fromKeys<K extends string | number | symbol, V>(keys: K[], value?: V): Record<K, V | undefined>;
-};
-
-/**
- * Python set methods for TypeScript
- * Usage: py.set.intersection(), py.set.union(), etc.
- */
-declare const set$1: {
-    /**
-     * Python set.add() - add element
-     */
-    add<T>(s: Set<T>, item: T): void;
-    /**
-     * Python set.remove() - remove element, raises error if not found
-     */
-    remove<T>(s: Set<T>, item: T): void;
-    /**
-     * Python set.discard() - remove element if present
-     */
-    discard<T>(s: Set<T>, item: T): void;
-    /**
-     * Python set.pop() - remove and return arbitrary element
-     */
-    pop<T>(s: Set<T>): T;
-    /**
-     * Python set.clear() - remove all elements
-     */
-    clear<T>(s: Set<T>): void;
-    /**
-     * Python set.copy() - shallow copy
-     */
-    copy<T>(s: Set<T>): Set<T>;
-    /**
-     * Python set.update() - add elements from iterable
-     */
-    update<T>(s: Set<T>, ...iterables: Iterable<T>[]): void;
-    /**
-     * Python set.union() - returns new set with all elements
-     */
-    union<T>(a: Set<T>, ...others: Iterable<T>[]): Set<T>;
-    /**
-     * Python set.intersection() - returns new set with common elements
-     */
-    intersection<T>(a: Set<T>, b: Set<T>): Set<T>;
-    /**
-     * Python set.intersection_update() - keep only common elements
-     */
-    intersectionUpdate<T>(a: Set<T>, b: Set<T>): void;
-    /**
-     * Python set.difference() - returns new set with elements in a but not in b
-     */
-    difference<T>(a: Set<T>, b: Set<T>): Set<T>;
-    /**
-     * Python set.difference_update() - remove elements found in b
-     */
-    differenceUpdate<T>(a: Set<T>, b: Set<T>): void;
-    /**
-     * Python set.symmetric_difference() - returns new set with elements in either but not both
-     */
-    symmetricDifference<T>(a: Set<T>, b: Set<T>): Set<T>;
-    /**
-     * Python set.symmetric_difference_update() - update with symmetric difference
-     */
-    symmetricDifferenceUpdate<T>(a: Set<T>, b: Set<T>): void;
-    /**
-     * Python set.isSubset() - test if all elements are in other
-     */
-    isSubset<T>(a: Set<T>, b: Set<T>): boolean;
-    /**
-     * Python set.isSuperset() - test if all other elements are in this set
-     */
-    isSuperset<T>(a: Set<T>, b: Set<T>): boolean;
-    /**
-     * Python set.isDisjoint() - test if no common elements
-     */
-    isDisjoint<T>(a: Set<T>, b: Set<T>): boolean;
-};
-
-/**
- * Python Runtime Library for TypeScript
+ * This module provides Python's built-in functions that are always available
+ * without imports. These are the fundamental operations for working with data
+ * in Python, including iteration (range, enumerate, zip), aggregation (len,
+ * sum, min, max), type conversion (int, str, bool), and more.
  *
- * Import styles:
+ * @example
+ * ```typescript
+ * // Direct imports
+ * import { len, range, sorted, min, max } from "pythonlib"
  *
- * 1. Builtins (global Python functions):
- *    import { len, range, sorted, min, max } from "pythonlib"
+ * // Module imports (like Python)
+ * import { chain, combinations } from "pythonlib/itertools"
+ * import { Counter, defaultdict } from "pythonlib/collections"
  *
- * 2. Module imports (like Python):
- *    import { dump, loads } from "pythonlib/json"
- *    import { match, search, sub } from "pythonlib/re"
- *    import { chain, combinations } from "pythonlib/itertools"
- *    import { Counter, defaultdict } from "pythonlib/collections"
+ * // Module namespaces
+ * import { json, re, itertools } from "pythonlib"
+ * ```
  *
- * 3. Module namespaces (alternative):
- *    import { json, re, itertools } from "pythonlib"
- *    json.dump(...), re.match(...), itertools.chain(...)
+ * @see {@link https://docs.python.org/3/library/functions.html | Python Built-in Functions}
+ * @module
  */
 
 declare const itertools: typeof itertoolsModule;
@@ -489,15 +106,22 @@ declare const string: {
     isLower(s: string): boolean;
     format(s: string, ...args: unknown[]): string;
 };
-type ListConstructor = {
-    <T>(iterable?: Iterable<T>): T[];
-} & typeof list$1;
-type DictConstructor = {
-    <K, V>(entries?: Iterable<[K, V]>): Map<K, V>;
-} & typeof dict$1;
-type SetConstructor = {
-    <T>(iterable?: Iterable<T>): Set<T>;
-} & typeof set$1;
+declare const sys: typeof sysModule;
+declare const time: typeof timeModule;
+declare const copy: typeof copyModule;
+declare const base64: typeof base64Module;
+declare const uuid: typeof uuidModule;
+declare const hashlib: typeof hashlibModule;
+declare const pathlib: typeof pathlibModule;
+declare const glob: typeof globModule;
+declare const shutil: typeof shutilModule;
+declare const tempfile: typeof tempfileModule;
+declare const subprocess: typeof subprocessModule;
+declare const urllib: typeof urllibModule;
+declare const logging: typeof loggingModule;
+type ListConstructor = (<T>(iterable?: Iterable<T>) => T[]) & typeof list$1;
+type DictConstructor = (<K, V>(entries?: Iterable<[K, V]>) => Map<K, V>) & typeof dict$1;
+type SetConstructor = (<T>(iterable?: Iterable<T>) => Set<T>) & typeof set$1;
 declare const list: ListConstructor;
 declare const dict: DictConstructor;
 declare const set: SetConstructor;
@@ -547,4 +171,4 @@ declare const getattr: typeof getattr$1;
 declare const hasattr: typeof hasattr$1;
 declare const setattr: typeof setattr$1;
 
-export { abs, all, any, ascii, at, bin, bool, chr, collections, contains, datetime, dict, divMod, enumerate, filter, float, floorDiv, format, functools, getattr, hasattr, hex, input, int, is, isinstance, iter, itertools, json, len, list, map, math, max, min, mod, oct, ord, os, pow, random, range, re, repeat as repeatValue, repr, reversed, round, set, setattr, slice, sorted, sprintf, str, strFormat, string, sum, tuple, type, zip };
+export { abs, all, any, ascii, at, base64, bin, bool, chr, collections, contains, copy, datetime, dict, divMod, enumerate, filter, float, floorDiv, format, functools, getattr, glob, hasattr, hashlib, hex, input, int, is, isinstance, iter, itertools, json, len, list, logging, map, math, max, min, mod, oct, ord, os, pathlib, random, range, re, repr, reversed, round, set, setattr, shutil, slice, sorted, sprintf, str, strFormat, string, subprocess, sum, sys, tempfile, time, tuple, type, urllib, uuid, zip };