pythonlib 1.0.2 → 2.0.1

package/dist/chunk-2YTO24B5.js

@@ -0,0 +1,78 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tempfile.browser.ts
+var tempfile_browser_exports = {};
+__export(tempfile_browser_exports, {
+  NamedTemporaryFile: () => NamedTemporaryFile,
+  TemporaryDirectory: () => TemporaryDirectory,
+  getPrefix: () => getPrefix,
+  getTempDir: () => getTempDir,
+  mkdtemp: () => mkdtemp,
+  mkstemp: () => mkstemp,
+  mktemp: () => mktemp
+});
+function getTempDir() {
+  return "/tmp";
+}
+function getPrefix() {
+  return "tmp";
+}
+function mktemp(suffix = "", prefix = "tmp", dir) {
+  const tempDir = dir ?? getTempDir();
+  const randomPart = Math.random().toString(36).slice(2, 10);
+  return `${tempDir}/${prefix}${randomPart}${suffix}`;
+}
+async function mkstemp(_suffix = "", _prefix = "tmp", _dir) {
+  throw new Error("mkstemp is not supported in browser environment");
+}
+async function mkdtemp(_suffix = "", _prefix = "tmp", _dir) {
+  throw new Error("mkdtemp is not supported in browser environment");
+}
+var NamedTemporaryFile = class {
+  name = "";
+  deleteOnClose = true;
+  constructor() {
+    throw new Error("NamedTemporaryFile is not supported in browser environment");
+  }
+  static async create(_options) {
+    throw new Error("NamedTemporaryFile is not supported in browser environment");
+  }
+  async write(_data) {
+    throw new Error("Not supported in browser");
+  }
+  async read(_size) {
+    throw new Error("Not supported in browser");
+  }
+  async flush() {
+    throw new Error("Not supported in browser");
+  }
+  async close() {
+    throw new Error("Not supported in browser");
+  }
+};
+var TemporaryDirectory = class {
+  name = "";
+  constructor() {
+    throw new Error("TemporaryDirectory is not supported in browser environment");
+  }
+  static async create(_options) {
+    throw new Error("TemporaryDirectory is not supported in browser environment");
+  }
+  async cleanup() {
+    throw new Error("Not supported in browser");
+  }
+};
+
+export {
+  getTempDir,
+  getPrefix,
+  mktemp,
+  mkstemp,
+  mkdtemp,
+  NamedTemporaryFile,
+  TemporaryDirectory,
+  tempfile_browser_exports
+};
+/* v8 ignore start -- browser stubs @preserve */

package/dist/chunk-3HQSBCEC.js

@@ -0,0 +1,348 @@
+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;
+  }
+  /* v8 ignore start -- async file writing is tested via integration @preserve */
+  emit(record) {
+    const msg = this.format(record) + "\n";
+    import("fs/promises").then((fs) => fs.appendFile(this.filename, msg)).catch(() => {
+      console.log(msg);
+    });
+  }
+  /* v8 ignore stop */
+};
+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-7BZB2TQF.js → chunk-3M3PB4RO.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-PZ5AY32C.js";
+} from "./chunk-MLKGABMK.js";
 
 // src/random.ts
 var random_exports = {};
@@ -80,7 +80,8 @@ function choices(population, options) {
       let hi = cumWeights.length;
       while (lo < hi) {
         const mid = Math.floor((lo + hi) / 2);
-        if (r > cumWeights[mid]) {
+        const midWeight = cumWeights[mid];
+        if (midWeight !== void 0 && r > midWeight) {
           lo = mid + 1;
         } else {
           hi = mid;
@@ -132,9 +133,7 @@ function gauss(mu = 0, sigma = 1) {
 }
 var normalVariate = gauss;
 function triangular(low = 0, high = 1, mode) {
-  if (mode === void 0) {
-    mode = (low + high) / 2;
-  }
+  mode ??= (low + high) / 2;
   const u = Math.random();
   const c = (mode - low) / (high - low);
   if (u < c) {
@@ -233,4 +232,3 @@ export {
   weibullVariate,
   random_exports
 };
-//# sourceMappingURL=chunk-7BZB2TQF.js.map