loglit 1.0.0__tar.gz

loglit-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FMJ
+
+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.

loglit-1.0.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: loglit
+Version: 1.0.0
+Summary: Lightweight logging for Python. One import, no boilerplate.
+Author: FMJ
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Saecke/loglit
+Project-URL: Issues, https://github.com/Saecke/loglit/issues
+Keywords: logging,log,print,console,file
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# loglit
+
+Lightweight logging for Python. One import, no boilerplate.
+
+## The idea
+
+You already know `print()`. Now use `log()` to write to a file, or `printlog()` to write to console **and** file. That's it.
+
+**Without loglit** — the standard way:
+
+```python
+import logging
+import os
+from datetime import datetime
+
+log_dir = "logs"
+os.makedirs(log_dir, exist_ok=True)
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter("%(asctime)s - %(message)s", datefmt="%d-%m-%Y %H:%M:%S")
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(formatter)
+
+file_handler = logging.FileHandler(
+    os.path.join(log_dir, f"log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"),
+    encoding="utf-8",
+)
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+logger.info("Hello World")
+```
+
+**With loglit:**
+
+```python
+from loglit import log, printlog
+
+printlog("Hello World")
+```
+
+Same result. Zero setup.
+
+## Installation
+
+```bash
+pip install loglit
+```
+
+## Usage
+
+```python
+from loglit import log, printlog
+
+log("Only written to the log file.")
+printlog("Written to console and log file.")
+```
+
+- `log()` → writes to log file only (silent)
+- `printlog()` → writes to console **and** log file
+
+Log files are created automatically with a timestamp per session.
+
+## Configuration
+
+Configuration is optional. Only call `configure()` if you want to change something:
+
+```python
+from loglit import configure, log
+
+configure(log_dir="my_logs", file_prefix="myapp_", file_extension="txt")
+
+log("Done.")
+# → Log file: my_logs/myapp_22-03-2026_12-00-00.txt
+```
+
+The filename is built from these parts:
+
+```
+{file_prefix}{file_timestamp}{file_suffix}.{file_extension}
+ myapp_       22-03-2026_12-00-00              .txt
+```
+
+All options with their defaults:
+
+| Option             | Default                     | Description                       |
+|--------------------|-----------------------------|-----------------------------------|
+| `log_dir`          | `loglit/logs/`              | Directory for log files           |
+| `encoding`         | `utf-8`                     | Log file encoding                 |
+| `log_level`        | `logging.DEBUG`             | Minimum log level                 |
+| `log_format`       | `%(asctime)s - %(message)s` | Log line format                   |
+| `date_format`      | `%d-%m-%Y %H:%M:%S`        | Timestamp format in log lines     |
+| `file_prefix`      | `loglit_`                   | Filename prefix                   |
+| `file_suffix`      | `""`                        | Filename suffix (after timestamp) |
+| `file_extension`   | `log`                       | File extension                    |
+| `file_timestamp`   | `%d-%m-%Y_%H-%M-%S`        | Timestamp format in filename      |
+
+## Log Levels
+
+Standard Python log levels work out of the box:
+
+```python
+import logging
+from loglit import log, printlog
+
+log("Debug info", level=logging.DEBUG)           # file only
+printlog("Something happened", level=logging.INFO)  # file + console
+printlog("Watch out", level=logging.WARNING)         # file + console
+printlog("Something broke", level=logging.ERROR)     # file + console
+```
+
+## Examples
+
+See the [examples/](examples/) folder for ready-to-run scripts:
+
+- [basic.py](examples/basic.py) — minimal usage, no configuration
+- [configured.py](examples/configured.py) — all options customized
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+**Author:** FMJ

loglit-1.0.0/README.md

