ansilogs 1.0.0__tar.gz

ansilogs-1.0.0/.github/workflows/python-app.yml

@@ -0,0 +1,44 @@
+name: Python application
+
+on:
+  push:
+    branches: [ '**' ]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install pre-commit pyright==1.1.411 -e ".[test]"
+      - name: Run pre-commit hooks
+        run: pre-commit run --all-files
+      - name: Run pyright
+        run: pyright
+
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [ "3.9", "3.10", "3.11", "3.12", "3.13", "3.14", "3.15" ]
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install ".[test]"
+      - name: Run tests
+        run: python -m pytest -v

ansilogs-1.0.0/.github/workflows/python-publish.yml

@@ -0,0 +1,38 @@
+# This workflow uploads a Python Package to PyPI using Trusted Publishing (OIDC).
+# No API tokens or passwords are stored: PyPI verifies the workflow's identity.
+# See: https://docs.pypi.org/trusted-publishers/
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/ansilogs
+
+    permissions:
+      id-token: write  # required for Trusted Publishing (OIDC)
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # full history + tags so setuptools_scm can derive the version
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build
+      run: python -m build
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

ansilogs-1.0.0/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+.idea/
+venv/
+build/
+dist/
+version.txt
+debug/
+*.pyc
+*.egg-info/
+/ansilogs/_version.py

ansilogs-1.0.0/.pre-commit-config.yaml

@@ -0,0 +1,9 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.14.2
+  hooks:
+    # Run the linter.
+    - id: ruff-check
+    # Run the formatter.
+    - id: ruff-format

ansilogs-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 doronz88
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ansilogs-1.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: ansilogs
+Version: 1.0.0
+Summary: Colored, single-line log output for command-line tools: a dependency-free coloredlogs.install() replacement
+Author-email: doronz88 <doron88@gmail.com>
+Maintainer-email: doronz88 <doron88@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 doronz88
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/doronz88/ansilogs
+Project-URL: Bug Reports, https://github.com/doronz88/ansilogs/issues
+Keywords: logging,color,ansi,terminal,cli
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Logging
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# ansilogs
+
+Colored, single-line log output for command-line tools. A small, dependency-free replacement
+for `coloredlogs.install()` with the same default look.
+
+```python
+import logging
+
+import ansilogs
+
+ansilogs.install(logging.DEBUG)
+logging.getLogger(__name__).warning("careful")
+```
+
+```
+2026-10-19 09:35:12 my-host my_tool.cli[4242] WARNING careful
+```
+
+- One line per record: `<time> <host> <name>[<pid>] <LEVEL> <message>`; tracebacks follow
+  uncolored.
+- Colors only when stderr is a terminal. `NO_COLOR` (non-empty) disables them, `FORCE_COLOR`
+  (non-empty) forces them. On Windows the console is switched to ANSI processing; if that
+  fails, output is plain.
+- Records go to whatever `sys.stderr` is at the time (test capture and live progress displays
+  that redirect stderr keep working).
+
+## API
+
+- `install(level=logging.INFO, colors=None)`: attach the handler to the root logger (once) and
+  show records from `level` up. `colors=None` means `supports_color()`.
+- `set_level(level)`: change the shown level (installs the handler if needed).
+- `supports_color(stream=None)`: the color decision used by `install()`.
+- `ColoredFormatter(colors=True, hostname=None)` and `StderrHandler` for custom setups.
+
+## Migrating from coloredlogs
+
+```diff
+-import coloredlogs
+-coloredlogs.install(level=logging.DEBUG)
++import ansilogs
++ansilogs.install(logging.DEBUG)
+```
+
+`coloredlogs.set_level(level)` becomes `ansilogs.set_level(level)`. `COLOREDLOGS_*` environment
+variables and custom field/level styles are not supported.

ansilogs-1.0.0/README.md

