cledar-sdk 1.2.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

{cledar_sdk-1.2.0.dist-info → cledar_sdk-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cledar-sdk
-Version: 1.2.0
+Version: 1.2.1
 Summary: Cledar Python SDK
 Author: Cledar
 License-File: LICENSE

{cledar_sdk-1.2.0.dist-info → cledar_sdk-1.2.1.dist-info}/RECORD

@@ -1,3 +1,7 @@
+common_logging/README.md,sha256=DIGwhCPugbeQ_tggXIVGi4NYkPZFtJcrO1RQksXxdPk,1798
+common_logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+common_logging/universal_plaintext_formatter.py,sha256=ExuXwfZmc_4tp3RIsoe_ByYpnTN0iQBOi101FB8hksc,3309
+common_logging/tests/test_universal_plaintext_formatter.py,sha256=bY6vvpra81_YXN2MLVjNuA8Iu7kOaZH0lmQMsohjRPI,8560
 kafka_service/README.md,sha256=3lKulsfEUs6qaKExlpPkxT_X1NYBAHraiqQRdvkQ48I,7021
 kafka_service/__init__.py,sha256=yHPDvgkwcM4vtJ2nvSsw9Sc0XqEoWUwhewRXH7x1V3A,1012
 kafka_service/exceptions.py,sha256=LJ-mUYCwoQsDM-bL4ms9ZCiWIOw5kt1KStbN04Mavl0,501
@@ -33,12 +37,44 @@ kafka_service/tests/unit/test_utils_comprehensive.py,sha256=VjyHgZDhilYtLEBFNedc
 kafka_service/utils/callbacks.py,sha256=mqs94wLhnVQTYrN-taD57FRU4K3jXHnNaZLIbBbgFGc,588
 kafka_service/utils/messages.py,sha256=j3Lr1_Rwr2FqepfhM-Jw4kaU3PkvqgugDeYzQsH7L60,738
 kafka_service/utils/topics.py,sha256=ekh7nJwUOojgfil7Ntef_FbebA1ExUcgp1QWUTj0Ywc,118
+kserve_service/README.md,sha256=b15WY_y96UiLAlbbtioua2esswtp3m7pLrhoOCy9q_o,8722
+kserve_service/__init__.py,sha256=XROt6VPOY8_vzt6vkiNAB4ffbgOAHOBlNrWrqmJOmgQ,66
+kserve_service/utils.py,sha256=Q6V-sws5dkIGZKW7XCKIPQ1Qs6itu2eLZ2mfW0HM20w,897
+kserve_service/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kserve_service/tests/test_utils.py,sha256=5XoSkr6tbDCJ7mV-jqaT7AlrKFAyk3hnRQh-u67KJd0,1678
 monitoring_service/README.md,sha256=UdcfEXK3IhCeBhYdrrV45DXh7FTAK72bXBmUDnqZY8E,2148
 monitoring_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monitoring_service/monitoring_server.py,sha256=lBnImACViG6QE70RFTziDg8zh0FJsiza6knPI-rvsE8,3488
 monitoring_service/tests/test_monitoring_server.py,sha256=urL2seruM_peNIr7c4hblGfEDjqQUzhPCE2gXIJ_Vf8,1657
 monitoring_service/tests/integration/test_monitoring_server_int.py,sha256=5PP-nm-gZPMyShccYUU17TfRprWq2Ij6Y1YA6JnN9jE,5359
-cledar_sdk-1.2.0.dist-info/METADATA,sha256=UveAiUFJICL4WhvllDT7McaYBVW2P3uZIWnBQwlmLrQ,6752
-cledar_sdk-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cledar_sdk-1.2.0.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-cledar_sdk-1.2.0.dist-info/RECORD,,
+nonce_service/README.md,sha256=sPxpA9UJfrqCWidNmzgdcXGT_-6SxPvysnhsSvC5FEo,3533
+nonce_service/__init__.py,sha256=Rh6JWML_ncfb_t_mVl7PIKOXpELRdfunMsFWAtbt5EE,68
+nonce_service/nonce_service.py,sha256=6RhA2eEztH_pNdjkBI5eqmRh14I96NjgVYy2v_z7vdM,1100
+nonce_service/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nonce_service/tests/test_nonce_service.py,sha256=sWzCBXghZNDOnSo8NQB6tyJJ95g2tZGRPlThFqD2P7g,4047
+redis_service/README.md,sha256=GFzNRpCvPRl-QoOFiDTmj1ncgUoU_HaJV74zVtdwG9M,10176
+redis_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+redis_service/example.py,sha256=OApl0JU59viBUZORLxlYBhVMdCc5QvOBdOjscxbm_aQ,1091
+redis_service/exceptions.py,sha256=vvD7SO0xHutSLvUf0ttMo7C6OeaVi8f3bxMservsSVI,737
+redis_service/logger.py,sha256=OBOTx6zk_6wkpB2N_FRV7gXR3xy4dpy4iX2B0oFfZ90,60
+redis_service/model.py,sha256=ykW_KHygNHhfHPvP2RyJj0g_WENXxJEP2HvGy7Yb4uo,174
+redis_service/redis.py,sha256=d8hqkVokVs6eMsteJEsEYZ56nb7WhTQ8Gc_sT4zkSRY,9974
+redis_service/redis_config_store.py,sha256=EFhyvg_Eklrh2tc5dtFpe6nnjMDkTqYT_egclhf0KaI,8919
+redis_service/tests/test_integration_redis.py,sha256=O3z5EgkeB6Sd9C1S3rRMW916bybDCAHb-DgTFZGLTqI,3345
+redis_service/tests/test_redis_service.py,sha256=n3FIYBk9SGzpDkRWnPj-Mi3NKYtDEpbwgjpjb_JwjF4,10252
+storage_service/README.md,sha256=Rkew1joVijHVEfyXS9C7dDw55rQ4HYRbHkRYlZiREak,15655
+storage_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+storage_service/constants.py,sha256=O6qHRQafs35_3TUShxtE2kq1lI4HQ-NRs2oWQFMt7Ko,85
+storage_service/exceptions.py,sha256=ItDsFU0Jzdg94yfXkLoC-Wp0Pz-XryNAypZDxpDNRnk,715
+storage_service/models.py,sha256=m1h1xx0YkdY6TIwrcBKKtZrzF1CltKzL-UQZgmP0MOQ,484
+storage_service/object_storage.py,sha256=wpZyEZvidLWgZli5BH_zCFWL42AwK9oN2pXBPVTmsHY,35830
+storage_service/tests/conftest.py,sha256=UfEjadRrCQuLbc9kNU8Y_8NWTyEp1DXmJ4nmb8hWU6k,467
+storage_service/tests/test_abfs.py,sha256=i7-yAlIjIDB8fkdOVz994bU62SMDK4VcRR9uu1OB7ic,5869
+storage_service/tests/test_integration_filesystem.py,sha256=-H3Skc_geYIjXW1si-8uHVxVImmPzr8h6aGYMolzORk,11174
+storage_service/tests/test_integration_s3.py,sha256=Ivg_52LXibqVGMS-53z4zda_Yh4u6FO8WplUUu5WWBc,13614
+storage_service/tests/test_local.py,sha256=3CgtxQ_lBBaPR4t9Ip0i7T98scrTOCdkmHYMVansNCc,11256
+storage_service/tests/test_s3.py,sha256=zAppsvVCeLx_NN1tQfqHo57mONEjeFDmiwyecrS3ZgQ,16355
+cledar_sdk-1.2.1.dist-info/METADATA,sha256=9087LMoW_Hd1TC5jwPFbg_w8a43r1ug9ssJJ_02gEzA,6752
+cledar_sdk-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cledar_sdk-1.2.1.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+cledar_sdk-1.2.1.dist-info/RECORD,,

common_logging/README.md

@@ -0,0 +1,53 @@
+# Universal Formatter
+
+The `UniversalPlaintextFormatter` is a custom logging formatter that extends the standard `logging.Formatter` class. It adds the ability to include extra attributes from log records while excluding standard attributes and configurable keys.
+
+## Usage
+
+To use the `UniversalPlaintextFormatter` in your logging configuration, add the following to your `logging.conf` file:
+
+```ini
+[formatter_plaintextFormatter]
+class=questions_generator.common_services.logging.universal_formatter.UniversalPlaintextFormatter
+format=%(asctime)s %(name)s [%(levelname)s]: %(message)s
+datefmt=%Y-%m-%d %H:%M:%S
+```
+
+## Features
+
+- Extends the standard logging.Formatter
+- Automatically includes extra attributes from log records
+- Excludes standard LogRecord attributes to keep logs clean
+- Configurable exclusion of additional keys
+
+## Configuration Options
+
+In addition to the standard formatter options, you can configure which keys to exclude from the log output:
+
+```ini
+[formatter_plaintextFormatter]
+class=questions_generator.common_services.logging.universal_formatter.UniversalPlaintextFormatter
+format=%(asctime)s %(name)s [%(levelname)s]: %(message)s
+datefmt=%Y-%m-%d %H:%M:%S
+exclude_keys=key1,key2,key3
+```
+
+The `exclude_keys` option allows you to specify a comma-separated list of keys that should be excluded from the log output, in addition to the standard LogRecord attributes.
+
+## Example
+
+When using this formatter, any extra attributes added to the log record will be automatically included in the log output:
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+logger.info("User logged in", extra={"user_id": 123, "ip_address": "192.168.1.1"})
+```
+
+Output:
+```
+2023-08-04 12:34:56 my_module [INFO]: User logged in
+    user_id: 123
+    ip_address: 192.168.1.1
+```

common_logging/tests/test_universal_plaintext_formatter.py

@@ -0,0 +1,249 @@
+# pylint: disable=unused-argument, protected-access
+import logging
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from common_logging.universal_plaintext_formatter import UniversalPlaintextFormatter
+
+
+@pytest.fixture(name="formatter")
+def fixture_formatter() -> UniversalPlaintextFormatter:
+    """Create a basic formatter instance for testing."""
+    return UniversalPlaintextFormatter(
+        fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+
+@pytest.fixture(name="log_record")
+def fixture_log_record() -> logging.LogRecord:
+    """Create a basic log record for testing."""
+    return logging.LogRecord(
+        name="test_logger",
+        level=logging.INFO,
+        pathname="/path/to/file.py",
+        lineno=42,
+        msg="Test message",
+        args=(),
+        exc_info=None,
+    )
+
+
+def test_basic_formatting_without_extras(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test that basic formatting works without extra attributes."""
+    formatted = formatter.format(log_record)
+    assert "Test message" in formatted
+    assert "test_logger" in formatted
+    assert "INFO" in formatted
+
+
+def test_standard_attributes_excluded(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test that standard LogRecord attributes are excluded from extras."""
+    formatted = formatter.format(log_record)
+    # Standard attributes should not appear as extras
+    assert "pathname:" not in formatted
+    assert "lineno:" not in formatted
+    assert "levelname:" not in formatted
+
+
+def test_extra_attributes_included(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test that extra attributes are included in the formatted output."""
+    log_record.user_id = "12345"
+    log_record.request_id = "abc-def-ghi"
+
+    formatted = formatter.format(log_record)
+
+    assert "user_id: 12345" in formatted
+    assert "request_id: abc-def-ghi" in formatted
+
+
+def test_default_exclude_keys(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test that DEFAULT_EXCLUDE_KEYS (message, asctime) are excluded."""
+    # Add 'message' and 'asctime' as extra attributes (shouldn't appear in extras)
+    log_record.message = "This should be excluded"
+    log_record.asctime = "2025-01-01 12:00:00"
+
+    formatted = formatter.format(log_record)
+
+    # These should not appear as extras
+    lines = formatted.split("\n")
+    extra_lines = [
+        line for line in lines if line.strip().startswith(("message:", "asctime:"))
+    ]
+    assert len(extra_lines) == 0
+
+
+def test_multiple_extras_formatting(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test formatting with multiple extra attributes."""
+    log_record.user_id = "12345"
+    log_record.session_id = "session-xyz"
+    log_record.ip_address = "192.168.1.1"
+
+    formatted = formatter.format(log_record)
+
+    assert "user_id: 12345" in formatted
+    assert "session_id: session-xyz" in formatted
+    assert "ip_address: 192.168.1.1" in formatted
+
+    # Check that extras are indented
+    lines = formatted.split("\n")
+    extra_lines = [
+        line
+        for line in lines
+        if any(key in line for key in ("user_id:", "session_id:", "ip_address:"))
+    ]
+    for line in extra_lines:
+        assert line.startswith("    ")
+
+
+def test_config_exclude_keys_from_file(log_record: logging.LogRecord) -> None:
+    """Test that exclude_keys from configuration file are properly excluded."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        config_path = Path(tmpdir) / "logging.conf"
+        config_content = """[formatter_plaintextFormatter]
+exclude_keys = custom_field, another_field
+"""
+        config_path.write_text(config_content)
+
+        # Change to temp directory to read config
+        original_dir = os.getcwd()
+        try:
+            os.chdir(tmpdir)
+            formatter = UniversalPlaintextFormatter(fmt="%(message)s")
+
+            # Add attributes that should be excluded
+            log_record.custom_field = "should be excluded"
+            log_record.another_field = "also excluded"
+            log_record.included_field = "should be included"
+
+            formatted = formatter.format(log_record)
+
+            assert "custom_field:" not in formatted
+            assert "another_field:" not in formatted
+            assert "included_field: should be included" in formatted
+        finally:
+            os.chdir(original_dir)
+
+
+def test_config_exclude_keys_with_whitespace(
+    log_record: logging.LogRecord,
+) -> None:
+    """Test that whitespace in exclude_keys configuration is handled correctly."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        config_path = Path(tmpdir) / "logging.conf"
+        config_content = """[formatter_plaintextFormatter]
+exclude_keys = field1 ,  field2  , field3
+"""
+        config_path.write_text(config_content)
+
+        original_dir = os.getcwd()
+        try:
+            os.chdir(tmpdir)
+            formatter = UniversalPlaintextFormatter(fmt="%(message)s")
+
+            log_record.field1 = "excluded"
+            log_record.field2 = "excluded"
+            log_record.field3 = "excluded"
+
+            formatted = formatter.format(log_record)
+
+            assert "field1:" not in formatted
+            assert "field2:" not in formatted
+            assert "field3:" not in formatted
+        finally:
+            os.chdir(original_dir)
+
+
+def test_no_config_file(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test that formatter works correctly when config file doesn't exist."""
+    log_record.some_extra = "value"
+    formatted = formatter.format(log_record)
+
+    # Should still format correctly
+    assert "Test message" in formatted
+    assert "some_extra: value" in formatted
+
+
+def test_empty_extras(
+    formatter: UniversalPlaintextFormatter, log_record: logging.LogRecord
+) -> None:
+    """Test formatting when there are no extra attributes."""
+    formatted = formatter.format(log_record)
+
+    # Should only contain the base formatted message without extra newlines
+    lines = formatted.split("\n")
+    assert len([line for line in lines if line.strip()]) == 1
+
+
+def test_standard_attrs_caching(
+    formatter: UniversalPlaintextFormatter,
+) -> None:
+    """Test that standard attributes are cached after first call."""
+    assert formatter._standard_attrs is None
+
+    # First call should set the cache
+    standard_attrs = formatter._get_standard_attrs()
+    assert formatter._standard_attrs is not None
+    assert formatter._standard_attrs == standard_attrs
+
+    # Second call should return cached value
+    standard_attrs_2 = formatter._get_standard_attrs()
+    assert standard_attrs_2 is standard_attrs  # Same object
+
+
+def test_formatter_with_custom_format_string(
+    log_record: logging.LogRecord,
+) -> None:
+    """Test formatter with a custom format string."""
+    formatter = UniversalPlaintextFormatter(fmt="[%(levelname)s] %(message)s")
+    log_record.extra_data = "test"
+
+    formatted = formatter.format(log_record)
+
+    assert "[INFO] Test message" in formatted
+    assert "extra_data: test" in formatted
+
+
+def test_exclude_keys_combination(log_record: logging.LogRecord) -> None:
+    """Test that all exclusion sources are combined correctly."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        config_path = Path(tmpdir) / "logging.conf"
+        config_content = """[formatter_plaintextFormatter]
+exclude_keys = config_excluded
+"""
+        config_path.write_text(config_content)
+
+        original_dir = os.getcwd()
+        try:
+            os.chdir(tmpdir)
+            formatter = UniversalPlaintextFormatter(fmt="%(message)s")
+
+            # Add various attributes
+            log_record.pathname = "standard_attr"  # Standard LogRecord attribute
+            log_record.message = "default_excluded"  # DEFAULT_EXCLUDE_KEYS
+            log_record.config_excluded = "from_config"  # From config file
+            log_record.should_appear = "yes"  # Should appear
+
+            formatted = formatter.format(log_record)
+
+            # Only should_appear should be in extras
+            assert "pathname:" not in formatted  # Standard attribute
+            assert "message:" not in formatted  # DEFAULT_EXCLUDE_KEYS
+            assert "config_excluded:" not in formatted  # Config exclude
+            assert "should_appear: yes" in formatted  # Should be included
+        finally:
+            os.chdir(original_dir)

common_logging/universal_plaintext_formatter.py

@@ -0,0 +1,94 @@
+import configparser
+import logging
+from typing import Any
+
+
+class UniversalPlaintextFormatter(logging.Formatter):
+    """
+    A custom formatter for logging that extends the standard logging.Formatter.
+
+    This formatter adds the ability to include extra attributes from log records while
+    excluding standard attributes and configurable keys.
+    """
+
+    # Predefined exclusions - keys that should always be excluded
+    DEFAULT_EXCLUDE_KEYS = {"message", "asctime"}
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Initialize the formatter with standard formatter parameters.
+
+        Args:
+            *args: Variable length argument list for the parent class.
+            **kwargs: Arbitrary keyword arguments for the parent class.
+        """
+        super().__init__(*args, **kwargs)
+        self._standard_attrs: set[str] | None = None
+        self._config_exclude_keys = self._load_exclude_keys_from_config()
+
+    def _load_exclude_keys_from_config(self) -> set[str]:
+        """
+        Load additional keys to exclude from the configuration file.
+
+        Returns:
+            set: A set of keys to exclude from log records.
+        """
+        try:
+            config = configparser.ConfigParser()
+            config.read("logging.conf")
+            if config.has_option("formatter_plaintextFormatter", "exclude_keys"):
+                exclude_str = config.get("formatter_plaintextFormatter", "exclude_keys")
+                return set(key.strip() for key in exclude_str.split(",") if key.strip())
+        except (configparser.Error, FileNotFoundError, PermissionError, ValueError):
+            pass
+        return set()
+
+    def _get_standard_attrs(self) -> set[str]:
+        """
+        Get the set of standard attributes to exclude from log records.
+
+        This includes standard LogRecord attributes, predefined exclusions,
+        and exclusions from configuration.
+
+        Returns:
+            set: A set of attribute names to exclude.
+        """
+        if self._standard_attrs is None:
+            dummy_record = logging.LogRecord(
+                name="dummy",
+                level=logging.INFO,
+                pathname="",
+                lineno=0,
+                msg="",
+                args=(),
+                exc_info=None,
+            )
+            # Combine standard attributes + predefined + from configuration
+            all_excludes = (
+                set(dummy_record.__dict__.keys())
+                | self.DEFAULT_EXCLUDE_KEYS
+                | self._config_exclude_keys
+            )
+            self._standard_attrs = all_excludes
+        return self._standard_attrs
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Format the log record, adding any extra attributes not in the standard set.
+
+        Args:
+            record: The log record to format.
+
+        Returns:
+            str: The formatted log message with extra attributes appended.
+        """
+        base = super().format(record)
+        extras = {
+            k: v
+            for k, v in record.__dict__.items()
+            if k not in self._get_standard_attrs()
+        }
+        if extras:
+            extras_str = "\n".join(f"    {k}: {v}" for k, v in extras.items())
+            return f"{base}\n{extras_str}"
+        return base