pythonlib 0.1.0

package/dist/functools.d.ts

@@ -0,0 +1 @@
+export { b as attrgetter, c as cache, e as cmp_to_key, d as identity, i as itemgetter, l as lru_cache, m as methodcaller, p as partial, a as partialmethod, r as reduce, s as singledispatch, t as total_ordering, w as wraps } from './functools-St5GqpKG.js';

package/dist/functools.js

@@ -0,0 +1,32 @@
+import {
+  attrgetter,
+  cache,
+  cmp_to_key,
+  identity,
+  itemgetter,
+  lru_cache,
+  methodcaller,
+  partial,
+  partialmethod,
+  reduce,
+  singledispatch,
+  total_ordering,
+  wraps
+} from "./chunk-OMQNGE6T.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  attrgetter,
+  cache,
+  cmp_to_key,
+  identity,
+  itemgetter,
+  lru_cache,
+  methodcaller,
+  partial,
+  partialmethod,
+  reduce,
+  singledispatch,
+  total_ordering,
+  wraps
+};
+//# sourceMappingURL=functools.js.map

package/dist/functools.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,624 @@
+import { i as itertoolsModule } from './itertools-Bj8XivI6.js';
+import { f as functoolsModule } from './functools-St5GqpKG.js';
+import { C as Counter, d as defaultdict, a as deque, c as collectionsModule } from './collections-xN9Gi0TA.js';
+import { m as mathModule } from './math-BrT4Aw3E.js';
+import { r as randomModule } from './random-D5S5iSV3.js';
+import { j as jsonModule } from './json-Xpk0kwSd.js';
+import { o as osModule } from './os-FRSJbEUH.js';
+import { d as datetimeModule } from './datetime-DRwFAiGV.js';
+import { r as reModule } from './re-DSxiURqN.js';
+import { Template, capwords } from './string.js';
+
+/**
+ * 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
+ * len, range, enumerate, sorted, min, max, etc.
+ */
+
+/**
+ * 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 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
+ *
+ * Import styles:
+ *
+ * 1. Builtins (global Python functions):
+ *    import { len, range, sorted, min, max } from "pythonlib"
+ *
+ * 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"
+ *
+ * 3. Module namespaces (alternative):
+ *    import { json, re, itertools } from "pythonlib"
+ *    json.dump(...), re.match(...), itertools.chain(...)
+ */
+
+declare const itertools: typeof itertoolsModule;
+declare const functools: typeof functoolsModule;
+declare const collections: typeof collectionsModule;
+declare const math: typeof mathModule;
+declare const random: typeof randomModule;
+declare const json: typeof jsonModule;
+declare const os: typeof osModule;
+declare const datetime: typeof datetimeModule;
+declare const re: typeof reModule;
+declare const string: {
+    ascii_lowercase: string;
+    ascii_uppercase: string;
+    ascii_letters: string;
+    digits: string;
+    hexdigits: string;
+    octdigits: string;
+    punctuation: string;
+    whitespace: string;
+    printable: string;
+    capwords: typeof capwords;
+    Template: typeof Template;
+    join(sep: string, iterable: Iterable<string>): string;
+    split(s: string, sep?: string, maxsplit?: number): string[];
+    rsplit(s: string, sep?: string, maxsplit?: number): string[];
+    strip(s: string, chars?: string): string;
+    lstrip(s: string, chars?: string): string;
+    rstrip(s: string, chars?: string): string;
+    upper(s: string): string;
+    lower(s: string): string;
+    capitalize(s: string): string;
+    title(s: string): string;
+    swapcase(s: string): string;
+    startswith(s: string, prefix: string, start?: number, end?: number): boolean;
+    endswith(s: string, suffix: string, start?: number, end?: number): boolean;
+    find(s: string, sub: string, start?: number, end?: number): number;
+    rfind(s: string, sub: string, start?: number, end?: number): number;
+    index(s: string, sub: string, start?: number, end?: number): number;
+    rindex(s: string, sub: string, start?: number, end?: number): number;
+    count(s: string, sub: string, start?: number, end?: number): number;
+    replace(s: string, old: string, newStr: string, count?: number): string;
+    zfill(s: string, width: number): string;
+    center(s: string, width: number, fillchar?: string): string;
+    ljust(s: string, width: number, fillchar?: string): string;
+    rjust(s: string, width: number, fillchar?: string): string;
+    partition(s: string, sep: string): [string, string, string];
+    rpartition(s: string, sep: string): [string, string, string];
+    isalpha(s: string): boolean;
+    isdigit(s: string): boolean;
+    isalnum(s: string): boolean;
+    isspace(s: string): boolean;
+    isupper(s: string): boolean;
+    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 list: ListConstructor;
+declare const dict: DictConstructor;
+declare const set: SetConstructor;
+declare const floordiv: typeof floordiv$1;
+declare const mod: typeof mod$1;
+declare const divmod: typeof divmod$1;
+declare const sprintf: typeof sprintf$1;
+declare const strFormat: typeof strFormat$1;
+declare const slice: typeof slice$1;
+declare const at: typeof at$1;
+declare const contains: typeof contains$1;
+declare const is: typeof is$1;
+
+declare const range: typeof range$1;
+declare const enumerate: typeof enumerate$1;
+declare const zip: typeof zip$1;
+declare const iter: typeof iter$1;
+declare const reversed: typeof reversed$1;
+declare const sorted: typeof sorted$1;
+declare const map: typeof map$1;
+declare const filter: typeof filter$1;
+declare const tuple: typeof tuple$1;
+declare const len: typeof len$1;
+declare const abs: typeof abs$1;
+declare const min: typeof min$1;
+declare const max: typeof max$1;
+declare const sum: typeof sum$1;
+declare const all: typeof all$1;
+declare const any: typeof any$1;
+declare const round: typeof round$1;
+declare const ord: typeof ord$1;
+declare const chr: typeof chr$1;
+declare const hex: typeof hex$1;
+declare const oct: typeof oct$1;
+declare const bin: typeof bin$1;
+declare const int: typeof int$1;
+declare const float: typeof float$1;
+declare const str: typeof str$1;
+declare const repr: typeof repr$1;
+declare const bool: typeof bool$1;
+declare const ascii: typeof ascii$1;
+declare const isinstance: typeof isinstance$1;
+declare const type: typeof type$1;
+declare const input: typeof input$1;
+declare const format: typeof format$1;
+declare const py: {
+    string: {
+        join(sep: string, iterable: Iterable<string>): string;
+        split(s: string, sep?: string, maxsplit?: number): string[];
+        rsplit(s: string, sep?: string, maxsplit?: number): string[];
+        strip(s: string, chars?: string): string;
+        lstrip(s: string, chars?: string): string;
+        rstrip(s: string, chars?: string): string;
+        upper(s: string): string;
+        lower(s: string): string;
+        capitalize(s: string): string;
+        title(s: string): string;
+        swapcase(s: string): string;
+        startswith(s: string, prefix: string, start?: number, end?: number): boolean;
+        endswith(s: string, suffix: string, start?: number, end?: number): boolean;
+        find(s: string, sub: string, start?: number, end?: number): number;
+        rfind(s: string, sub: string, start?: number, end?: number): number;
+        index(s: string, sub: string, start?: number, end?: number): number;
+        rindex(s: string, sub: string, start?: number, end?: number): number;
+        count(s: string, sub: string, start?: number, end?: number): number;
+        replace(s: string, old: string, newStr: string, count?: number): string;
+        zfill(s: string, width: number): string;
+        center(s: string, width: number, fillchar?: string): string;
+        ljust(s: string, width: number, fillchar?: string): string;
+        rjust(s: string, width: number, fillchar?: string): string;
+        partition(s: string, sep: string): [string, string, string];
+        rpartition(s: string, sep: string): [string, string, string];
+        isalpha(s: string): boolean;
+        isdigit(s: string): boolean;
+        isalnum(s: string): boolean;
+        isspace(s: string): boolean;
+        isupper(s: string): boolean;
+        islower(s: string): boolean;
+        format(s: string, ...args: unknown[]): string;
+    };
+    list: ListConstructor;
+    dict: DictConstructor;
+    set: SetConstructor;
+    floordiv: typeof floordiv$1;
+    pow: typeof pow;
+    mod: typeof mod$1;
+    divmod: typeof divmod$1;
+    sprintf: typeof sprintf$1;
+    strFormat: typeof strFormat$1;
+    slice: typeof slice$1;
+    at: typeof at$1;
+    repeat: typeof repeat;
+    in: typeof contains$1;
+    is: typeof is$1;
+    range: typeof range$1;
+    enumerate: typeof enumerate$1;
+    zip: typeof zip$1;
+    iter: typeof iter$1;
+    reversed: typeof reversed$1;
+    sorted: typeof sorted$1;
+    map: typeof map$1;
+    filter: typeof filter$1;
+    tuple: typeof tuple$1;
+    len: typeof len$1;
+    abs: typeof abs$1;
+    min: typeof min$1;
+    max: typeof max$1;
+    sum: typeof sum$1;
+    all: typeof all$1;
+    any: typeof any$1;
+    round: typeof round$1;
+    ord: typeof ord$1;
+    chr: typeof chr$1;
+    hex: typeof hex$1;
+    oct: typeof oct$1;
+    bin: typeof bin$1;
+    int: typeof int$1;
+    float: typeof float$1;
+    str: typeof str$1;
+    repr: typeof repr$1;
+    bool: typeof bool$1;
+    ascii: typeof ascii$1;
+    isinstance: typeof isinstance$1;
+    type: typeof type$1;
+    input: typeof input$1;
+    format: typeof format$1;
+    itertools: typeof itertoolsModule;
+    functools: typeof functoolsModule;
+    math: typeof mathModule;
+    random: typeof randomModule;
+    json: typeof jsonModule;
+    os: typeof osModule;
+    datetime: typeof datetimeModule;
+    re: typeof reModule;
+    Counter: typeof Counter;
+    defaultdict: typeof defaultdict;
+    deque: typeof deque;
+    Template: typeof Template;
+    ascii_lowercase: string;
+    ascii_uppercase: string;
+    ascii_letters: string;
+    digits: string;
+    hexdigits: string;
+    octdigits: string;
+    punctuation: string;
+    whitespace: string;
+    printable: string;
+    capwords: typeof capwords;
+};
+
+export { abs, all, any, ascii, at, bin, bool, chr, collections, contains, datetime, py as default, dict, divmod, enumerate, filter, float, floordiv, format, functools, hex, input, int, is, isinstance, iter, itertools, json, len, list, map, math, max, min, mod, oct, ord, os, pow, py, random, range, re, repeat as repeatValue, repr, reversed, round, set, slice, sorted, sprintf, str, strFormat, string, sum, tuple, type, zip };