pythonlib 1.0.2 → 2.0.0

package/dist/chunk-OZRS5PC4.js

@@ -0,0 +1,312 @@
+import {
+  altSep,
+  chdir,
+  curDir,
+  environ,
+  extSep,
+  getCwd,
+  getCwdb,
+  getenv,
+  lineSep,
+  name,
+  parDir,
+  pathBasename,
+  pathCommonPath,
+  pathDirname,
+  pathExpandUser,
+  pathExpandVars,
+  pathExtName,
+  pathIsAbs,
+  pathJoin,
+  pathNormPath,
+  pathRelPath,
+  pathSep,
+  pathSplitExt,
+  pathSplitFn,
+  sep
+} from "./chunk-LHPQS75Z.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/os.node.ts
+var os_node_exports = {};
+__export(os_node_exports, {
+  altSep: () => altSep,
+  chdir: () => chdir,
+  curDir: () => curDir,
+  environ: () => environ,
+  extSep: () => extSep,
+  getCwd: () => getCwd,
+  getCwdb: () => getCwdb,
+  getenv: () => getenv,
+  lineSep: () => lineSep,
+  listDir: () => listDir,
+  makeDirs: () => makeDirs,
+  mkdir: () => mkdir,
+  name: () => name,
+  parDir: () => parDir,
+  path: () => path,
+  pathBasename: () => pathBasename,
+  pathCommonPath: () => pathCommonPath,
+  pathDirname: () => pathDirname,
+  pathExpandUser: () => pathExpandUser,
+  pathExpandVars: () => pathExpandVars,
+  pathExtName: () => pathExtName,
+  pathIsAbs: () => pathIsAbs,
+  pathJoin: () => pathJoin,
+  pathNormPath: () => pathNormPath,
+  pathRelPath: () => pathRelPath,
+  pathSep: () => pathSep,
+  pathSplitExt: () => pathSplitExt,
+  pathSplitFn: () => pathSplitFn,
+  remove: () => remove,
+  removeDirs: () => removeDirs,
+  rename: () => rename,
+  renames: () => renames,
+  replace: () => replace,
+  rmdir: () => rmdir,
+  sep: () => sep,
+  stat: () => stat,
+  unlink: () => unlink,
+  walk: () => walk
+});
+import {
+  access,
+  lstat,
+  mkdir as fsMkdir,
+  readdir,
+  realpath,
+  rename as fsRename,
+  rmdir as fsRmdir,
+  stat as fsStat,
+  unlink as fsUnlink
+} from "fs/promises";
+import { join } from "path";
+var path = {
+  join: pathJoin,
+  basename: pathBasename,
+  dirname: pathDirname,
+  split: pathSplitFn,
+  splitExt: pathSplitExt,
+  extName: pathExtName,
+  isAbs: pathIsAbs,
+  normPath: pathNormPath,
+  relPath: pathRelPath,
+  commonPath: pathCommonPath,
+  expandUser: pathExpandUser,
+  expandVars: pathExpandVars,
+  /** Return normalized absolutized version of pathname */
+  absPath(p) {
+    if (pathIsAbs(p)) {
+      return pathNormPath(p);
+    }
+    return pathNormPath(pathJoin(getCwd(), p));
+  },
+  /** Return canonical path, eliminating symlinks */
+  async realPath(p) {
+    try {
+      return await realpath(p);
+    } catch {
+      return path.absPath(p);
+    }
+  },
+  /** Test if path exists */
+  async exists(p) {
+    try {
+      await access(p);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  /** Test if path is a file */
+  async isFile(p) {
+    try {
+      return (await fsStat(p)).isFile();
+    } catch {
+      return false;
+    }
+  },
+  /** Test if path is a directory */
+  async isDir(p) {
+    try {
+      return (await fsStat(p)).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  /** Test if path is a symbolic link */
+  async isLink(p) {
+    try {
+      return (await lstat(p)).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  },
+  /** Return size of file */
+  async getSize(p) {
+    try {
+      return (await fsStat(p)).size;
+    } catch {
+      return 0;
+    }
+  },
+  /** Return modification time as Unix timestamp */
+  async getMtime(p) {
+    try {
+      return Math.floor((await fsStat(p)).mtimeMs / 1e3);
+    } catch {
+      return 0;
+    }
+  },
+  /** Return access time as Unix timestamp */
+  async getAtime(p) {
+    try {
+      return Math.floor((await fsStat(p)).atimeMs / 1e3);
+    } catch {
+      return 0;
+    }
+  },
+  /** Return creation time as Unix timestamp */
+  async getCtime(p) {
+    try {
+      return Math.floor((await fsStat(p)).ctimeMs / 1e3);
+    } catch {
+      return 0;
+    }
+  }
+};
+async function listDir(p = ".") {
+  try {
+    return await readdir(p);
+  } catch {
+    return [];
+  }
+}
+async function mkdir(p, mode = 511) {
+  await fsMkdir(p, { mode });
+}
+async function makeDirs(p, mode = 511, existOk = false) {
+  try {
+    await fsMkdir(p, { recursive: true, mode });
+  } catch (e) {
+    if (!existOk || !(e instanceof Error && "code" in e && e.code === "EEXIST")) {
+      throw e;
+    }
+  }
+}
+async function remove(p) {
+  await fsUnlink(p);
+}
+var unlink = remove;
+async function rmdir(p) {
+  await fsRmdir(p);
+}
+async function removeDirs(p) {
+  await fsRmdir(p);
+  let parent = pathDirname(p);
+  while (parent && parent !== p) {
+    try {
+      await fsRmdir(parent);
+      p = parent;
+      parent = pathDirname(p);
+    } catch {
+      break;
+    }
+  }
+}
+async function rename(src, dst) {
+  await fsRename(src, dst);
+}
+async function renames(src, dst) {
+  const dstDir = pathDirname(dst);
+  if (dstDir) {
+    await makeDirs(dstDir, 511, true);
+  }
+  await rename(src, dst);
+  const srcDir = pathDirname(src);
+  if (srcDir) {
+    try {
+      await removeDirs(srcDir);
+    } catch {
+    }
+  }
+}
+async function replace(src, dst) {
+  await fsRename(src, dst);
+}
+async function* walk(top, options) {
+  const topdown = options?.topdown ?? true;
+  const followlinks = options?.followlinks ?? false;
+  const dirs = [];
+  const files = [];
+  try {
+    const entries = await readdir(top, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        dirs.push(entry.name);
+      } else if (entry.isFile()) {
+        files.push(entry.name);
+      } else if (entry.isSymbolicLink()) {
+        if (followlinks) {
+          try {
+            const realPath = await realpath(join(top, entry.name));
+            if ((await fsStat(realPath)).isDirectory()) {
+              dirs.push(entry.name);
+            } else {
+              files.push(entry.name);
+            }
+          } catch {
+            files.push(entry.name);
+          }
+        } else {
+          files.push(entry.name);
+        }
+      }
+    }
+  } catch {
+    return;
+  }
+  if (topdown) {
+    yield [top, dirs, files];
+  }
+  for (const dir of dirs) {
+    const dirPath = join(top, dir);
+    yield* walk(dirPath, options);
+  }
+  if (!topdown) {
+    yield [top, dirs, files];
+  }
+}
+async function stat(p) {
+  try {
+    const s = await fsStat(p);
+    return {
+      st_mode: s.mode,
+      st_size: s.size,
+      st_mtime: Math.floor(s.mtimeMs / 1e3),
+      st_atime: Math.floor(s.atimeMs / 1e3),
+      st_ctime: Math.floor(s.ctimeMs / 1e3)
+    };
+  } catch {
+    return { st_mode: 0, st_size: 0, st_mtime: 0, st_atime: 0, st_ctime: 0 };
+  }
+}
+
+export {
+  path,
+  listDir,
+  mkdir,
+  makeDirs,
+  remove,
+  unlink,
+  rmdir,
+  removeDirs,
+  rename,
+  renames,
+  replace,
+  walk,
+  stat,
+  os_node_exports
+};

package/dist/chunk-PWA3YQZU.js

@@ -0,0 +1,346 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/logging.node.ts
+var logging_node_exports = {};
+__export(logging_node_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,
+  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;
+  // Note: mode is stored for future use when proper file writing is implemented
+  mode;
+  constructor(filename, mode = "a") {
+    super();
+    this.filename = filename;
+    this.mode = mode;
+  }
+  emit(record) {
+    const msg = this.format(record) + "\n";
+    import("fs/promises").then((fs) => fs.appendFile(this.filename, msg)).catch(() => {
+      console.log(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 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,
+  disable,
+  shutdown,
+  logging_node_exports
+};

package/dist/{chunk-56DGFWIJ.js → chunk-QKJBQKPY.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/math.ts
 var math_exports = {};
@@ -258,4 +258,3 @@ export {
   prod,
   math_exports
 };
-//# sourceMappingURL=chunk-56DGFWIJ.js.map