@@ -0,0 +1,45 @@
+# ansilogs
+
+Colored, single-line log output for command-line tools. A small, dependency-free replacement
+for `coloredlogs.install()` with the same default look.
+
+```python
+import logging
+
+import ansilogs
+
+ansilogs.install(logging.DEBUG)
+logging.getLogger(__name__).warning("careful")
+```
+
+```
+2026-10-19 09:35:12 my-host my_tool.cli[4242] WARNING careful
+```
+
+- One line per record: `<time> <host> <name>[<pid>] <LEVEL> <message>`; tracebacks follow
+  uncolored.
+- Colors only when stderr is a terminal. `NO_COLOR` (non-empty) disables them, `FORCE_COLOR`
+  (non-empty) forces them. On Windows the console is switched to ANSI processing; if that
+  fails, output is plain.
+- Records go to whatever `sys.stderr` is at the time (test capture and live progress displays
+  that redirect stderr keep working).
+
+## API
+
+- `install(level=logging.INFO, colors=None)`: attach the handler to the root logger (once) and
+  show records from `level` up. `colors=None` means `supports_color()`.
+- `set_level(level)`: change the shown level (installs the handler if needed).
+- `supports_color(stream=None)`: the color decision used by `install()`.
+- `ColoredFormatter(colors=True, hostname=None)` and `StderrHandler` for custom setups.
+
+## Migrating from coloredlogs
+
+```diff
+-import coloredlogs
+-coloredlogs.install(level=logging.DEBUG)
++import ansilogs
++ansilogs.install(logging.DEBUG)
+```
+
+`coloredlogs.set_level(level)` becomes `ansilogs.set_level(level)`. `COLOREDLOGS_*` environment
+variables and custom field/level styles are not supported.

ansilogs-1.0.0/ansilogs/__init__.py

