nfo 0.1.9__tar.gz

nfo-0.1.9/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

nfo-0.1.9/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: nfo
+Version: 0.1.9
+Summary: Automatic function logging with decorators — output to SQLite, CSV, and Markdown
+Author: wronai
+License-Expression: Apache-2.0
+Keywords: logging,decorator,sqlite,csv,markdown,auto-logging
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: license-file
+
+# lg
+
+
+Tak, istnieją biblioteki Pythona, które automatyzują generowanie logów w funkcjach na podstawie analizy kodu, typów danych czy struktur jak try-except.
+
+## Loguru
+Loguru to popularna biblioteka oferująca dekoratory do automatycznego logowania wejścia/wyjścia funkcji oraz wyjątków.  
+Używa się jej prosto: `@loguru.logger.catch` na funkcji automatycznie przechwytuje błędy i loguje szczegóły, w tym argumenty i typy.  
+Przykład: dekorator loguje parametry wejściowe, wyjątki z traceback oraz czas wykonania bez pisania ręcznych logów. [pktiuk.github](https://pktiuk.github.io/notatki_z_jezykow/Python%F0%9F%90%8D/4_biblioteki_i_narz%C4%99dzia/)
+
+## Decorator logowania
+Biblioteka `funcy` lub proste dekoratory z `functools` pozwalają tworzyć customowe wrappery analizujące `inspect.signature()` dla typów argumentów.  
+Można dynamicznie logować nazwy parametrów, ich typy (`type(arg)`) i wartości przy wejściu/wyjściu.  
+Dla zaawansowanych przypadków `pydantic` integruje walidację typów z automatycznymi logami błędów walidacji w blokach try-except. [bulldogjob](https://bulldogjob.pl/readme/przewodnik-dla-poczatkujacych-po-pydantic-pythona)
+
+## Funkcjonalne podejście
+Własny dekorator z `inspect` i `logging` może skanować strukturę kodu (ast.parse) i generować logi debug na podstawie obecności try-catch czy typów.  
+Biblioteki jak `wrapt` ułatwiają takie wrappingi bez modyfikacji oryginalnych funkcji.  
+To idealne dla Twoich projektów z embedded systems i automatyzacją, gdzie chcesz minimalizować boilerplate. [pktiuk.github](https://pktiuk.github.io/notatki_z_jezykow/Python%F0%9F%90%8D/4_biblioteki_i_narz%C4%99dzia/)
+
+
+
+Tak, Loguru i standardowy logging z custom handlerami umożliwiają eksport logów bezpośrednio do SQLite, CSV czy Markdown poprzez konfigurację sinków lub handlerów. Poniżej przykłady użycia z automatycznym logowaniem (dekoratory) i outputem do plików.
+
+## Przykład Loguru z dekoratorem i CSV
+Loguru pozwala dodać sink do pliku CSV, logując automatycznie argumenty, wyjątki z try-catch i typy danych.
+
+```python
+from loguru import logger
+
+# Dodaj sink CSV (automatycznie strukturyzuje logi)
+logger.add("logs.csv", format="{time} | {level} | {name}:{function}:{line} | {message}", serialize=True)
+
+@logger.catch  # Automatycznie loguje wejście/wyjście i wyjątki
+def moja_funkcja(x: int, y: str):
+    return x / len(y)  # Przykładowy błąd
+
+moja_funkcja(10, "")  # Loguje do CSV z typami i traceback [web:23][web:13]
+```
+
+Wynik w CSV: kolumny jak time, level, message z JSON-serializowanymi danymi (argumenty, typy). [github](https://github.com/Delgan/loguru/blob/master/README.md)
+
+## Loguru do Markdown
+Loguru sink do Markdown generuje czytelne logi z nagłówkami i formatowaniem.
+
+```python
+logger.add("logs.md", format="## {time:YYYY-MM-DD HH:mm:ss} | {level}\n{ message }\n", colorize=False)
+
+@logger.catch
+def test_funkcja(data):
+    raise ValueError("Błąd typów")
+
+test_funkcja({"key": "value"})  # Logi z markdown: ## nagłówki, kody bloków [web:21]
+```
+
+Plik MD: struktura z datą, poziomem, pełnym traceback i zmiennymi. [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/)
+
+## SQLite Handler dla logging/Loguru
+Użyj `python-sqlite-log-handler` lub custom handler do bazy danych; integruje z dekoratorami.
+
+```python
+import logging
+from python_sqlite_log_handler import SQLiteLogHandler  # pip install python-sqlite-log-handler
+
+logger = logging.getLogger("app")
+handler = SQLiteLogHandler(db_path="logs.db")  # Tworzy tabelę logs
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG)
+
+def try_catch_logger(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Błąd w {func.__name__}: {e}", exc_info=True)
+            raise
+    return wrapper
+
+@try_catch_logger
+def funkcja_z_db(arg: dict):
+    if not arg: raise KeyError("Brak danych")
+
+funkcja_z_db({})  # Loguje do SQLite: created_at, level, message, extra z typami [web:15][web:12]
+```
+
+Query SQL: `SELECT * FROM logs WHERE level >= 30` – łatwe filtrowanie. [pypi](https://pypi.org/project/python-sqlite-log-handler/)
+
+## Porównanie outputów
+| Biblioteka/Handler | SQLite | CSV | Markdown | Automatyczne dekoratory |
+|--------------------|--------|-----|----------|------------------------|
+| Loguru            | Tak (custom sink)  [stackoverflow](https://stackoverflow.com/questions/67693767/how-do-i-create-an-sqlite-3-database-handler-for-my-python-logger) | Tak (serialize=True)  [github](https://github.com/Delgan/loguru/blob/master/README.md) | Tak (format MD)  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) | @logger.catch  [datacamp](https://www.datacamp.com/tutorial/loguru-python-logging-tutorial) |
+| logging + sqlite-handler | Tak (natywnie)  [pypi](https://pypi.org/project/python-sqlite-log-handler/) | Tak (CSVHandler) | Custom formatter | Custom @try_catch  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) |
+
+
+
+
+## Analiza rozwiązań do automatycznego logowania w Pythonie
+
+Istnieją cztery główne biblioteki umożliwiające automatyczne logi w funkcjach na bazie typów danych, struktur kodu (try-catch) i dekoratorów. Loguru jest najpopularniejszy (15k+ gwiazdek GitHub), structlog skupia się na strukturyzowanych logach, Eliot na wizualizacji, a standardowy logging z rozszerzeniami na elastyczność. [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/)
+
+## Szczegółowa tabela porównawcza
+
+| Biblioteka       | Automatyczne logi (dekoratory) | Analiza typów/struktury kodu | Obsługa SQLite | Obsługa CSV | Obsługa Markdown | Zalety | Wady | GitHub Stars (2026) | Ostatnia aktualizacja |
+|------------------|-------------------------------|------------------------------|----------------|-------------|------------------|--------|------|---------------------|-----------------------|
+| **Loguru**  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Tak (@logger.catch: wejście/wyjście, wyjątki, traceback) | Częściowa (loguje args via inspect, typy w serializacji) | Tak (custom sink z sqlite3)  [stackoverflow](https://stackoverflow.com/questions/67693767/how-do-i-create-an-sqlite-3-database-handler-for-my-python-logger) | Tak (serialize=True, CSV format)  [github](https://github.com/Delgan/loguru/blob/master/README.md) | Tak (custom format z ## nagłówkami)  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) | Zero-config, rotation plików, structured JSON, kolorowanie | Nie threaded-safe domyślnie | 15k+  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Aktywna (2024-12)  [pypi](https://pypi.org/project/loguru/) |
+| **structlog**  [matthewstrawbridge](https://www.matthewstrawbridge.com/content/2024/python-logging-basic-better-best/) | Tak (bind_context, processors dla func args) | Tak (structured metadata z typami, AST via processors) | Tak (via JSON + sqlite insert)  [stackoverflow](https://stackoverflow.com/questions/67693767/how-do-i-create-an-sqlite-3-database-handler-for-my-python-logger) | Tak (JSON/CSV processors) | Tak (custom renderer) | Structured logs, async, OpenTelemetry | Więcej configu niż Loguru | Wysokie (top 6)  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Aktywna  [dash0](https://www.dash0.com/guides/python-logging-with-structlog) |
+| **Eliot**  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Tak (@log_call: pełne wejście/wyjście funkcji) | Tak (strukturyzowane eventy z typami) | Tak (JSON do SQLite) | Tak (JSON export) | Częściowa (JSON -> MD via tree) | Wizualizacja (eliot-tree CLI), narracyjne logi | Brak poziomów logów | Średnie  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Stabilna |
+| **logging std + handlers**  [reddit](https://www.reddit.com/r/Python/comments/1p6qy1e/spent_a_bunch_of_time_choosing_between_loguru/) | Tak (custom @decorator z inspect/traceback)  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) | Tak (via inspect.signature, ast.parse) | Tak (python-sqlite-log-handler)  [pypi](https://pypi.org/project/python-sqlite-log-handler/) | Tak (CSVHandler/FileHandler) | Tak (custom Formatter) | Natywny, config files, threaded | Boilerplate bez dekoratorów | Wbudowany | Python 3.14  [docs.python](https://docs.python.org/pl/3/tutorial/errors.html) |
+
+## Rekomendacje dla Twoich projektów
+Dla embedded/automatyzacji (RPi/ESP32) wybierz **Loguru** – prosty, lekki, integruje z Docker/K8s. Do biznesu (ERP/legal) **structlog** dla searchable JSON/SQLite. Przykłady kodu z poprzednich odpowiedzi działają out-of-box po `pip install loguru python-sqlite-log-handler`. [reddit](https://www.reddit.com/r/Python/comments/1p6qy1e/spent_a_bunch_of_time_choosing_between_loguru/)
+
+
+
+W dobie LLM i multisrodowiskowych aplikacji (embedded, Docker/K8s, CI/CD) brakuje kilku kluczowych funkcji w bibliotekach logujących jak Loguru/structlog.
+
+## Braki w automatycznym logowaniu
+
+**Brak natywnej integracji z LLM do kontekstowego parsowania logów**  
+Żadna biblioteka nie analizuje logów przez LLM w locie (np. "ten wyjątek TypeError sugeruje brak walidacji int w argumencie x") ani nie generuje sugestii fixów bezpośrednio w logu. W CI/CD z LLM to kluczowe dla szybkiej iteracji. [ijamjournal](https://ijamjournal.org/ijam/publication/index.php/ijam/article/view/77/)
+
+## Tabela brakujących funkcji
+
+| Brakująca funkcja | Opis problemu | Przykład zastosowania w Twoich projektach |
+|-------------------|---------------|------------------------------------------|
+| **LLM-powered log parsing** | Logi tylko statyczne; brak AI do grupowania podobnych błędów czy predykcji root cause | W embedded RPi: LLM grupuje "I2C timeout" z sensorami i sugeruje "sprawdź zasilanie" |
+| **Multi-env log correlation** | Brak automatycznego tagowania środowisk (dev/staging/prod) + trace ID dla K8s pods | CI/CD deploy do Docker: brak linku "błąd w pod-3 → Git commit abc123" |
+| **Dynamic sink routing** | Ręczne config sinków (SQLite/CSV); brak auto-przełączania na bazie env/variable types | Prod → Elasticsearch, dev → Markdown; bez config files |
+| **Structured diff logs** | Nie loguje zmian input/output między wersjami funkcji w CI/CD | A/B test funkcji: "v1.2.1 input dict → output None, v1.2.2 → output list" |
+| **Prompt injection detection** | Brak auto-detektu LLM prompt injection w logach API calls | Twoja automatyzacja prawna: loguje "znajdź lukę w umowie X" → flaga bezpieczeństwa |
+
+## Proponowane rozszerzenia dla CI/CD + LLM
+
+```python
+# Wyobrażone Loguru 3.0 z LLM integration
+from loguru_llm import LLMAnalyzer
+
+@logger.catch(llm_analyzer=LLMAnalyzer(model="gpt-4o-mini"))
+def risky_function(user_input: str):
+    # LLM auto-parsuje exception i dodaje: "Prawdopodobna przyczyna: SQL injection"
+    return eval(user_input)  # danger!
+```
+
+**Dla Twoich projektów**: Stwórz custom sink z LangChain + Pinecone vector DB do semantycznego searchu logów ("pokaż wszystkie TypeError z dict arg w ciągu 7 dni") i GitHub Actions step z LLM code review na bazie logów z failed builds. [github](https://github.com/charliepaks/llm-cicd)

nfo-0.1.9/README.md

@@ -0,0 +1,144 @@
+# lg
+
+
+Tak, istnieją biblioteki Pythona, które automatyzują generowanie logów w funkcjach na podstawie analizy kodu, typów danych czy struktur jak try-except.
+
+## Loguru
+Loguru to popularna biblioteka oferująca dekoratory do automatycznego logowania wejścia/wyjścia funkcji oraz wyjątków.  
+Używa się jej prosto: `@loguru.logger.catch` na funkcji automatycznie przechwytuje błędy i loguje szczegóły, w tym argumenty i typy.  
+Przykład: dekorator loguje parametry wejściowe, wyjątki z traceback oraz czas wykonania bez pisania ręcznych logów. [pktiuk.github](https://pktiuk.github.io/notatki_z_jezykow/Python%F0%9F%90%8D/4_biblioteki_i_narz%C4%99dzia/)
+
+## Decorator logowania
+Biblioteka `funcy` lub proste dekoratory z `functools` pozwalają tworzyć customowe wrappery analizujące `inspect.signature()` dla typów argumentów.  
+Można dynamicznie logować nazwy parametrów, ich typy (`type(arg)`) i wartości przy wejściu/wyjściu.  
+Dla zaawansowanych przypadków `pydantic` integruje walidację typów z automatycznymi logami błędów walidacji w blokach try-except. [bulldogjob](https://bulldogjob.pl/readme/przewodnik-dla-poczatkujacych-po-pydantic-pythona)
+
+## Funkcjonalne podejście
+Własny dekorator z `inspect` i `logging` może skanować strukturę kodu (ast.parse) i generować logi debug na podstawie obecności try-catch czy typów.  
+Biblioteki jak `wrapt` ułatwiają takie wrappingi bez modyfikacji oryginalnych funkcji.  
+To idealne dla Twoich projektów z embedded systems i automatyzacją, gdzie chcesz minimalizować boilerplate. [pktiuk.github](https://pktiuk.github.io/notatki_z_jezykow/Python%F0%9F%90%8D/4_biblioteki_i_narz%C4%99dzia/)
+
+
+
+Tak, Loguru i standardowy logging z custom handlerami umożliwiają eksport logów bezpośrednio do SQLite, CSV czy Markdown poprzez konfigurację sinków lub handlerów. Poniżej przykłady użycia z automatycznym logowaniem (dekoratory) i outputem do plików.
+
+## Przykład Loguru z dekoratorem i CSV
+Loguru pozwala dodać sink do pliku CSV, logując automatycznie argumenty, wyjątki z try-catch i typy danych.
+
+```python
+from loguru import logger
+
+# Dodaj sink CSV (automatycznie strukturyzuje logi)
+logger.add("logs.csv", format="{time} | {level} | {name}:{function}:{line} | {message}", serialize=True)
+
+@logger.catch  # Automatycznie loguje wejście/wyjście i wyjątki
+def moja_funkcja(x: int, y: str):
+    return x / len(y)  # Przykładowy błąd
+
+moja_funkcja(10, "")  # Loguje do CSV z typami i traceback [web:23][web:13]
+```
+
+Wynik w CSV: kolumny jak time, level, message z JSON-serializowanymi danymi (argumenty, typy). [github](https://github.com/Delgan/loguru/blob/master/README.md)
+
+## Loguru do Markdown
+Loguru sink do Markdown generuje czytelne logi z nagłówkami i formatowaniem.
+
+```python
+logger.add("logs.md", format="## {time:YYYY-MM-DD HH:mm:ss} | {level}\n{ message }\n", colorize=False)
+
+@logger.catch
+def test_funkcja(data):
+    raise ValueError("Błąd typów")
+
+test_funkcja({"key": "value"})  # Logi z markdown: ## nagłówki, kody bloków [web:21]
+```
+
+Plik MD: struktura z datą, poziomem, pełnym traceback i zmiennymi. [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/)
+
+## SQLite Handler dla logging/Loguru
+Użyj `python-sqlite-log-handler` lub custom handler do bazy danych; integruje z dekoratorami.
+
+```python
+import logging
+from python_sqlite_log_handler import SQLiteLogHandler  # pip install python-sqlite-log-handler
+
+logger = logging.getLogger("app")
+handler = SQLiteLogHandler(db_path="logs.db")  # Tworzy tabelę logs
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG)
+
+def try_catch_logger(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Błąd w {func.__name__}: {e}", exc_info=True)
+            raise
+    return wrapper
+
+@try_catch_logger
+def funkcja_z_db(arg: dict):
+    if not arg: raise KeyError("Brak danych")
+
+funkcja_z_db({})  # Loguje do SQLite: created_at, level, message, extra z typami [web:15][web:12]
+```
+
+Query SQL: `SELECT * FROM logs WHERE level >= 30` – łatwe filtrowanie. [pypi](https://pypi.org/project/python-sqlite-log-handler/)
+
+## Porównanie outputów
+| Biblioteka/Handler | SQLite | CSV | Markdown | Automatyczne dekoratory |
+|--------------------|--------|-----|----------|------------------------|
+| Loguru            | Tak (custom sink)  [stackoverflow](https://stackoverflow.com/questions/67693767/how-do-i-create-an-sqlite-3-database-handler-for-my-python-logger) | Tak (serialize=True)  [github](https://github.com/Delgan/loguru/blob/master/README.md) | Tak (format MD)  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) | @logger.catch  [datacamp](https://www.datacamp.com/tutorial/loguru-python-logging-tutorial) |
+| logging + sqlite-handler | Tak (natywnie)  [pypi](https://pypi.org/project/python-sqlite-log-handler/) | Tak (CSVHandler) | Custom formatter | Custom @try_catch  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) |
+
+
+
+
+## Analiza rozwiązań do automatycznego logowania w Pythonie
+
+Istnieją cztery główne biblioteki umożliwiające automatyczne logi w funkcjach na bazie typów danych, struktur kodu (try-catch) i dekoratorów. Loguru jest najpopularniejszy (15k+ gwiazdek GitHub), structlog skupia się na strukturyzowanych logach, Eliot na wizualizacji, a standardowy logging z rozszerzeniami na elastyczność. [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/)
+
+## Szczegółowa tabela porównawcza
+
+| Biblioteka       | Automatyczne logi (dekoratory) | Analiza typów/struktury kodu | Obsługa SQLite | Obsługa CSV | Obsługa Markdown | Zalety | Wady | GitHub Stars (2026) | Ostatnia aktualizacja |
+|------------------|-------------------------------|------------------------------|----------------|-------------|------------------|--------|------|---------------------|-----------------------|
+| **Loguru**  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Tak (@logger.catch: wejście/wyjście, wyjątki, traceback) | Częściowa (loguje args via inspect, typy w serializacji) | Tak (custom sink z sqlite3)  [stackoverflow](https://stackoverflow.com/questions/67693767/how-do-i-create-an-sqlite-3-database-handler-for-my-python-logger) | Tak (serialize=True, CSV format)  [github](https://github.com/Delgan/loguru/blob/master/README.md) | Tak (custom format z ## nagłówkami)  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) | Zero-config, rotation plików, structured JSON, kolorowanie | Nie threaded-safe domyślnie | 15k+  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Aktywna (2024-12)  [pypi](https://pypi.org/project/loguru/) |
+| **structlog**  [matthewstrawbridge](https://www.matthewstrawbridge.com/content/2024/python-logging-basic-better-best/) | Tak (bind_context, processors dla func args) | Tak (structured metadata z typami, AST via processors) | Tak (via JSON + sqlite insert)  [stackoverflow](https://stackoverflow.com/questions/67693767/how-do-i-create-an-sqlite-3-database-handler-for-my-python-logger) | Tak (JSON/CSV processors) | Tak (custom renderer) | Structured logs, async, OpenTelemetry | Więcej configu niż Loguru | Wysokie (top 6)  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Aktywna  [dash0](https://www.dash0.com/guides/python-logging-with-structlog) |
+| **Eliot**  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Tak (@log_call: pełne wejście/wyjście funkcji) | Tak (strukturyzowane eventy z typami) | Tak (JSON do SQLite) | Tak (JSON export) | Częściowa (JSON -> MD via tree) | Wizualizacja (eliot-tree CLI), narracyjne logi | Brak poziomów logów | Średnie  [betterstack](https://betterstack.com/community/guides/logging/best-python-logging-libraries/) | Stabilna |
+| **logging std + handlers**  [reddit](https://www.reddit.com/r/Python/comments/1p6qy1e/spent_a_bunch_of_time_choosing_between_loguru/) | Tak (custom @decorator z inspect/traceback)  [jojoduquartier.github](https://jojoduquartier.github.io/snippets/logging_decorator/) | Tak (via inspect.signature, ast.parse) | Tak (python-sqlite-log-handler)  [pypi](https://pypi.org/project/python-sqlite-log-handler/) | Tak (CSVHandler/FileHandler) | Tak (custom Formatter) | Natywny, config files, threaded | Boilerplate bez dekoratorów | Wbudowany | Python 3.14  [docs.python](https://docs.python.org/pl/3/tutorial/errors.html) |
+
+## Rekomendacje dla Twoich projektów
+Dla embedded/automatyzacji (RPi/ESP32) wybierz **Loguru** – prosty, lekki, integruje z Docker/K8s. Do biznesu (ERP/legal) **structlog** dla searchable JSON/SQLite. Przykłady kodu z poprzednich odpowiedzi działają out-of-box po `pip install loguru python-sqlite-log-handler`. [reddit](https://www.reddit.com/r/Python/comments/1p6qy1e/spent_a_bunch_of_time_choosing_between_loguru/)
+
+
+
+W dobie LLM i multisrodowiskowych aplikacji (embedded, Docker/K8s, CI/CD) brakuje kilku kluczowych funkcji w bibliotekach logujących jak Loguru/structlog.
+
+## Braki w automatycznym logowaniu
+
+**Brak natywnej integracji z LLM do kontekstowego parsowania logów**  
+Żadna biblioteka nie analizuje logów przez LLM w locie (np. "ten wyjątek TypeError sugeruje brak walidacji int w argumencie x") ani nie generuje sugestii fixów bezpośrednio w logu. W CI/CD z LLM to kluczowe dla szybkiej iteracji. [ijamjournal](https://ijamjournal.org/ijam/publication/index.php/ijam/article/view/77/)
+
+## Tabela brakujących funkcji
+
+| Brakująca funkcja | Opis problemu | Przykład zastosowania w Twoich projektach |
+|-------------------|---------------|------------------------------------------|
+| **LLM-powered log parsing** | Logi tylko statyczne; brak AI do grupowania podobnych błędów czy predykcji root cause | W embedded RPi: LLM grupuje "I2C timeout" z sensorami i sugeruje "sprawdź zasilanie" |
+| **Multi-env log correlation** | Brak automatycznego tagowania środowisk (dev/staging/prod) + trace ID dla K8s pods | CI/CD deploy do Docker: brak linku "błąd w pod-3 → Git commit abc123" |
+| **Dynamic sink routing** | Ręczne config sinków (SQLite/CSV); brak auto-przełączania na bazie env/variable types | Prod → Elasticsearch, dev → Markdown; bez config files |
+| **Structured diff logs** | Nie loguje zmian input/output między wersjami funkcji w CI/CD | A/B test funkcji: "v1.2.1 input dict → output None, v1.2.2 → output list" |
+| **Prompt injection detection** | Brak auto-detektu LLM prompt injection w logach API calls | Twoja automatyzacja prawna: loguje "znajdź lukę w umowie X" → flaga bezpieczeństwa |
+
+## Proponowane rozszerzenia dla CI/CD + LLM
+
+```python
+# Wyobrażone Loguru 3.0 z LLM integration
+from loguru_llm import LLMAnalyzer
+
+@logger.catch(llm_analyzer=LLMAnalyzer(model="gpt-4o-mini"))
+def risky_function(user_input: str):
+    # LLM auto-parsuje exception i dodaje: "Prawdopodobna przyczyna: SQL injection"
+    return eval(user_input)  # danger!
+```
+
+**Dla Twoich projektów**: Stwórz custom sink z LangChain + Pinecone vector DB do semantycznego searchu logów ("pokaż wszystkie TypeError z dict arg w ciągu 7 dni") i GitHub Actions step z LLM code review na bazie logów z failed builds. [github](https://github.com/charliepaks/llm-cicd)

nfo-0.1.9/lg/__init__.py

@@ -0,0 +1,20 @@
+"""
+lg — Automatic function logging with decorators.
+
+Output to SQLite, CSV, and Markdown.
+"""
+
+from lg.decorators import log_call, catch
+from lg.logger import Logger
+from lg.sinks import SQLiteSink, CSVSink, MarkdownSink
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "log_call",
+    "catch",
+    "Logger",
+    "SQLiteSink",
+    "CSVSink",
+    "MarkdownSink",
+]