@@ -0,0 +1,132 @@
+# loglit
+
+Lightweight logging for Python. One import, no boilerplate.
+
+## The idea
+
+You already know `print()`. Now use `log()` to write to a file, or `printlog()` to write to console **and** file. That's it.
+
+**Without loglit** — the standard way:
+
+```python
+import logging
+import os
+from datetime import datetime
+
+log_dir = "logs"
+os.makedirs(log_dir, exist_ok=True)
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter("%(asctime)s - %(message)s", datefmt="%d-%m-%Y %H:%M:%S")
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(formatter)
+
+file_handler = logging.FileHandler(
+    os.path.join(log_dir, f"log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"),
+    encoding="utf-8",
+)
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+logger.info("Hello World")
+```
+
+**With loglit:**
+
+```python
+from loglit import log, printlog
+
+printlog("Hello World")
+```
+
+Same result. Zero setup.
+
+## Installation
+
+```bash
+pip install loglit
+```
+
+## Usage
+
+```python
+from loglit import log, printlog
+
+log("Only written to the log file.")
+printlog("Written to console and log file.")
+```
+
+- `log()` → writes to log file only (silent)
+- `printlog()` → writes to console **and** log file
+
+Log files are created automatically with a timestamp per session.
+
+## Configuration
+
+Configuration is optional. Only call `configure()` if you want to change something:
+
+```python
+from loglit import configure, log
+
+configure(log_dir="my_logs", file_prefix="myapp_", file_extension="txt")
+
+log("Done.")
+# → Log file: my_logs/myapp_22-03-2026_12-00-00.txt
+```
+
+The filename is built from these parts:
+
+```
+{file_prefix}{file_timestamp}{file_suffix}.{file_extension}
+ myapp_       22-03-2026_12-00-00              .txt
+```
+
+All options with their defaults:
+
+| Option             | Default                     | Description                       |
+|--------------------|-----------------------------|-----------------------------------|
+| `log_dir`          | `loglit/logs/`              | Directory for log files           |
+| `encoding`         | `utf-8`                     | Log file encoding                 |
+| `log_level`        | `logging.DEBUG`             | Minimum log level                 |
+| `log_format`       | `%(asctime)s - %(message)s` | Log line format                   |
+| `date_format`      | `%d-%m-%Y %H:%M:%S`        | Timestamp format in log lines     |
+| `file_prefix`      | `loglit_`                   | Filename prefix                   |
+| `file_suffix`      | `""`                        | Filename suffix (after timestamp) |
+| `file_extension`   | `log`                       | File extension                    |
+| `file_timestamp`   | `%d-%m-%Y_%H-%M-%S`        | Timestamp format in filename      |
+
+## Log Levels
+
+Standard Python log levels work out of the box:
+
+```python
+import logging
+from loglit import log, printlog
+
+log("Debug info", level=logging.DEBUG)           # file only
+printlog("Something happened", level=logging.INFO)  # file + console
+printlog("Watch out", level=logging.WARNING)         # file + console
+printlog("Something broke", level=logging.ERROR)     # file + console
+```
+
+## Examples
+
+See the [examples/](examples/) folder for ready-to-run scripts:
+
+- [basic.py](examples/basic.py) — minimal usage, no configuration
+- [configured.py](examples/configured.py) — all options customized
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+**Author:** FMJ

loglit-1.0.0/loglit/__init__.py

@@ -0,0 +1 @@
+from loglit.loglit import configure, log, printlog

loglit-1.0.0/loglit/loglit.py

