ezlog-py 1.0.1__tar.gz → 1.0.2__tar.gz

ezlog_py-1.0.2/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.3
+Name: ezlog-py
+Version: 1.0.2
+Summary: Simple, performant logging with ANSI colors for Python.
+Author: eaannist
+Author-email: eaannist <eaannist@gmail.com>
+Requires-Dist: pytest>=8.0.0 ; extra == 'dev'
+Requires-Python: >=3.12
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# ezlog
+
+Simple, performant logging with ANSI colors for Python.  
+Published on PyPI as **ezlog-py** (import as `ezlog`).
+
+- **5 levels**: `error`, `warn`, `info`, `success`, `debug` (no NOTSET/CRITICAL)
+- **Short aliases**: `e`, `w`, `i`, `s`, `d`
+- **ANSI colors**: red, yellow, cyan, green, magenta
+- **Stdlib integration**: after `init()`, `logging.info()` etc. go through ezlog formatting
+- **Zero dependencies**
+
+## Install
+
+```bash
+pip install ezlog-py
+```
+
+## Usage
+
+Import only ezlog, call **init** with the two settings, then use **ezlog.log** or stdlib **logging** (both go through ezlog):
+
+```python
+import ezlog
+
+ezlog.init(use_colors=True, use_timestamp=True)
+
+# Direct ezlog (includes .success() level)
+ezlog.log.success("Application started")
+ezlog.log.info("Environment: dev")
+ezlog.log.w("Warning")
+ezlog.log.e("Error")
+ezlog.log.d("Debug")
+
+# Stdlib logging (wired internally; same formatting)
+import logging
+logging.info("Hello from stdlib")
+logging.error("Something failed", exc_info=True)
+```
+
+## init (two settings)
+
+| Argument        | Default | Description     |
+|----------------|--------|-----------------|
+| `use_colors`   | `True` | ANSI colors     |
+| `use_timestamp`| `True` | ISO timestamp   |
+
+## Levels
+
+Ezlog has 5 levels: **error**, **warn**, **info**, **success**, **debug**.  
+Stdlib DEBUG/INFO/WARNING/ERROR are mapped to ezlog; NOTSET is skipped, CRITICAL is treated as error.
+
+## Exports
+
+- `init(use_colors=..., use_timestamp=...)` – initialize and wire to stdlib logging
+- `log` – EzLog instance (set after `init()`); use for direct logging and `.success()`
+- `EzLog` – logger class (for custom instances)
+- Types: `LogLevel`, `LogColors`, `EzlogConfig`, `LevelsConfig`, `LevelConfig`, `LogArgs`, `ConsoleMethod`

ezlog_py-1.0.2/README.md

@@ -0,0 +1,57 @@
+# ezlog
+
+Simple, performant logging with ANSI colors for Python.  
+Published on PyPI as **ezlog-py** (import as `ezlog`).
+
+- **5 levels**: `error`, `warn`, `info`, `success`, `debug` (no NOTSET/CRITICAL)
+- **Short aliases**: `e`, `w`, `i`, `s`, `d`
+- **ANSI colors**: red, yellow, cyan, green, magenta
+- **Stdlib integration**: after `init()`, `logging.info()` etc. go through ezlog formatting
+- **Zero dependencies**
+
+## Install
+
+```bash
+pip install ezlog-py
+```
+
+## Usage
+
+Import only ezlog, call **init** with the two settings, then use **ezlog.log** or stdlib **logging** (both go through ezlog):
+
+```python
+import ezlog
+
+ezlog.init(use_colors=True, use_timestamp=True)
+
+# Direct ezlog (includes .success() level)
+ezlog.log.success("Application started")
+ezlog.log.info("Environment: dev")
+ezlog.log.w("Warning")
+ezlog.log.e("Error")
+ezlog.log.d("Debug")
+
+# Stdlib logging (wired internally; same formatting)
+import logging
+logging.info("Hello from stdlib")
+logging.error("Something failed", exc_info=True)
+```
+
+## init (two settings)
+
+| Argument        | Default | Description     |
+|----------------|--------|-----------------|
+| `use_colors`   | `True` | ANSI colors     |
+| `use_timestamp`| `True` | ISO timestamp   |
+
+## Levels
+
+Ezlog has 5 levels: **error**, **warn**, **info**, **success**, **debug**.  
+Stdlib DEBUG/INFO/WARNING/ERROR are mapped to ezlog; NOTSET is skipped, CRITICAL is treated as error.
+
+## Exports
+
+- `init(use_colors=..., use_timestamp=...)` – initialize and wire to stdlib logging
+- `log` – EzLog instance (set after `init()`); use for direct logging and `.success()`
+- `EzLog` – logger class (for custom instances)
+- Types: `LogLevel`, `LogColors`, `EzlogConfig`, `LevelsConfig`, `LevelConfig`, `LogArgs`, `ConsoleMethod`

