pythonlib 1.0.1 → 2.0.0

package/dist/chunk-5VAHUJNC.js

@@ -0,0 +1,348 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/logging.browser.ts
+var logging_browser_exports = {};
+__export(logging_browser_exports, {
+  CRITICAL: () => CRITICAL,
+  DEBUG: () => DEBUG,
+  ERROR: () => ERROR,
+  FATAL: () => FATAL,
+  FileHandler: () => FileHandler,
+  Formatter: () => Formatter,
+  Handler: () => Handler,
+  INFO: () => INFO,
+  Logger: () => Logger,
+  NOTSET: () => NOTSET,
+  StreamHandler: () => StreamHandler,
+  WARN: () => WARN,
+  WARNING: () => WARNING,
+  basicConfig: () => basicConfig,
+  critical: () => critical,
+  debug: () => debug,
+  disable: () => disable,
+  error: () => error,
+  exception: () => exception,
+  fatal: () => fatal,
+  getLevelName: () => getLevelName,
+  getLogger: () => getLogger,
+  info: () => info,
+  levelNames: () => levelNames,
+  log: () => log,
+  setLevel: () => setLevel,
+  shutdown: () => shutdown,
+  warn: () => warn,
+  warning: () => warning
+});
+var CRITICAL = 50;
+var FATAL = CRITICAL;
+var ERROR = 40;
+var WARNING = 30;
+var WARN = WARNING;
+var INFO = 20;
+var DEBUG = 10;
+var NOTSET = 0;
+var levelNames = {
+  [CRITICAL]: "CRITICAL",
+  [ERROR]: "ERROR",
+  [WARNING]: "WARNING",
+  [INFO]: "INFO",
+  [DEBUG]: "DEBUG",
+  [NOTSET]: "NOTSET"
+};
+function getLevelName(level) {
+  if (typeof level === "number") {
+    return levelNames[level] ?? `Level ${String(level)}`;
+  }
+  const upper = level.toUpperCase();
+  for (const [num, name] of Object.entries(levelNames)) {
+    if (name === upper) {
+      return parseInt(num, 10);
+    }
+  }
+  return level;
+}
+var Handler = class {
+  level = NOTSET;
+  formatter = null;
+  setLevel(level) {
+    this.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  format(record) {
+    if (this.formatter) {
+      return this.formatter.format(record);
+    }
+    return record.msg;
+  }
+  handle(record) {
+    if (record.levelno >= this.level) {
+      this.emit(record);
+    }
+  }
+};
+var StreamHandler = class extends Handler {
+  emit(record) {
+    const msg = this.format(record);
+    if (record.levelno >= ERROR) {
+      console.error(msg);
+    } else if (record.levelno >= WARNING) {
+      console.warn(msg);
+    } else if (record.levelno >= INFO) {
+      console.info(msg);
+    } else {
+      console.debug(msg);
+    }
+  }
+};
+var FileHandler = class extends Handler {
+  filename;
+  mode;
+  constructor(filename, mode = "a") {
+    super();
+    this.filename = filename;
+    this.mode = mode;
+  }
+  emit(record) {
+    const msg = this.format(record);
+    console.log(`[${this.filename}]`, msg);
+  }
+};
+var Formatter = class {
+  fmt;
+  datefmt;
+  constructor(fmt, datefmt) {
+    this.fmt = fmt ?? "%(levelname)s:%(name)s:%(message)s";
+    this.datefmt = datefmt ?? "%Y-%m-%d %H:%M:%S";
+  }
+  formatTime(record) {
+    const date = new Date(record.created * 1e3);
+    return this.datefmt.replace("%Y", String(date.getFullYear())).replace("%m", String(date.getMonth() + 1).padStart(2, "0")).replace("%d", String(date.getDate()).padStart(2, "0")).replace("%H", String(date.getHours()).padStart(2, "0")).replace("%M", String(date.getMinutes()).padStart(2, "0")).replace("%S", String(date.getSeconds()).padStart(2, "0"));
+  }
+  format(record) {
+    let msg = this.fmt.replace("%(name)s", record.name).replace("%(levelno)d", String(record.levelno)).replace("%(levelname)s", record.levelname).replace("%(message)s", record.msg).replace("%(asctime)s", this.formatTime(record));
+    if (record.filename) {
+      msg = msg.replace("%(filename)s", record.filename);
+    }
+    if (record.lineno !== void 0) {
+      msg = msg.replace("%(lineno)d", String(record.lineno));
+    }
+    if (record.funcName) {
+      msg = msg.replace("%(funcName)s", record.funcName);
+    }
+    return msg;
+  }
+};
+var Logger = class {
+  name;
+  level = NOTSET;
+  handlers = [];
+  parent = null;
+  propagate = true;
+  constructor(name) {
+    this.name = name;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  addHandler(handler) {
+    if (!this.handlers.includes(handler)) {
+      this.handlers.push(handler);
+    }
+  }
+  removeHandler(handler) {
+    const index = this.handlers.indexOf(handler);
+    if (index !== -1) {
+      this.handlers.splice(index, 1);
+    }
+  }
+  getEffectiveLevel() {
+    let logger = this;
+    while (logger) {
+      if (logger.level !== NOTSET) {
+        return logger.level;
+      }
+      logger = logger.parent;
+    }
+    return NOTSET;
+  }
+  isEnabledFor(level) {
+    return level >= this.getEffectiveLevel();
+  }
+  makeRecord(level, msg, args) {
+    let formattedMsg = msg;
+    if (args.length > 0) {
+      formattedMsg = msg.replace(/%[sdfo]/g, () => {
+        const arg = args.shift();
+        return String(arg);
+      });
+    }
+    return {
+      name: this.name,
+      levelno: level,
+      levelname: levelNames[level] ?? `Level ${String(level)}`,
+      msg: formattedMsg,
+      args,
+      created: Date.now() / 1e3
+    };
+  }
+  handle(record) {
+    for (const handler of this.handlers) {
+      handler.handle(record);
+    }
+    if (this.propagate && this.parent) {
+      this.parent.handle(record);
+    }
+  }
+  log(level, msg, ...args) {
+    if (this.isEnabledFor(level)) {
+      const record = this.makeRecord(level, msg, args);
+      this.handle(record);
+    }
+  }
+  debug(msg, ...args) {
+    this.log(DEBUG, msg, ...args);
+  }
+  info(msg, ...args) {
+    this.log(INFO, msg, ...args);
+  }
+  warning(msg, ...args) {
+    this.log(WARNING, msg, ...args);
+  }
+  warn(msg, ...args) {
+    this.warning(msg, ...args);
+  }
+  error(msg, ...args) {
+    this.log(ERROR, msg, ...args);
+  }
+  critical(msg, ...args) {
+    this.log(CRITICAL, msg, ...args);
+  }
+  fatal(msg, ...args) {
+    this.critical(msg, ...args);
+  }
+  exception(msg, ...args) {
+    this.error(msg, ...args);
+  }
+};
+var loggers = /* @__PURE__ */ new Map();
+var rootLogger = new Logger("root");
+rootLogger.setLevel(WARNING);
+function getLogger(name) {
+  if (!name) {
+    return rootLogger;
+  }
+  let logger = loggers.get(name);
+  if (!logger) {
+    logger = new Logger(name);
+    const parts = name.split(".");
+    if (parts.length > 1) {
+      const parentName = parts.slice(0, -1).join(".");
+      logger.parent = getLogger(parentName);
+    } else {
+      logger.parent = rootLogger;
+    }
+    loggers.set(name, logger);
+  }
+  return logger;
+}
+function basicConfig(options) {
+  if (rootLogger.handlers.length > 0 && !options?.handlers) {
+    return;
+  }
+  rootLogger.handlers = [];
+  if (options?.level !== void 0) {
+    rootLogger.setLevel(options.level);
+  }
+  const formatter = new Formatter(options?.format, options?.datefmt);
+  if (options?.handlers) {
+    for (const handler of options.handlers) {
+      handler.setFormatter(formatter);
+      rootLogger.addHandler(handler);
+    }
+  } else if (options?.filename) {
+    const handler = new FileHandler(options.filename, options.filemode);
+    handler.setFormatter(formatter);
+    rootLogger.addHandler(handler);
+  } else {
+    const handler = new StreamHandler();
+    handler.setFormatter(formatter);
+    rootLogger.addHandler(handler);
+  }
+}
+function debug(msg, ...args) {
+  rootLogger.debug(msg, ...args);
+}
+function info(msg, ...args) {
+  rootLogger.info(msg, ...args);
+}
+function warning(msg, ...args) {
+  rootLogger.warning(msg, ...args);
+}
+function warn(msg, ...args) {
+  rootLogger.warn(msg, ...args);
+}
+function error(msg, ...args) {
+  rootLogger.error(msg, ...args);
+}
+function critical(msg, ...args) {
+  rootLogger.critical(msg, ...args);
+}
+function fatal(msg, ...args) {
+  rootLogger.fatal(msg, ...args);
+}
+function exception(msg, ...args) {
+  rootLogger.exception(msg, ...args);
+}
+function log(level, msg, ...args) {
+  rootLogger.log(level, msg, ...args);
+}
+function setLevel(level) {
+  rootLogger.setLevel(level);
+}
+function disable(level = CRITICAL) {
+  rootLogger.setLevel(level + 1);
+}
+function shutdown() {
+  rootLogger.handlers = [];
+  for (const logger of loggers.values()) {
+    logger.handlers = [];
+  }
+  loggers.clear();
+}
+
+export {
+  CRITICAL,
+  FATAL,
+  ERROR,
+  WARNING,
+  WARN,
+  INFO,
+  DEBUG,
+  NOTSET,
+  levelNames,
+  getLevelName,
+  Handler,
+  StreamHandler,
+  FileHandler,
+  Formatter,
+  Logger,
+  getLogger,
+  basicConfig,
+  debug,
+  info,
+  warning,
+  warn,
+  error,
+  critical,
+  fatal,
+  exception,
+  log,
+  setLevel,
+  disable,
+  shutdown,
+  logging_browser_exports
+};

package/dist/chunk-B5AUEOAH.js

@@ -0,0 +1,193 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/shutil.node.ts
+var shutil_node_exports = {};
+__export(shutil_node_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
+});
+import { constants } from "fs";
+import {
+  access,
+  chmod,
+  copyFile,
+  lstat,
+  mkdir,
+  readdir,
+  readlink,
+  rename as fsRename,
+  rm,
+  stat,
+  statfs,
+  symlink,
+  unlink,
+  utimes
+} from "fs/promises";
+import { basename, delimiter, join } from "path";
+async function copy(src, dst) {
+  let finalDst = dst;
+  try {
+    if ((await stat(dst)).isDirectory()) {
+      finalDst = join(dst, basename(src));
+    }
+  } catch {
+  }
+  await copyFile(src, finalDst);
+  return finalDst;
+}
+async function copy2(src, dst) {
+  const finalDst = await copy(src, dst);
+  const srcStat = await stat(src);
+  await utimes(finalDst, srcStat.atime, srcStat.mtime);
+  return finalDst;
+}
+async function copytree(src, dst, options) {
+  const copyFunc = options?.copyFunction ?? (async (s, d) => {
+    await copy2(s, d);
+  });
+  const ignoreFunc = options?.ignore;
+  await mkdir(dst, { recursive: options?.dirsExistOk });
+  const entries = await readdir(src);
+  const ignoredNames = ignoreFunc ? ignoreFunc(src, entries) : [];
+  for (const entry of entries) {
+    if (ignoredNames.includes(entry)) {
+      continue;
+    }
+    const srcPath = join(src, entry);
+    const dstPath = join(dst, entry);
+    const entryStat = await lstat(srcPath);
+    if (entryStat.isDirectory()) {
+      await copytree(srcPath, dstPath, options);
+    } else if (entryStat.isSymbolicLink() && options?.symlinkss) {
+      const target = await readlink(srcPath);
+      await symlink(target, dstPath);
+    } else {
+      await copyFunc(srcPath, dstPath);
+    }
+  }
+  return dst;
+}
+async function move(src, dst) {
+  let finalDst = dst;
+  try {
+    if ((await stat(dst)).isDirectory()) {
+      finalDst = join(dst, basename(src));
+    }
+  } catch {
+  }
+  try {
+    await fsRename(src, finalDst);
+  } catch {
+    const srcStat = await stat(src);
+    if (srcStat.isDirectory()) {
+      await copytree(src, finalDst);
+      await rmtree(src);
+    } else {
+      await copy2(src, finalDst);
+      await unlink(src);
+    }
+  }
+  return finalDst;
+}
+async function rmtree(path, options) {
+  try {
+    await rm(path, { recursive: true, force: options?.ignoreErrors ?? false });
+  } catch (err) {
+    if (!options?.ignoreErrors) {
+      throw err;
+    }
+  }
+}
+async function which(cmd, path) {
+  const pathDirs = (path ?? process.env.PATH ?? "").split(delimiter);
+  const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat", ".com", ""] : [""];
+  for (const dir of pathDirs) {
+    for (const ext of extensions) {
+      const fullPath = join(dir, cmd + ext);
+      try {
+        await access(fullPath, constants.X_OK);
+        return fullPath;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+async function diskUsage(path) {
+  if (process.platform === "win32") {
+    throw new Error("diskUsage is not implemented on Windows");
+  }
+  const fsStat = await statfs(path);
+  const total = fsStat.blocks * fsStat.bsize;
+  const free = fsStat.bavail * fsStat.bsize;
+  return { total, used: total - free, free };
+}
+function getTerminalSize() {
+  const columns = process.stdout.columns ?? 80;
+  const lines = process.stdout.rows ?? 24;
+  return { columns, lines };
+}
+async function copymode(src, dst) {
+  const srcStat = await stat(src);
+  await chmod(dst, srcStat.mode);
+}
+async function copystat(src, dst) {
+  const srcStat = await stat(src);
+  await chmod(dst, srcStat.mode);
+  await utimes(dst, srcStat.atime, srcStat.mtime);
+}
+async function copyfile(src, dst) {
+  await copyFile(src, dst);
+}
+function copyfileobj(fsrc, fdst, length) {
+  if (length === void 0) {
+    ;
+    fsrc.pipe(fdst);
+  } else {
+    let remaining = length;
+    fsrc.on("data", (chunk) => {
+      if (remaining <= 0) return;
+      const toWrite = chunk.subarray(0, Math.min(chunk.length, remaining));
+      fdst.write(toWrite);
+      remaining -= toWrite.length;
+    });
+  }
+}
+function makeArchive(_baseName, _format, _rootDir) {
+  throw new Error("makeArchive is not implemented (requires external tools)");
+}
+function unpackArchive(_filename, _extractDir) {
+  throw new Error("unpackArchive is not implemented (requires external tools)");
+}
+
+export {
+  copy,
+  copy2,
+  copytree,
+  move,
+  rmtree,
+  which,
+  diskUsage,
+  getTerminalSize,
+  copymode,
+  copystat,
+  copyfile,
+  copyfileobj,
+  makeArchive,
+  unpackArchive,
+  shutil_node_exports
+};

package/dist/chunk-B5LQJODJ.js

@@ -0,0 +1,37 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/glob.browser.ts
+var glob_browser_exports = {};
+__export(glob_browser_exports, {
+  escape: () => escape,
+  glob: () => glob,
+  hasMagic: () => hasMagic,
+  iglob: () => iglob,
+  rglob: () => rglob
+});
+async function glob(_pattern, _options) {
+  return [];
+}
+async function* iglob(_pattern, _options) {
+}
+function escape(pathname) {
+  return pathname.replace(/([*?[])/g, "[$1]");
+}
+function hasMagic(pattern) {
+  return /[*?[\]]/.test(pattern);
+}
+async function rglob(_pattern, _rootDir = ".") {
+  return [];
+}
+
+export {
+  glob,
+  iglob,
+  escape,
+  hasMagic,
+  rglob,
+  glob_browser_exports
+};
+/* v8 ignore start -- browser stubs @preserve */

package/dist/{chunk-HQ42WNKZ.js → chunk-BCMGGBWG.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/itertools.ts
 var itertools_exports = {};
@@ -52,7 +52,7 @@ function combinations(iterable, r) {
 function permutations(iterable, r) {
   const pool = [...iterable];
   const n = pool.length;
-  const rLen = r === void 0 ? n : r;
+  const rLen = r ?? n;
   if (rLen > n || rLen < 0) return [];
   const result = [];
   const indices = Array.from({ length: n }, (_, i) => i);
@@ -60,7 +60,6 @@ function permutations(iterable, r) {
   result.push(indices.slice(0, rLen).map((i) => pool[i]));
   outer: for (; ; ) {
     for (let i = rLen - 1; i >= 0; i--) {
-      ;
       cycles[i]--;
       if (cycles[i] === 0) {
         const temp = indices[i];
@@ -92,7 +91,6 @@ function product(...iterables) {
   for (; ; ) {
     let i = pools.length - 1;
     while (i >= 0) {
-      ;
       indices[i]++;
       const currentPool = pools[i];
       if (indices[i] < currentPool.length) {
@@ -361,4 +359,3 @@ export {
   partition,
   itertools_exports
 };
-//# sourceMappingURL=chunk-HQ42WNKZ.js.map