@@ -0,0 +1,126 @@
+"""
+loglit - Lightweight logging for Python. One import, no boilerplate.
+
+Features:
+- log() for file logging, printlog() for console + file logging
+- configure() to customize without editing source code
+- Automatic timestamped log files
+- UTF-8 log files by default
+
+Author: FMJ
+License: MIT
+"""
+import os
+import sys
+import logging
+from datetime import datetime
+
+# --- Internal State ---
+_config = {
+    "log_dir": os.path.join(os.path.dirname(os.path.abspath(__file__)), "logs"),
+    "logger_name": "loglit",
+    "log_level": logging.DEBUG,
+    "log_format": "%(asctime)s - %(message)s",
+    "date_format": "%d-%m-%Y %H:%M:%S",
+    "encoding": "utf-8",
+    "file_prefix": "loglit_",
+    "file_suffix": "",
+    "file_extension": "log",
+    "file_timestamp": "%d-%m-%Y_%H-%M-%S",
+}
+
+_file_logger = None
+_print_logger = None
+_initialized = False
+
+
+def _generate_log_filename():
+    timestamp = datetime.now().strftime(_config["file_timestamp"])
+    name = f"{_config['file_prefix']}{timestamp}{_config['file_suffix']}"
+    return os.path.join(_config["log_dir"], f"{name}.{_config['file_extension']}")
+
+
+def _setup_logger():
+    global _file_logger, _print_logger, _initialized
+
+    os.makedirs(_config["log_dir"], exist_ok=True)
+
+    formatter = logging.Formatter(
+        _config["log_format"], datefmt=_config["date_format"]
+    )
+
+    file_handler = logging.FileHandler(
+        _generate_log_filename(), encoding=_config["encoding"]
+    )
+    file_handler.setLevel(_config["log_level"])
+    file_handler.setFormatter(formatter)
+
+    console_handler = logging.StreamHandler(stream=sys.stderr)
+    console_handler.setLevel(_config["log_level"])
+    console_handler.setFormatter(formatter)
+
+    # Close old handlers before replacing (prevents file handle leaks)
+    if _file_logger:
+        for h in _file_logger.handlers:
+            h.close()
+        _file_logger.handlers.clear()
+    if _print_logger:
+        for h in _print_logger.handlers:
+            h.close()
+        _print_logger.handlers.clear()
+
+    # log() → file only
+    _file_logger = logging.getLogger(_config["logger_name"] + ".file")
+    _file_logger.setLevel(_config["log_level"])
+    _file_logger.addHandler(file_handler)
+    _file_logger.propagate = False
+
+    # printlog() → file + console
+    _print_logger = logging.getLogger(_config["logger_name"] + ".print")
+    _print_logger.setLevel(_config["log_level"])
+    _print_logger.addHandler(file_handler)
+    _print_logger.addHandler(console_handler)
+    _print_logger.propagate = False
+
+    _initialized = True
+
+
+def _ensure_initialized():
+    if not _initialized:
+        _setup_logger()
+
+
+# --- Public API ---
+def configure(**kwargs):
+    """Configure the logger. Call before the first log() or printlog().
+
+    Keyword arguments:
+        log_dir (str):          Directory for log files. Default: loglit/logs/
+        encoding (str):         Log file encoding. Default: utf-8
+        log_level (int):        Minimum log level. Default: logging.DEBUG
+        log_format (str):       Log line format. Default: %(asctime)s - %(message)s
+        date_format (str):      Timestamp format. Default: %d-%m-%Y %H:%M:%S
+        file_prefix (str):      Filename prefix. Default: loglit_
+        file_suffix (str):      Filename suffix (after timestamp). Default: ""
+        file_extension (str):   File extension. Default: log
+        file_timestamp (str):   Timestamp format in filename. Default: %d-%m-%Y_%H-%M-%S
+    """
+    for key, value in kwargs.items():
+        if key not in _config:
+            raise ValueError(f"Unknown config option: '{key}'")
+        _config[key] = value
+
+    # (Re)initialize logger with new config
+    _setup_logger()
+
+
+def log(message, level=logging.INFO):
+    """Log a message to file only."""
+    _ensure_initialized()
+    _file_logger.log(level, message)
+
+
+def printlog(message, level=logging.INFO):
+    """Log a message to console and file."""
+    _ensure_initialized()
+    _print_logger.log(level, message)

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

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: loglit
+Version: 1.0.0
+Summary: Lightweight logging for Python. One import, no boilerplate.
+Author: FMJ
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Saecke/loglit
+Project-URL: Issues, https://github.com/Saecke/loglit/issues
+Keywords: logging,log,print,console,file
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# loglit
+
+Lightweight logging for Python. One import, no boilerplate.
+
+## The idea
+
+You already know `print()`. Now use `log()` to write to a file, or `printlog()` to write to console **and** file. That's it.
+
+**Without loglit** — the standard way:
+
+```python
+import logging
+import os
+from datetime import datetime
+
+log_dir = "logs"
+os.makedirs(log_dir, exist_ok=True)
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter("%(asctime)s - %(message)s", datefmt="%d-%m-%Y %H:%M:%S")
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(formatter)
+
+file_handler = logging.FileHandler(
+    os.path.join(log_dir, f"log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"),
+    encoding="utf-8",
+)
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+logger.info("Hello World")
+```
+
+**With loglit:**
+
+```python
+from loglit import log, printlog
+
+printlog("Hello World")
+```
+
+Same result. Zero setup.
+
+## Installation
+
+```bash
+pip install loglit
+```
+
+## Usage
+
+```python
+from loglit import log, printlog
+
+log("Only written to the log file.")
+printlog("Written to console and log file.")
+```
+
+- `log()` → writes to log file only (silent)
+- `printlog()` → writes to console **and** log file
+
+Log files are created automatically with a timestamp per session.
+
+## Configuration
+
+Configuration is optional. Only call `configure()` if you want to change something:
+
+```python
+from loglit import configure, log
+
+configure(log_dir="my_logs", file_prefix="myapp_", file_extension="txt")
+
+log("Done.")
+# → Log file: my_logs/myapp_22-03-2026_12-00-00.txt
+```
+
+The filename is built from these parts:
+
+```
+{file_prefix}{file_timestamp}{file_suffix}.{file_extension}
+ myapp_       22-03-2026_12-00-00              .txt
+```
+
+All options with their defaults:
+
+| Option             | Default                     | Description                       |
+|--------------------|-----------------------------|-----------------------------------|
+| `log_dir`          | `loglit/logs/`              | Directory for log files           |
+| `encoding`         | `utf-8`                     | Log file encoding                 |
+| `log_level`        | `logging.DEBUG`             | Minimum log level                 |
+| `log_format`       | `%(asctime)s - %(message)s` | Log line format                   |
+| `date_format`      | `%d-%m-%Y %H:%M:%S`        | Timestamp format in log lines     |
+| `file_prefix`      | `loglit_`                   | Filename prefix                   |
+| `file_suffix`      | `""`                        | Filename suffix (after timestamp) |
+| `file_extension`   | `log`                       | File extension                    |
+| `file_timestamp`   | `%d-%m-%Y_%H-%M-%S`        | Timestamp format in filename      |
+
+## Log Levels
+
+Standard Python log levels work out of the box:
+
+```python
+import logging
+from loglit import log, printlog
+
+log("Debug info", level=logging.DEBUG)           # file only
+printlog("Something happened", level=logging.INFO)  # file + console
+printlog("Watch out", level=logging.WARNING)         # file + console
+printlog("Something broke", level=logging.ERROR)     # file + console
+```
+
+## Examples
+
+See the [examples/](examples/) folder for ready-to-run scripts:
+
+- [basic.py](examples/basic.py) — minimal usage, no configuration
+- [configured.py](examples/configured.py) — all options customized
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+**Author:** FMJ

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

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+loglit/__init__.py
+loglit/loglit.py
+loglit.egg-info/PKG-INFO
+loglit.egg-info/SOURCES.txt
+loglit.egg-info/dependency_links.txt
+loglit.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+loglit

loglit-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "loglit"
+version = "1.0.0"
+description = "Lightweight logging for Python. One import, no boilerplate."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [{ name = "FMJ" }]
+keywords = ["logging", "log", "print", "console", "file"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "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",
+    "Topic :: System :: Logging",
+]
+
+[project.urls]
+Homepage = "https://github.com/Saecke/loglit"
+Issues = "https://github.com/Saecke/loglit/issues"

loglit-1.0.0/setup.cfg

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