@@ -0,0 +1,173 @@
+"""
+Colored, single-line log output for command-line tools.
+
+A small, dependency-free replacement for ``coloredlogs.install()``::
+
+    import logging
+    import ansilogs
+
+    ansilogs.install(logging.DEBUG)
+
+Each record is one line, ``<time> <host> <name>[<pid>] <LEVEL> <message>``, colored with ANSI
+escape codes when stderr is a terminal (honoring ``NO_COLOR`` and ``FORCE_COLOR``, and switching
+Windows consoles to ANSI processing). The handler writes to whatever ``sys.stderr`` is at the
+time of each record, so redirections (test capture, live progress displays) are respected.
+"""
+
+import logging
+import os
+import socket
+import sys
+from typing import IO, Optional, Union
+
+__all__ = ["DATE_FORMAT", "ColoredFormatter", "StderrHandler", "install", "set_level", "supports_color"]
+
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+_RESET = "\x1b[0m"
+_TIME = "32"  # green
+_HOST = "35"  # magenta
+_NAME = "34"  # blue
+_LEVEL_NAME = "1;30"  # bold black
+_MESSAGE_BY_LEVEL = {
+    logging.DEBUG: "32",  # green
+    logging.WARNING: "33",  # yellow
+    logging.ERROR: "31",  # red
+    logging.CRITICAL: "1;31",  # bold red
+}
+
+# SetConsoleMode flag that makes a Windows console interpret ANSI escape sequences.
+_ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+_STD_ERROR_HANDLE = -12
+
+
+def _sgr(code: str, text: str) -> str:
+    return f"\x1b[{code}m{text}{_RESET}"
+
+
+class ColoredFormatter(logging.Formatter):
+    """
+    ``<time> <host> <name>[<pid>] <LEVEL> <message>``, with ANSI colors when ``colors`` is set.
+
+    The colors are baked into the format string once; per record only the message is wrapped in
+    its level's color. Tracebacks and stack info are appended uncolored.
+    """
+
+    def __init__(self, colors: bool = True, hostname: Optional[str] = None) -> None:
+        host = (hostname or socket.gethostname()).replace("%", "%%")
+        fields = [
+            ("%(asctime)s", _TIME),
+            (host, _HOST),
+            ("%(name)s[%(process)d]", _NAME),
+            ("%(levelname)s", _LEVEL_NAME),
+        ]
+        prefix = " ".join(_sgr(code, text) if colors else text for text, code in fields)
+        super().__init__(f"{prefix} %(message)s", datefmt=DATE_FORMAT)
+        self.colors = colors
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        code = _MESSAGE_BY_LEVEL.get(record.levelno) if self.colors else None
+        if code is None:
+            return super().formatMessage(record)
+        message = record.message
+        record.message = _sgr(code, message)
+        try:
+            return super().formatMessage(record)
+        finally:
+            record.message = message
+
+
+class StderrHandler(logging.Handler):
+    """Writes each record to the current ``sys.stderr`` (looked up per record, never cached)."""
+
+    terminator = "\n"
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            line = self.format(record)
+            stream = sys.stderr
+            if stream is None:
+                return
+            stream.write(line + self.terminator)
+            stream.flush()
+        except RecursionError:
+            raise
+        except Exception:
+            self.handleError(record)
+
+
+def _enable_windows_ansi(stream: IO[str]) -> bool:
+    """Switch the Windows console behind ``stream`` to ANSI processing; False if it isn't a console."""
+    if sys.platform != "win32":
+        return True
+    import ctypes
+    from ctypes import wintypes
+
+    if stream is not sys.__stderr__:
+        # Only the process' own stderr maps to the standard error console handle.
+        return False
+    kernel32 = ctypes.windll.kernel32
+    handle = kernel32.GetStdHandle(_STD_ERROR_HANDLE)
+    mode = wintypes.DWORD()
+    if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+        return False
+    if mode.value & _ENABLE_VIRTUAL_TERMINAL_PROCESSING:
+        return True
+    return bool(kernel32.SetConsoleMode(handle, mode.value | _ENABLE_VIRTUAL_TERMINAL_PROCESSING))
+
+
+def supports_color(stream: Optional[IO[str]] = None) -> bool:
+    """
+    Whether to color output written to ``stream`` (default: ``sys.stderr``).
+
+    ``NO_COLOR`` (non-empty) disables colors and ``FORCE_COLOR`` (non-empty) forces them;
+    otherwise the stream must be a terminal, and on Windows a console that accepts ANSI codes.
+    """
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("FORCE_COLOR"):
+        return True
+    stream = sys.stderr if stream is None else stream
+    if stream is None:
+        return False
+    isatty = getattr(stream, "isatty", None)
+    try:
+        if isatty is None or not isatty():
+            return False
+    except ValueError:  # closed stream
+        return False
+    return _enable_windows_ansi(stream)
+
+
+def _installed_handler() -> Optional[StderrHandler]:
+    return next((h for h in logging.getLogger().handlers if isinstance(h, StderrHandler)), None)
+
+
+def install(level: Union[int, str] = logging.INFO, colors: Optional[bool] = None) -> None:
+    """
+    Attach a colored stderr handler to the root logger and show records from ``level`` up.
+
+    Calling it again reconfigures the existing handler instead of adding another. ``colors``
+    defaults to :func:`supports_color` for the current ``sys.stderr``.
+    """
+    handler = _installed_handler()
+    if handler is None:
+        handler = StderrHandler()
+        logging.getLogger().addHandler(handler)
+    handler.setFormatter(ColoredFormatter(colors=supports_color() if colors is None else colors))
+    set_level(level)
+
+
+def set_level(level: Union[int, str]) -> None:
+    """
+    Show records from ``level`` up: sets the handler's level (installing it if needed) and relaxes
+    the root logger's level if it would filter those records out.
+    """
+    handler = _installed_handler()
+    if handler is None:
+        install(level)
+        return
+    handler.setLevel(level)
+    root = logging.getLogger()
+    if root.getEffectiveLevel() > handler.level:
+        root.setLevel(handler.level)

ansilogs-1.0.0/ansilogs/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = 'gaa8e027c2'