{ezlog_py-1.0.1 → ezlog_py-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ezlog-py"
-version = "1.0.1"
+version = "1.0.2"
 description = "Simple, performant logging with ANSI colors for Python."
 readme = "README.md"
 authors = [

ezlog_py-1.0.2/src/ezlog/__init__.py

@@ -0,0 +1,71 @@
+"""
+ezlog: simple, performant logging with ANSI colors (Python port of ezlog).
+Install as ezlog-py from PyPI. Import ezlog, call init(use_colors, use_timestamp),
+then use ezlog.log or stdlib logging; both go through ezlog formatting.
+5 levels: error, warn, info, success, debug (no NOTSET/CRITICAL).
+"""
+from __future__ import annotations
+
+import logging
+
+from ezlog.ezlog import EzLog, _EzLogHandler
+from ezlog.types import (
+    ConsoleMethod,
+    EzlogConfig,
+    LevelConfig,
+    LevelsConfig,
+    LogArgs,
+    LogColors,
+    LogLevel,
+)
+
+__all__ = [
+    "EzLog",
+    "init",
+    "log",
+    "LogLevel",
+    "LogColors",
+    "EzlogConfig",
+    "LevelsConfig",
+    "LevelConfig",
+    "LogArgs",
+    "ConsoleMethod",
+]
+
+# Set by init(); use ezlog.log after calling ezlog.init().
+log: EzLog | None = None
+
+
+def init(
+    *,
+    use_colors: bool = True,
+    use_timestamp: bool = True,
+) -> EzLog:
+    """
+    Initialize ezlog and wire it to stdlib logging. Call once at startup.
+    After init(), use ezlog.log for direct logging (including .success()) or
+    logging.info() / logger.error() etc.; all go through ezlog formatting.
+    """
+    global log
+    log = EzLog({
+        "useColors": use_colors,
+        "useTimestamp": use_timestamp,
+    })
+    root = logging.getLogger()
+    root.addHandler(_EzLogHandler(log))
+    root.setLevel(logging.DEBUG)
+    return log
+
+
+def main() -> None:
+    """CLI entry point: init + short demo."""
+    init(use_colors=True, use_timestamp=True)
+    assert log is not None
+    log.success("Application started")
+    log.info("Environment: dev")
+    log.w("Warning message")
+    log.e("Error message")
+    log.d("Debug message")
+    log.info("User data:", {"id": 1, "name": "John"})
+    log.configure({"useTimestamp": False})
+    log.s("Done")

{ezlog_py-1.0.1 → ezlog_py-1.0.2}/src/ezlog/ezlog.py

@@ -1,19 +1,28 @@
 """
 EzLog: simple, performant logging with ANSI colors.
-Mirrors ezlog (TypeScript) API: 5 levels, short aliases, safe serialization.
+Mirrors ezlog (TypeScript) API: 5 levels (error, warn, info, success, debug).
+Integrates with stdlib logging internally via init(); no NOTSET/CRITICAL.
 """
 from __future__ import annotations
 
 import json
-import os
+import logging
 import re
 import sys
 import traceback
 from datetime import datetime
-from typing import Any, Callable
+from typing import Any
 
 from ezlog.types import EzlogConfig, LevelConfig, LogLevel
 
+# Stdlib level -> ezlog level. We do not use NOTSET or CRITICAL (CRITICAL -> error).
+_STDLIB_LEVEL_MAP = {
+    logging.DEBUG: "debug",
+    logging.INFO: "info",
+    logging.WARNING: "warn",
+    logging.ERROR: "error",
+}
+
 # Compiled regex for stack line formatting (path:line:col).
 _STACK_PATH_LINE_RE = re.compile(r"(\(?)([^\s()]+):(\d+):(\d+)(\)?)")
 _STACK_FILE_RE = re.compile(r"^\s*File\s*")
@@ -351,69 +360,24 @@ class EzLog:
         return self._colors["white"]
 
 
-# --- create_error_handler (uses internal logger, not exported as "log") ---
-
-_IS_PRODUCTION = os.environ.get("ENV", "").lower() == "production"
-
-_log = EzLog(
-    {
-        "levels": {
-            "error": True,
-            "warn": True,
-            "info": True,
-            "success": True,
-            "debug": not _IS_PRODUCTION,
-        },
-        "useColors": True,
-        "useLevels": True,
-        "useSymbols": True,
-        "useTimestamp": True,
-    }
-)
-
-
-def _default_is_http_error(err: Any) -> bool:
-    """True if err has status_code or statusCode (common HTTP error pattern)."""
-    return hasattr(err, "status_code") or hasattr(err, "statusCode")
-
+class _EzLogHandler(logging.Handler):
+    """Internal handler: forwards stdlib LogRecords to EzLog. Skips NOTSET; CRITICAL -> error."""
 
-def _default_status_code(err: Any) -> int:
-    """Extract status code from error (status_code or statusCode)."""
-    return getattr(err, "status_code", None) or getattr(err, "statusCode", 500)
+    def __init__(self, ezlog: EzLog) -> None:
+        super().__init__()
+        self._ezlog = ezlog
 
-
-def create_error_handler(
-    *,
-    is_http_error: Callable[[Any], bool] | None = None,
-    get_method: Callable[[Any], str] | None = None,
-    get_url: Callable[[Any], str] | None = None,
-) -> Callable[[Any, Any], None]:
-    """
-    Create error handler for router on_error callback.
-    Logs by level: 5xx -> error, 4xx -> warn, else -> info.
-    """
-    is_http = is_http_error or _default_is_http_error
-    get_m = get_method or (
-        lambda req: getattr(req, "method", getattr(req, "METHOD", "?"))
-    )
-    get_u = get_url or (
-        lambda req: getattr(req, "url", getattr(req, "path", "?"))
-    )
-
-    def handler(err: Any, request: Any = None) -> None:
-        if request is None:
-            method, url = "?", "?"
-        else:
-            method, url = get_m(request), get_u(request)
-        if is_http(err):
-            code = _default_status_code(err)
-            if code >= 500:
-                _log.e(f"[{method}] {url} - {code}", err)
-            elif code >= 400:
-                _log.w(f"[{method}] {url} - {code}", err)
+    def emit(self, record: logging.LogRecord) -> None:
+        if record.levelno == logging.NOTSET:
+            return
+        level_name = _STDLIB_LEVEL_MAP.get(record.levelno)
+        if level_name is None:
+            level_name = "error"  # CRITICAL and any unknown -> error
+        try:
+            msg = self.format(record)
+            if record.exc_info and record.exc_info[1] is not None:
+                self._ezlog._log(level_name, msg, record.exc_info[1])
             else:
-                _log.i(f"[{method}] {url} - {code}", err)
-        else:
-            _log.e(f"[{method}] {url} - Unhandled error", err)
-
-    return handler
+                self._ezlog._log(level_name, msg)
+        except Exception:  # noqa: BLE001
+            self.handleError(record)

ezlog_py-1.0.1/PKG-INFO

@@ -1,72 +0,0 @@
-Metadata-Version: 2.3
-Name: ezlog-py
-Version: 1.0.1
-Summary: Simple, performant logging with ANSI colors for Python.
-Author: eaannist
-Author-email: eaannist <eaannist@gmail.com>
-Requires-Dist: pytest>=8.0.0 ; extra == 'dev'
-Requires-Python: >=3.12
-Provides-Extra: dev
-Description-Content-Type: text/markdown
-
-# ezlog (Python)
-
-Simple, performant logging with ANSI colors for Python.  
-Published on PyPI as **ezlog-py** (import as `ezlog`).
-
-- **5 levels**: `error`, `warn`, `info`, `success`, `debug`
-- **Short aliases**: `e`, `w`, `i`, `s`, `d`
-- **ANSI colors**: red, yellow, cyan, green, magenta
-- **Config**: levels on/off, colors, symbols vs text, timestamp
-- **Safe serialization**: circular refs, dates, exceptions
-- **Zero dependencies**
-
-## Install
-
-```bash
-pip install ezlog-py
-```
-
-## Usage
-
-```python
-from ezlog import EzLog, create_error_handler
-
-# Create your own logger (no pre-initialized log instance)
-logger = EzLog({
-    "levels": {"error": True, "warn": True, "info": True, "success": True, "debug": False},
-    "useColors": True,
-    "useLevels": True,
-    "useSymbols": False,
-    "useTimestamp": True,
-})
-logger.success("Application started")
-logger.info("Environment: dev")
-logger.w("Warning")
-logger.e("Error")
-logger.d("Debug")
-
-logger.configure({"useTimestamp": False})
-logger.info("User:", {"id": 1, "name": "John"})
-logger.error("Failed", Exception("Connection failed"))
-
-# Error handler for routers (e.g. FastAPI/Starlette)
-on_error = create_error_handler()
-on_error(exception, request)
-```
-
-## Config
-
-| Option         | Description                            |
-|----------------|----------------------------------------|
-| `levels`      | Enable/disable per level               |
-| `useColors`   | ANSI colors on/off                     |
-| `useLevels`   | Show level label before message        |
-| `useSymbols` | Use symbols (x, !, i, ✓, d) or text   |
-| `useTimestamp`| ISO timestamp before message           |
-
-## Exports
-
-- `EzLog` – logger class (create instances yourself)
-- `create_error_handler(is_http_error=..., get_method=..., get_url=...)` – for router error callbacks
-- Types: `LogLevel`, `LogColors`, `EzlogConfig`, `LevelsConfig`, `LevelConfig`, `LogArgs`, `ConsoleMethod`

ezlog_py-1.0.1/README.md

@@ -1,61 +0,0 @@
-# ezlog (Python)
-
-Simple, performant logging with ANSI colors for Python.  
-Published on PyPI as **ezlog-py** (import as `ezlog`).
-
-- **5 levels**: `error`, `warn`, `info`, `success`, `debug`
-- **Short aliases**: `e`, `w`, `i`, `s`, `d`
-- **ANSI colors**: red, yellow, cyan, green, magenta
-- **Config**: levels on/off, colors, symbols vs text, timestamp
-- **Safe serialization**: circular refs, dates, exceptions
-- **Zero dependencies**
-
-## Install
-
-```bash
-pip install ezlog-py
-```
-
-## Usage
-
-```python
-from ezlog import EzLog, create_error_handler
-
-# Create your own logger (no pre-initialized log instance)
-logger = EzLog({
-    "levels": {"error": True, "warn": True, "info": True, "success": True, "debug": False},
-    "useColors": True,
-    "useLevels": True,
-    "useSymbols": False,
-    "useTimestamp": True,
-})
-logger.success("Application started")
-logger.info("Environment: dev")
-logger.w("Warning")
-logger.e("Error")
-logger.d("Debug")
-
-logger.configure({"useTimestamp": False})
-logger.info("User:", {"id": 1, "name": "John"})
-logger.error("Failed", Exception("Connection failed"))
-
-# Error handler for routers (e.g. FastAPI/Starlette)
-on_error = create_error_handler()
-on_error(exception, request)
-```
-
-## Config
-
-| Option         | Description                            |
-|----------------|----------------------------------------|
-| `levels`      | Enable/disable per level               |
-| `useColors`   | ANSI colors on/off                     |
-| `useLevels`   | Show level label before message        |
-| `useSymbols` | Use symbols (x, !, i, ✓, d) or text   |
-| `useTimestamp`| ISO timestamp before message           |
-
-## Exports
-
-- `EzLog` – logger class (create instances yourself)
-- `create_error_handler(is_http_error=..., get_method=..., get_url=...)` – for router error callbacks
-- Types: `LogLevel`, `LogColors`, `EzlogConfig`, `LevelsConfig`, `LevelConfig`, `LogArgs`, `ConsoleMethod`

ezlog_py-1.0.1/src/ezlog/__init__.py

@@ -1,54 +0,0 @@
-"""
-ezlog: simple, performant logging with ANSI colors (Python port of ezlog).
-Install as ezlog-py from PyPI; import as: from ezlog import EzLog, create_error_handler.
-5 levels: error, warn, info, success, debug. Short aliases: e, w, i, s, d.
-"""
-from ezlog.ezlog import EzLog, create_error_handler
-from ezlog.types import (
-    ConsoleMethod,
-    EzlogConfig,
-    LevelConfig,
-    LevelsConfig,
-    LogArgs,
-    LogColors,
-    LogLevel,
-)
-
-__all__ = [
-    "EzLog",
-    "create_error_handler",
-    "LogLevel",
-    "LogColors",
-    "EzlogConfig",
-    "LevelsConfig",
-    "LevelConfig",
-    "LogArgs",
-    "ConsoleMethod",
-]
-
-
-def main() -> None:
-    """CLI entry point: short demo (users create their own EzLog())."""
-    logger = EzLog(
-        {
-            "levels": {
-                "error": True,
-                "warn": True,
-                "info": True,
-                "success": True,
-                "debug": False,
-            },
-            "useColors": True,
-            "useLevels": True,
-            "useSymbols": False,
-            "useTimestamp": True,
-        }
-    )
-    logger.success("Application started")
-    logger.info("Environment: dev")
-    logger.w("Warning message")
-    logger.e("Error message")
-    logger.d("Debug message")
-    logger.info("User data:", {"id": 1, "name": "John"})
-    logger.configure({"useTimestamp": False})
-    logger.s("Done")