qilisdk 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

qilisdk/__init__.py

@@ -12,6 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from qilisdk import analog, common, digital, extras, utils
+from importlib.metadata import PackageNotFoundError, version
 
-__all__ = ["analog", "common", "digital", "extras", "utils"]
+from ._logging import configure_logging
+
+configure_logging()
+
+try:
+    __version__ = version("qilisdk")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = []

qilisdk/__init__.pyi

@@ -12,6 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from qilisdk import analog, common, digital, extras, utils
-
-__all__ = ["analog", "common", "digital", "extras", "utils"]
+__all__: list[str] = []
+__version__: str

qilisdk/_logging.py

@@ -0,0 +1,135 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# 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.
+
+"""config.py"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from loguru import logger
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings
+from ruamel.yaml import YAML
+
+from qilisdk.settings import get_settings
+
+if TYPE_CHECKING:
+    from types import FrameType
+
+
+class SinkConfig(BaseModel):
+    """
+    Configuration for a single Loguru sink.
+    """
+
+    sink: str | Path
+    level: str = "INFO"
+    format: str | None = None
+    filter: str | dict[str, str] | None = None
+    colorize: bool = False
+    enqueue: bool = False
+    rotation: str | None = None
+    serialize: bool = False
+
+
+class InterceptLibraryConfig(BaseModel):
+    """
+    Configuration for intercepting a stdlib logging library.
+    """
+
+    name: str
+    level: str = "ERROR"
+
+
+class LoggingSettings(BaseSettings):
+    """
+    Pydantic settings for Loguru configuration loaded from YAML or JSON.
+    """
+
+    sinks: list[SinkConfig] = []
+    intercept_libraries: list[InterceptLibraryConfig] = []
+
+    @classmethod
+    def load(cls, path: str | Path) -> LoggingSettings:
+        path = Path(path)
+        yaml = YAML(typ="safe")
+        data = yaml.load(path)
+        return cls(**data)
+
+
+class InterceptHandler(logging.Handler):
+    """
+    Redirect stdlib 'logging' records to Loguru, optionally filtering by name_prefix.
+    """
+
+    def emit(self, record: logging.LogRecord) -> None:  # noqa: PLR6301
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno  # type: ignore[assignment]
+
+        frame: FrameType | None = logging.currentframe()
+        depth = 2
+        while frame and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
+def configure_logging() -> None:
+    """
+    Load settings (path overridden by environment variable) and configure Loguru + stdlib logging intercept.
+    """
+    # Determine config path
+    config_path = Path(get_settings().logging_config_path).expanduser()
+    if not config_path.is_absolute():
+        config_path = (Path.cwd() / config_path).resolve()
+
+    settings = LoggingSettings.load(config_path)
+
+    # 1) Remove all pre-configured Loguru handlers
+    logger.remove()
+
+    # 2) Add configured sinks
+    for sink_conf in settings.sinks:
+        params = sink_conf.model_dump()
+        sink_target = params.pop("sink")
+
+        # Resolve stderr/stdout
+        if isinstance(sink_target, str) and sink_target.lower() == "stderr":
+            sink_target = sys.stderr
+        elif isinstance(sink_target, str) and sink_target.lower() == "stdout":
+            sink_target = sys.stdout
+
+        clean_params = {k: v for k, v in params.items() if v is not None}
+
+        logger.add(sink_target, **clean_params)
+
+    # 3) Quiet down noisy libraries before intercepting
+    for intercept_library in settings.intercept_libraries:
+        logging.getLogger(intercept_library.name).setLevel(intercept_library.level)
+
+    # 4) Intercept stdlib -> Loguru
+    handler = InterceptHandler()
+    logging.root.handlers = [handler]
+    logging.root.setLevel(logging.NOTSET)
+
+    for logger_name in list(logging.root.manager.loggerDict.keys()):
+        logging.getLogger(logger_name).handlers = []
+        logging.getLogger(logger_name).propagate = True

qilisdk/_optionals.py

@@ -33,12 +33,10 @@ class OptionalFeature:
     """Holds metadata about an optional feature.
 
     Attributes:
-        feature_name (str):
+        name (str):
             The name of the extras group in pyproject.toml
-        distributions (list[str]):
-            The PyPI distribution names that must be installed
-        import_path (str):
-            The Python import path to the module containing the real symbols
+        dependencies (list[str]):
+            The dependencies that must be installed
         symbols (list[str]):
             Which symbols (classes, functions, etc.) to re-export
     """
@@ -53,9 +51,9 @@ class ImportedFeature:
     """Holds the result of an optional import.
 
     Attributes:
-        feature_name (str):
+        name (str):
             A label for the feature (e.g. 'qibo-backend').
-        symbol_map (dict[str, Union[Any, Callable]]):
+        symbols (dict[str, Union[Any, Callable]]):
             A mapping from symbol name to the real or stubbed object.
             If the required dependency is missing, the symbol is a stub
             that raises an error when called.

qilisdk/analog/__init__.py

@@ -12,23 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .algorithms import TimeEvolution
-from .hamiltonian import Hamiltonian, I, X, Y, Z
-from .quantum_objects import QuantumObject, basis_state, bra, expect_val, ket, tensor_prod
+from .hamiltonian import Hamiltonian, I, PauliI, PauliX, PauliY, PauliZ, X, Y, Z
+from .linear_schedule import LinearSchedule
 from .schedule import Schedule
 
-__all__ = [
-    "Hamiltonian",
-    "I",
-    "QuantumObject",
-    "Schedule",
-    "TimeEvolution",
-    "X",
-    "Y",
-    "Z",
-    "basis_state",
-    "bra",
-    "expect_val",
-    "ket",
-    "tensor_prod",
-]
+__all__ = ["Hamiltonian", "I", "LinearSchedule", "PauliI", "PauliX", "PauliY", "PauliZ", "Schedule", "X", "Y", "Z"]

qilisdk/analog/exceptions.py

@@ -13,7 +13,5 @@
 # limitations under the License.
 
 
-class InvalidHamiltonianOperation(Exception): ...
-
-
-class NotSupportedOperation(Exception): ...
+class InvalidHamiltonianOperation(Exception):
+    """Raised when an operation cannot be applied to the current Hamiltonian."""