ansilogs-1.0.0/ansilogs.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: ansilogs
+Version: 1.0.0
+Summary: Colored, single-line log output for command-line tools: a dependency-free coloredlogs.install() replacement
+Author-email: doronz88 <doron88@gmail.com>
+Maintainer-email: doronz88 <doron88@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 doronz88
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/doronz88/ansilogs
+Project-URL: Bug Reports, https://github.com/doronz88/ansilogs/issues
+Keywords: logging,color,ansi,terminal,cli
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Logging
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# ansilogs
+
+Colored, single-line log output for command-line tools. A small, dependency-free replacement
+for `coloredlogs.install()` with the same default look.
+
+```python
+import logging
+
+import ansilogs
+
+ansilogs.install(logging.DEBUG)
+logging.getLogger(__name__).warning("careful")
+```
+
+```
+2026-10-19 09:35:12 my-host my_tool.cli[4242] WARNING careful
+```
+
+- One line per record: `<time> <host> <name>[<pid>] <LEVEL> <message>`; tracebacks follow
+  uncolored.
+- Colors only when stderr is a terminal. `NO_COLOR` (non-empty) disables them, `FORCE_COLOR`
+  (non-empty) forces them. On Windows the console is switched to ANSI processing; if that
+  fails, output is plain.
+- Records go to whatever `sys.stderr` is at the time (test capture and live progress displays
+  that redirect stderr keep working).
+
+## API
+
+- `install(level=logging.INFO, colors=None)`: attach the handler to the root logger (once) and
+  show records from `level` up. `colors=None` means `supports_color()`.
+- `set_level(level)`: change the shown level (installs the handler if needed).
+- `supports_color(stream=None)`: the color decision used by `install()`.
+- `ColoredFormatter(colors=True, hostname=None)` and `StderrHandler` for custom setups.
+
+## Migrating from coloredlogs
+
+```diff
+-import coloredlogs
+-coloredlogs.install(level=logging.DEBUG)
++import ansilogs
++ansilogs.install(logging.DEBUG)
+```
+
+`coloredlogs.set_level(level)` becomes `ansilogs.set_level(level)`. `COLOREDLOGS_*` environment
+variables and custom field/level styles are not supported.

ansilogs-1.0.0/ansilogs.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+.gitignore
+.pre-commit-config.yaml
+LICENSE
+README.md
+pyproject.toml
+.github/workflows/python-app.yml
+.github/workflows/python-publish.yml
+ansilogs/__init__.py
+ansilogs/_version.py
+ansilogs/py.typed
+ansilogs.egg-info/PKG-INFO
+ansilogs.egg-info/SOURCES.txt
+ansilogs.egg-info/dependency_links.txt
+ansilogs.egg-info/requires.txt
+ansilogs.egg-info/scm_file_list.json
+ansilogs.egg-info/scm_version.json
+ansilogs.egg-info/top_level.txt
+tests/console_child.py
+tests/test_ansilogs.py
+tests/test_windows_console.py

ansilogs-1.0.0/ansilogs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ansilogs-1.0.0/ansilogs.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[test]
+pytest

ansilogs-1.0.0/ansilogs.egg-info/scm_file_list.json

@@ -0,0 +1,16 @@
+{
+  "files": [
+    ".github/workflows/python-app.yml",
+    ".github/workflows/python-publish.yml",
+    ".gitignore",
+    ".pre-commit-config.yaml",
+    "LICENSE",
+    "README.md",
+    "ansilogs/__init__.py",
+    "ansilogs/py.typed",
+    "pyproject.toml",
+    "tests/console_child.py",
+    "tests/test_ansilogs.py",
+    "tests/test_windows_console.py"
+  ]
+}

ansilogs-1.0.0/ansilogs.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.0",
+  "distance": 0,
+  "node": "gaa8e027c29ab9ce72f33445b198a6c6f71d53b2a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-19"
+}

ansilogs-1.0.0/ansilogs.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+ansilogs
+dist

ansilogs-1.0.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "ansilogs"
+description = "Colored, single-line log output for command-line tools: a dependency-free coloredlogs.install() replacement"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+keywords = ["logging", "color", "ansi", "terminal", "cli"]
+authors = [
+    { name = "doronz88", email = "doron88@gmail.com" }
+]
+maintainers = [
+    { name = "doronz88", email = "doron88@gmail.com" }
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: System :: Logging",
+    "Typing :: Typed",
+]
+dependencies = []
+dynamic = ["version"]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.urls]
+"Homepage" = "https://github.com/doronz88/ansilogs"
+"Bug Reports" = "https://github.com/doronz88/ansilogs/issues"
+
+[tool.setuptools.packages.find]
+exclude = ["docs*", "tests*"]
+
+[tool.setuptools.package-data]
+ansilogs = ["py.typed"]
+
+[tool.setuptools_scm]
+version_file = "ansilogs/_version.py"
+
+[build-system]
+requires = ["setuptools>=64", "setuptools_scm>=8", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.ruff]
+target-version = "py39"
+line-length = 120
+fix = true
+
+[tool.ruff.lint]
+select = ["YTT", "B", "A", "C4", "T10", "SIM", "I", "E", "W", "F", "PGH", "UP", "RUF", "TRY"]
+
+[tool.pyright]
+pythonVersion = "3.9"
+typeCheckingMode = "strict"
+include = ["ansilogs", "tests"]

ansilogs-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ansilogs-1.0.0/tests/console_child.py

@@ -0,0 +1,77 @@
+"""
+Run inside a fresh Windows console (``CREATE_NEW_CONSOLE``) by ``test_windows_console.py``.
+
+Turns ANSI processing off, writes a raw escape sequence (the control: it must land on screen
+literally), then lets ``ansilogs.install()`` turn processing on and logs a warning (which must
+render without escape codes). Reports the console modes and the screen text as JSON.
+"""
+
+import ctypes
+import json
+import logging
+import sys
+from ctypes import wintypes
+
+import ansilogs
+
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+STD_ERROR_HANDLE = -12
+GENERIC_READ_WRITE = 0x80000000 | 0x40000000
+FILE_SHARE_READ_WRITE = 0x1 | 0x2
+OPEN_EXISTING = 3
+
+
+class COORD(ctypes.Structure):
+    _fields_ = [("X", wintypes.SHORT), ("Y", wintypes.SHORT)]  # noqa: RUF012 (ctypes API)
+
+
+class CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
+    _fields_ = [  # noqa: RUF012 (ctypes API)
+        ("dwSize", COORD),
+        ("dwCursorPosition", COORD),
+        ("wAttributes", wintypes.WORD),
+        ("srWindow", wintypes.SMALL_RECT),
+        ("dwMaximumWindowSize", COORD),
+    ]
+
+
+def main() -> None:
+    assert sys.platform == "win32"
+    kernel32 = ctypes.windll.kernel32
+    kernel32.CreateFileW.restype = wintypes.HANDLE
+    report = {}
+    stderr_handle = kernel32.GetStdHandle(STD_ERROR_HANDLE)
+    mode = wintypes.DWORD()
+    report["stderr_is_console"] = bool(kernel32.GetConsoleMode(stderr_handle, ctypes.byref(mode)))
+    if report["stderr_is_console"]:
+        kernel32.SetConsoleMode(stderr_handle, mode.value & ~ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+        sys.stderr.write("\x1b[33mCONTROL\x1b[0m\n")
+        sys.stderr.flush()
+
+        ansilogs.install(logging.INFO)
+        kernel32.GetConsoleMode(stderr_handle, ctypes.byref(mode))
+        report["vt_after_install"] = bool(mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+        (handler,) = [h for h in logging.getLogger().handlers if isinstance(h, ansilogs.StderrHandler)]
+        formatter = handler.formatter
+        report["colors"] = isinstance(formatter, ansilogs.ColoredFormatter) and formatter.colors
+        logging.getLogger("ansilogs.console").warning("hello from a console")
+
+        screen = kernel32.CreateFileW(
+            "CONOUT$", GENERIC_READ_WRITE, FILE_SHARE_READ_WRITE, None, OPEN_EXISTING, 0, None
+        )
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        kernel32.GetConsoleScreenBufferInfo(screen, ctypes.byref(info))
+        width = info.dwSize.X
+        rows = []
+        for y in range(info.dwCursorPosition.Y + 1):
+            buffer = ctypes.create_unicode_buffer(width)
+            read = wintypes.DWORD()
+            kernel32.ReadConsoleOutputCharacterW(screen, buffer, width, COORD(0, y), ctypes.byref(read))
+            rows.append(buffer.value[: read.value].rstrip())
+        report["screen"] = rows
+    with open(sys.argv[1], "w", encoding="utf-8") as f:
+        json.dump(report, f)
+
+
+if __name__ == "__main__":
+    main()

ansilogs-1.0.0/tests/test_ansilogs.py

@@ -0,0 +1,159 @@
+import io
+import logging
+import re
+import sys
+from collections.abc import Iterator
+from typing import Any
+
+import pytest
+
+import ansilogs
+from ansilogs import ColoredFormatter, StderrHandler
+
+LINE = re.compile(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d host ansilogs\.tests\[\d+\] (\w+) (.*)$")
+
+
+def _record(level: int, msg: str, *args: Any, exc_info: Any = None) -> logging.LogRecord:
+    return logging.LogRecord("ansilogs.tests", level, __file__, 1, msg, args, exc_info)
+
+
+@pytest.fixture(autouse=True)
+def clean_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    monkeypatch.delenv("FORCE_COLOR", raising=False)
+
+
+@pytest.fixture
+def root(monkeypatch: pytest.MonkeyPatch) -> Iterator[logging.Logger]:
+    root = logging.getLogger()
+    monkeypatch.setattr(root, "handlers", [])
+    monkeypatch.setattr(root, "level", logging.WARNING)
+    yield root
+
+
+def _ours(root: logging.Logger) -> list[StderrHandler]:
+    # pytest attaches its own capture handlers to the root logger while a test runs.
+    return [h for h in root.handlers if isinstance(h, StderrHandler)]
+
+
+def test_plain_layout_is_one_line() -> None:
+    line = ColoredFormatter(colors=False, hostname="host").format(_record(logging.INFO, "sent %d bytes", 5))
+    match = LINE.match(line)
+    assert match is not None
+    assert match.groups() == ("INFO", "sent 5 bytes")
+
+
+def test_colored_layout_matches_coloredlogs_defaults() -> None:
+    record = _record(logging.WARNING, "careful")
+    line = ColoredFormatter(colors=True, hostname="host").format(record)
+    timestamp = ColoredFormatter(colors=False).formatTime(record, ansilogs.DATE_FORMAT)
+    assert line == (
+        f"\x1b[32m{timestamp}\x1b[0m \x1b[35mhost\x1b[0m \x1b[34mansilogs.tests[{record.process}]\x1b[0m "
+        "\x1b[1;30mWARNING\x1b[0m \x1b[33mcareful\x1b[0m"
+    )
+
+
+@pytest.mark.parametrize(
+    ("level", "code"),
+    [(logging.DEBUG, "32"), (logging.WARNING, "33"), (logging.ERROR, "31"), (logging.CRITICAL, "1;31")],
+)
+def test_message_takes_its_level_color(level: int, code: str) -> None:
+    line = ColoredFormatter(colors=True).format(_record(level, "msg"))
+    assert line.endswith(f"\x1b[{code}mmsg\x1b[0m")
+
+
+def test_info_message_is_uncolored_and_record_is_left_untouched() -> None:
+    record = _record(logging.INFO, "msg")
+    assert ColoredFormatter(colors=True).format(record).endswith("\x1b[0m msg")
+    warning = _record(logging.WARNING, "msg")
+    ColoredFormatter(colors=True).format(warning)
+    assert warning.message == "msg"
+
+
+def test_hostname_with_percent_is_literal() -> None:
+    line = ColoredFormatter(colors=False, hostname="a%sb").format(_record(logging.INFO, "msg"))
+    assert " a%sb " in line
+
+
+def test_traceback_is_appended_uncolored() -> None:
+    def boom() -> None:
+        raise ValueError("boom")
+
+    with pytest.raises(ValueError) as excinfo:
+        boom()
+    record = _record(logging.ERROR, "failed", exc_info=(excinfo.type, excinfo.value, excinfo.tb))
+    lines = ColoredFormatter(colors=True).format(record).splitlines()
+    assert lines[0].endswith("\x1b[31mfailed\x1b[0m")
+    assert lines[1] == "Traceback (most recent call last):"
+    assert lines[-1] == "ValueError: boom"
+
+
+def test_handler_writes_to_the_current_stderr(monkeypatch: pytest.MonkeyPatch) -> None:
+    handler = StderrHandler()
+    handler.setFormatter(ColoredFormatter(colors=False))
+    first, second = io.StringIO(), io.StringIO()
+    monkeypatch.setattr(sys, "stderr", first)
+    handler.handle(_record(logging.INFO, "one"))
+    monkeypatch.setattr(sys, "stderr", second)
+    handler.handle(_record(logging.INFO, "two"))
+    assert first.getvalue().endswith(" INFO one\n")
+    assert second.getvalue().endswith(" INFO two\n")
+
+
+def test_handler_tolerates_missing_stderr(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(sys, "stderr", None)
+    StderrHandler().handle(_record(logging.INFO, "dropped"))
+
+
+class _Tty(io.StringIO):
+    def isatty(self) -> bool:
+        if self.closed:
+            raise ValueError
+        return True
+
+
+def test_supports_color_requires_a_terminal() -> None:
+    assert not ansilogs.supports_color(io.StringIO())
+    if sys.platform != "win32":
+        assert ansilogs.supports_color(_Tty())
+
+
+def test_supports_color_rejects_a_closed_stream() -> None:
+    stream = _Tty()
+    stream.close()
+    assert not ansilogs.supports_color(stream)
+
+
+def test_no_color_and_force_color(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("FORCE_COLOR", "1")
+    assert ansilogs.supports_color(io.StringIO())
+    monkeypatch.setenv("NO_COLOR", "1")
+    assert not ansilogs.supports_color(_Tty())
+    monkeypatch.setenv("NO_COLOR", "")
+    assert ansilogs.supports_color(io.StringIO())
+
+
+def test_install_is_idempotent_and_relaxes_the_root_level(root: logging.Logger) -> None:
+    ansilogs.install(logging.INFO, colors=False)
+    ansilogs.install(logging.INFO, colors=False)
+    (handler,) = _ours(root)
+    assert handler.level == logging.INFO
+    assert root.level == logging.INFO
+    ansilogs.set_level("DEBUG")
+    assert handler.level == logging.DEBUG
+    assert root.level == logging.DEBUG
+
+
+def test_set_level_installs_when_needed(root: logging.Logger) -> None:
+    ansilogs.set_level(logging.DEBUG)
+    (handler,) = _ours(root)
+    assert handler.level == logging.DEBUG
+
+
+def test_install_colors_follow_stderr(root: logging.Logger, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(sys, "stderr", io.StringIO())
+    ansilogs.install()
+    (handler,) = _ours(root)
+    formatter = handler.formatter
+    assert isinstance(formatter, ColoredFormatter)
+    assert not formatter.colors

ansilogs-1.0.0/tests/test_windows_console.py

@@ -0,0 +1,30 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+pytestmark = pytest.mark.skipif(sys.platform != "win32", reason="needs a Windows console")
+
+
+def test_install_turns_on_ansi_processing_in_a_real_console(tmp_path: Path) -> None:
+    report_path = tmp_path / "report.json"
+    child = Path(__file__).with_name("console_child.py")
+    subprocess.run(
+        [sys.executable, str(child), str(report_path)],
+        creationflags=subprocess.CREATE_NEW_CONSOLE if sys.platform == "win32" else 0,
+        check=True,
+        timeout=60,
+    )
+    report = json.loads(report_path.read_text(encoding="utf-8"))
+    assert report["stderr_is_console"], report
+    screen = report["screen"]
+    # Control: with processing off, the escape sequence lands on screen literally.
+    assert any("[33mCONTROL" in row for row in screen), screen
+    assert report["vt_after_install"], report
+    assert report["colors"], report
+    (line,) = [row for row in screen if "hello from a console" in row]
+    assert "WARNING hello from a console" in line
+    assert "\x1b" not in line
+    assert "[0m" not in line